Przejdź do treści
Biblioteka skilli
Dokumenty i biuro · Pisanie

prose-edit

/prose-edit

Redaguje dokumenty, takie jak RDR, eseje lub wpisy w CHANGELOG, skracając je lub rozwijając, na prośbę autora.

Repozytorium
nexus ↗
Licencja
AGPL-3.0
Ostatnia zmiana repozytorium
13.11.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
4
Skrypty
3
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

Co sprawdzić przed instalacją
  • 3 skrypty w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/brief.py, scripts/memory.py, scripts/review.py

Co robi i kiedy

Redaguje dokumenty, takie jak RDR, eseje lub wpisy w CHANGELOG, skracając je lub rozwijając, na prośbę autora.

Oryginalny opis (EN)

Use when the author asks to line-edit, tighten, cut or unpack a document (an RDR, reference doc, essay, CHANGELOG entry, web page, or text pasted in for a commit message), to list or remove a document's stored rejections, to add an exemplar passage to a genre, or to set prose-edit up in a repository. Invoked as /prose-edit.

Jak działa

  1. Invocation
  2. Steps
  3. Rules
  4. Asking the author
  5. Setup run
Sekcje z nagłówków SKILL.md, w oryginale · 173 linii, 6 546 słów
Podgląd SKILL.md
---
name: prose-edit
description: Use when the author asks to line-edit, tighten, cut or unpack a document (an RDR, reference doc, essay, CHANGELOG entry, web page, or text pasted in for a commit message), to list or remove a document's stored rejections, to add an exemplar passage to a genre, or to set prose-edit up in a repository. Invoked as /prose-edit.
disable-model-invocation: true
allowed-tools: Bash(python3 ${CLAUDE_PLUGIN_ROOT}/skills/prose-edit/scripts/*)
---

# Prose edit

Arguments: $ARGUMENTS

Run every command from the directory this session started in. Never run `cd`, and put nothing in front of a command and nothing after it: no `;`, `&&`, `||`, `|` or `echo` joined to it. The exit code comes back with the result, and a command with anything joined to it no longer matches the permission rule, so it is refused. Write the command prefix of the table below exactly as it is shown: unquoted, with no `./` and no `cd` before it. The skill's permission rule matches that text, and a quoted or `./`-prefixed script path, or a `cd '<dir>' &&` in front, does not match it. Pass each argument as its own argv token. Never build a shell string from the arguments. Only the arguments after the prefix go in single quotes (a single quote inside one is written `'\''`): a path with a space or a `;` is author input, and so is every token. In a command below, the names of the first column (BRIEF, MEMORY, REVIEW) stand for the prefix text of their row, typed as it is shown, and a `<placeholder>` stands for one argument in single quotes.

| Name | Command prefix |
| --- | --- |
| BRIEF | `python3 ${CLAUDE_PLUGIN_ROOT}/skills/prose-edit/scripts/brief.py` |
| MEMORY | `python3 ${CLAUDE_PLUGIN_ROOT}/skills/prose-edit/scripts/memory.py` |
| REVIEW | `python3 ${CLAUDE_PLUGIN_ROOT}/skills/prose-edit/scripts/review.py` |

A document in another checkout (a git worktree, say) is named by its absolute path: the scripts take the repository from the path, so the edit lands in that checkout.

## Invocation

| Form | Meaning |
| --- | --- |
| `<path>[:<start>-<end>] [--genre G] [--budget N]` | Edit run. Budget defaults to 10. A range limits proposals to those lines. |
| `<path>[:<start>-<end>] --mode cut-only --voice-card F --word-budget N [--genre G] [--budget N]` | Cut-only run. Not run here: the site-page review gate runs it through the `conexus-prose-edit:prose-cut` skill, which a model can invoke and this command cannot. |
| `- --genre G [--budget N]` | Stdin run. The flags are the first line. The text is everything after the first newline. Nothing is applied. |
| `rejections <path> [--remove N]` | List a document's stored rejections, or remove number N. |
| `exemplar <genre> <path>:<start>-<end>` | Store that passage as an exemplar of the genre. |
| `setup` | Check and finish what runs in this repository need. Run it once per machine and once per repository. |
| `-- <path>` or `./<path>` | A file named `rejections`, `exemplar`, `setup`, `decide` or `count`. |

## Steps

1. Run `BRIEF parse <token>...` with the arguments as tokens. For a stdin run pass only `-` and the flags to `parse`. Never pass the text. On exit 1, show stderr to the author and stop, except a stdin run whose stderr says `needs --genre`: ask the genre question of step 4's `no genre` row with `reference-doc` suggested and no remember question (a stdin run has no folder), then run `parse` again with `--genre`. A null `genre` in the output only means the flag was not given for a path run. Never ask the author for a genre because of it: a null `genre` after `parse` is not a reason to ask, at this step or at any step before step 4. Go on to step 2: step 4 finds the genre from the path and reports when none exists, and only that report (`build` exits 1 with `no genre` in stderr) is a reason to ask. On any failure, show stderr and stop.
2. Branch on `mode` in the JSON.

   | mode | Do |
   | --- | --- |
   | `rejections` | Run `MEMORY <memory_argv...>`. Show the numbered rejections. Stop. |
   | `exemplar` | Run `MEMORY <memory_argv...>`. Show the stored passage and `duplicate`. Stop. |
   | `setup` | Follow the Setup run section below. Stop. |
   | `cut-only` | Not run here. Tell the author that cut-only runs through the `conexus-prose-edit:prose-cut` skill, which the site-page review gate calls, and stop. |
   | `decide`, `count` | The same: they belong to the `conexus-prose-edit:prose-cut` skill. Tell the author and stop. |
   | `edit` | Continue. |

   If a `MEMORY` command fails, show stderr and stop.
3. Fix the input.

   | `stdin` | Do |
   | --- | --- |
   | false | Use `target` from step 1. |
   | true | Take the text after the first newline of the message. If there is none, ask the author to paste it and end your turn: no WORK exists yet. Otherwise run `BRIEF tmpdir --ready`. It prints eight lines, `WORK=`, `INPUT=`, `REPLY=`, `FILTERED=`, `REASONS=`, `ANSWERS=`, `ENTRY=` and `CARD=`, each a full path. Write the text with the Write tool to the `INPUT=` path. Use `-` as the target and `--file '<input>'`. |

4. Build the brief. Both runs print a header, a blank line, and then the brief.

   | `stdin` | Run |
   | --- | --- |
   | false | `BRIEF build <target> --budget <budget> [--genre <genre>] --work`. The header is six lines: `WORK=<dir>`, `DISPATCH=<prompt>`, `REPLY=<path>`, `FILTERED=<path>`, `REASONS=<path>` and `ANSWERS=<path>`. The brief is everything after the blank line. |
   | true | `BRIEF build - --budget <budget> --genre <genre> --file '<input>'`. The header is one line, `DISPATCH=<prompt>`. The brief is everything after the blank line. |

   Either way `build` has written the brief to `brief.md` in the work directory, which ends with the line `Brief id: <id>`. The line-editor reads that file and echoes the id. The id is in the file and nowhere else: never put one in the prompt. The `DISPATCH=` line is the whole prompt for step 7, with the full path of that file already in it. The brief printed here is for you to check step 6.

   | Result | Do |
   | --- | --- |
   | exit 0 | Continue. |
   | exit 1, stderr contains `no genre` | Never choose a genre yourself. Run `BRIEF suggest-genre '<path>'` (the `path` from step 1, without a range). It prints `folder_key`, `suggested`, `ranked` and `descriptions`. Ask the author which genre applies with one `AskUserQuestion` call of two questions. End your turn with that question and do nothing else. Genre question (header `Genre`): the options are `suggested` with `(Recommended)` and the next two of `ranked`, each described by its line in `descriptions`; the question text names the document and the three genres left out, which "Other" accepts. Only an exact genre name is a genre: an "Other" answer that is not exactly one of `rdr`, `reference-doc`, `how-to`, `exploration-essay`, `changelog` or `commit-message` is never passed as `--genre` or stored; say so and ask the genre question again. Remember question (header `Remember`): "Remember this for `<folder_key>`?" with "Yes, remember (Recommended)" and "Just this run". Run this step again with `--genre` only after the author answers. For "Yes, remember", also store `<folder_key>=<genre>` as one `genre_map` entry the way step 4 of the Setup run does (a fresh work directory made as step 3 of the Steps list does, `MEMORY add-entry --level repo --from-stdin`, then `BRIEF rmtmp '<work>'`). |
   | any other non-zero exit | On any failure, show stderr and stop. |

5. WORK is the directory on the `WORK=` line of step 3 or 4. It holds the marked-up copy and the saved proposal until step 12 deletes it. Every path in the steps below comes from a header line of step 3 or 4 and is used exactly as printed: `<work>` is the `WORK=` path, `<input>` the `INPUT=` path, `<reply>` the `REPLY=` path, `<filtered>` the `FILTERED=` path, `<reasons>` the `REASONS=` path, `<answers>` the `ANSWERS=` path (the `ENTRY=` and `CARD=` paths are for step 13). Never type the word WORK as a path and never build a path yourself. Never create a directory named WORK, in the repository or anywhere else: Write makes a missing directory without a word, and the stray one shows in the author's `git status`. A path that is not on a header line is not yours to invent: stop and tell the author. On every stop after WORK exists and before step 12, delete WORK first with `BRIEF rmtmp '<work>'`. Step 11, the answer route and a retry in step 12, and a retry of step 9 or step 10 after exit 3 are the exceptions: the turn ends there with WORK in place.
6. If the brief contains `No exemplars are stored`, tell the author the genre has no exemplars yet and the editor runs without them. If it contains `all come from this document`, tell the author the genre's only exemplars are from this document, so the editor runs without them.
7. Dispatch the `line-editor` agent with the Agent tool (`subagent_type` `conexus-prose-edit:line-editor`, `run_in_background` false). The prompt is the text after `DISPATCH=` on the header line of step 4, exactly as printed: copy it whole, change nothing, add nothing, and never type a path yourself. It already holds the full path of the brief and the instruction for the id; `<id>` stays as shown, because you do not know it. Do not paste the brief into the prompt. If the line-editor says it cannot read the brief, stop and show the author its error and tell the author to run `/prose-edit setup`: do not create a directory or a link in the repository and do not list the work directory. Wait for its reply. The harness may run the agent in the background even so: then the tool result only says the agent started, and the reply comes later as a message from the agent (its report). Wait for that message and do nothing else meanwhile.
8. Write the agent's whole reply, once, with the Write tool to the `REPLY=` path: the tool result, or the report text of the agent's message. Keep its indentation and its ```json fence as they are: the filter reads both. Never copy the reply with Bash (a heredoc or `echo`): a quote or the delimiter inside the reply breaks the copy.
9. Run `BRIEF filter <target> --budget <budget> --save '<filtered>' [--file '<input>'] < '<reply>'` (`<filtered>` is the `FILTERED=` path, `<reply>` the `REPLY=` path). Its output is the filtered proposal and the saved file holds the same text. A `warnings` entry about `brief_sha` means the editor's reply does not carry the id on the last line of `brief.md` in the work directory, so it did not read the file to its end. A `warnings` entry about `voice_card` means the editor's card is not the author-approved card the brief gave it. Show each to the author with the others in step 10. On exit 3 (a T2 outage; the `REPLY=` file holds the editor's work): show stderr, keep WORK, tell the author, end your turn, and run this step again when the author says to retry. On any failure, show stderr and stop.
10. Run `REVIEW render <target> --work '<work>' [--file '<input>'] [--genre <genre>]`. A stdin run passes `--file '<input>'` and the genre it was given. A path run passes `--genre` only when the author gave one. If `REVIEW render` fails with exit 3 (T2 became unavailable after the editor ran), keep WORK: show stderr, tell the author, end your turn, and run the same command again when the author says to retry. Any other failure: show stderr and stop. Tell the author where the marked-up copy is (`copy`) and whether it opened in the viewer (`opened`; when false, `reason` says why and the path is how to read it). Show each filter `warnings` entry and each `unplaced` edit with its cause. If `opened` is false, also show the filtered proposal:

    | Part | Show |
    | --- | --- |
    | `note` | The editor's note. |
    | `voice_card` | The voice card. |
    | `paragraphs` | Each as `[P<n>] <action>: <paragraphs>. <advice>`. |
    | `edits` | Each as `<n>. <old> -> <new> (<reason>)`. |
    | `queries` | Each as `[Q<n>] <anchor>: <text>`. |
    | `dropped` | Each as `<n> <old> -> <new> (<cause>)`. The author cannot see these edits in the copy otherwise. |
    | `dropped_queries`, `dropped_paragraphs` | Each as `<n> <anchor or paragraphs> (<cause>)`. |

11. If the filtered proposal has no `edits` (the editor proposed none, or the filter dropped every one), there is nothing to accept or reject: do not ask for numbers. Show the note, the paragraph proposals, the queries, each filter `warnings` entry and each `dropped` edit with its cause (so the author sees why no edit is left). If there is a query or a paragraph proposal, ask the author with `AskUserQuestion` whether to answer any of them with a change, in the query question below, and end your turn; a change goes through the answer route of step 12. With no query, no paragraph proposal, or an answer that asks for no change, go to step 12 with `--accept none` and no other spec. Run its dry run and then, without asking, the same command without `--dry-run`: it changes no file, logs the session and deletes WORK. Otherwise ask the author with `AskUserQuestion`, one call at a time and in this order. Each call ends your work for the step until the author answers. Never choose the numbers yourself.

    First say, in two sentences at most, what the answers do. Accept puts the edit's new text in the document. Reject keeps the document's text as it is and stores the edit, so the editor does not propose it again for this document (a stdin run stores none). An edit the author neither accepts nor rejects is left undecided: the text stays as it is and nothing is stored for it. Offer only the edits that were placed: an edit listed as one that cannot be placed is not offered, and `reject the rest` leaves it alone.

    1. Queries and paragraph proposals, only when the proposal has any. One question, header `Answer`: "Answer a query or paragraph proposal with a change?" with "No (Recommended)" and "Yes". Put what it asks about in the question text: the text of the query when there is one, or the count and the first one (`[Q1] <anchor>: <text>`) when there are several; likewise a paragraph proposal. On "Yes", ask in plain words which one and what the change is, end your turn, and take the answer through the answer route of step 12; then return here for the edits, new ones included. A change the author makes this way is the author's own edit: it can be accepted or held, never rejected.
    2. Accept. Split the placed edits, in order, into groups of 2 to 4 that are as even as possible: 2 to 4 edits are one group, 5 edits are 3 + 2, 6 are 3 + 3, 7 are 4 + 3, 9 are 3 + 3 + 3, 13 are 4 + 3 + 3 + 3. One multi-select question per group, up to four questions in one call (sixteen edits), with the text "Which edits do you accept?". The header names the group's own edit numbers, its first and its last, as in `Edits 3-6` (edit numbers have gaps when an edit was unplaced or dropped; the options name each edit exactly), at most 12 characters. Each option is one edit: label `Edit <n>`, description the reason first and then the words that change, `<reason>: <old words> -> <new words>`. Show the changed words with a few words of context, not the whole sentence cut off where it happens to end, and shorten the reason before you shorten the change. The author ticks none, some or all; a submission with nothing ticked means none accepted from that group. A single placed edit is one single-select question with the header `Edit <n>` and the options "Accept it" and "Leave it undecided". If more than 16 placed edits remain, offer the first 16 this way and ask for the rest in plain words as step 12's free-text route describes, naming the numbers left.
    3. The rest. When any edit offered in the accept questions went unticked, one question, header `Others`: "What about the edits you did not accept?" with "Leave undecided (Recommended)" (they are held: the text stays and nothing is stored), "Reject them all" (declines every edit you showed in the accept questions and did not get ticked; on a file run each is stored as a rejection for this document, on a stdin run none is stored; the text stays as it is) and "Choose which to reject". "Reject them all" covers only the editor's own edits the accept questions offered, never an overflow edit the author was not asked about and never an edit the author added through the answer route: those stay held. For "Choose which to reject", ask a follow-up multi-select call in groups made as the accept question makes them (header `Reject 3-6`; a single edit is one single-select question with the options "Reject it" and "Leave it undecided"), offering only the edits that were not accepted and are the editor's own; the ones the author does not tick are held. Rejection reasons are optional. Take one only from words the author wrote (the "Other" text of any of these questions, or the author's notes in conversation), never invent one, and write it through `REASONS=` as step 12 says. An "Other" answer that names explicit edit numbers is a spec of the free-text route; one that names none is asked again.

12. When the author answers a query (`Q<n>`) or a paragraph proposal (`P<n>`) with a change, never edit the document yourself. Write each change as exact text: `old` copied word for word from the document, `new` the text the author asked for, `answers` the `Q<n>` or `P<n>` it answers. Write them all as one JSON list `[{"answers": "Q4", "old": "...", "new": "..."}]` with the Write tool to the `ANSWERS=` path and run `REVIEW answer --work '<work>' --from-file '<answers>'`. It prints the new edit numbers, or on exit 1 says which `old` it cannot place (not found, ambiguous, protected): fix that entry (quote more of the text) and run it again; nothing is added until every entry places. Then run step 10's `REVIEW render` again, show each added edit as `<n>. <old> -> <new> (answers Q<n>)`, and go back to the edit questions of step 11, the added edits among them. An added edit is the author's own: it can be accepted or held, never rejected, and nothing is stored for it.

    Build the specs from the author's picks in step 11 as explicit numbers: `--accept` the numbers ticked in the accept questions, `--reject` the numbers of the rejected edits (every edit the accept questions offered and the author did not tick for "Reject them all", leaving out the author's own added edits, the ticked ones for "Choose which to reject"; none for "Leave undecided"), `--hold` every placed edit that is in neither, so nothing is rejected that the author did not pick. Write the reasons the author gave as step 11 says. When the author answers in words instead (the overflow past sixteen edits, or "Other" text that names numbers), turn the answer into an accept spec, a reject spec when the author rejects anything, and a hold spec when the author names edits to hold. A spec is explicit numbers and ranges (`1, 3-5`), `all` or `none`, in the author's own words. The reject spec may also be `rest`, only when the author says "reject the rest" or "reject everything else". Never reject an edit the author did not name: an edit the author leaves out is held, and so is every edit when the answer is "accept 1" or "none". For each reason the author gives, write all of them as one JSON object `{"<n>": "<the author's words>"}` (one key per rejected edit) with the Write tool to the `REASONS=` path, and pass `--reasons-file '<reasons>'`. Never put the author's words on the Bash line. If the answer names no explicit numbers (for example "all but 2", "the cuts", "looks good", "edit one", "no"), or `REVIEW` refuses it, ask the author again for explicit numbers and end your turn; never compute, infer or choose the set yourself.

    Run `REVIEW apply --work '<work>' --accept <spec> [--reject <spec>] [--hold <spec>] [--reasons-file '<reasons>'] --dry-run`, each spec as one argv token. `--accept` may be left out when the author accepts nothing: it defaults to `none`. It prints the sets it understood and changes nothing. Show the author `accept` (the new text goes in), `hold` (undecided: the text stays, nothing stored) and `reject` (the text stays as it is, and the edit is stored), each as `<n>. <old> -> <new>`, with its `reason` when it has one, `unplaced` (the edits the copy could not show, which are left alone) and `would_skip` (each with its `cause`). Say that only the edits under `reject` are stored as rejections for the document (`stores_rejections`; a stdin run stores none). Then call `AskUserQuestion` with one question, header `Apply`, "Apply these changes?" and the options "Apply (Recommended)", "Change my picks" and "Cancel", and end your turn (in the no-edits close of step 11, do not ask: run it at once). When the author picks "Apply", run the same command without `--dry-run`. On "Change my picks", or when the author changes a number, ask step 11's questions again and run the dry run again. On "Cancel", run `BRIEF rmtmp '<work>'`, tell the author nothing was changed or stored, and stop. The script refuses a real apply that no matching dry run came before (the same answer, the file not saved since): exit 1 with `dry run` in stderr, nothing written, WORK still there. Run the dry run, show it, and ask the author to confirm; never skip it.

    On exit 1 with `--accept`, `--hold`, `--reject`, `--reason` or `--reasons-file` in stderr (a number that is not an edit, an edit named twice, an answer that is not numbers, or a reasons file that is not valid), show stderr and ask again; WORK is still there. On exit 2 (a usage error: nothing ran), keep WORK, show stderr, fix the command and run it again. On exit 1 with `expired` in stderr, the work directory was swept after two hours idle and the review in it is gone: there is nothing to delete, so tell the author and start again at step 1. On exit 3, or exit 1 with `run apply again` in stderr (T2 unavailable or refusing, the file changed while the edits were applied, mixed line endings, a permission or disk problem), apply did not change the file (a change the author saved meanwhile is the author's own) and WORK is still there: keep WORK, show stderr, tell the author the cause, and ask the author to say when to retry; on retry run the dry run again, show it, and run the real apply after the author confirms. On any other failure, delete WORK, show stderr and stop. A successful apply has already deleted WORK (unless it reports `log_error`, below); do not delete it again. Show the author:

    | Part | Show |
    | --- | --- |
    | `applied` | Each as `<n>. <old> -> <new>`. A stdin run applies nothing. |
    | `skipped` | Each as `<n> skipped: <cause> (<detail>)`. The edit stays in the file as it was. |
    | `rejected` | The numbers the author rejected. A path run stored them as rejections for the document, each with its reason when it had one. A stdin run stores none: say they were declined. |
    | `held` | The numbers left undecided: not applied, nothing stored. |
    | `unplaced` | The numbers the copy could not show. They were not stored. |
    | `log_error` | When present: the file was written but the session log was not, and WORK is still there. Tell the author the edits are in the file and the session is not yet in the accept-rate record, then run `REVIEW log-retry --work '<work>'` (now, and again when the author says T2 is back). It prints `log` and deletes WORK. If it fails, show stderr, keep WORK and stop; a WORK idle for more than two hours may be swept when the next one is made. Never run apply again for it. |
    | `staged_beside_document` | When present: the new text was staged beside the document, not in the git directory. Say so; nothing else to do. |
    | `text` | A stdin run only: the text with the accepted edits applied, in a code block. |

13. Offer to keep what the author taught you. Each offer is an `AskUserQuestion` call that shows the text that will be stored in the question, so choosing an option is the yes. Do any of these only after the author has read the text that will be stored and has said yes by choosing to keep it.
    - A correction in the answer or in conversation (for example "lead with the point here"): write it as a diagnostic that states its exception, then ask one question, header `Keep`: "Keep this correction for later runs?" with the text in the question and the options "This repository (Recommended)", "All my repositories" (user level), "This document only" (a stdin run has no document level, so leave it out) and "Do not keep". End your turn with it. Make a fresh work directory as step 3 of the Steps list does, with the command of its stdin row: it prints the `ENTRY=` path. Write `{"scalars": {}, "lists": {"diagnostics": ["<text>"]}}` with the Write tool to its `ENTRY=` path, run `MEMORY add-entry --level <level> [--path <path>] --from-stdin < '<entry>'`, then `BRIEF rmtmp '<work>'` for its `WORK=` path.
    - A correction that targets a rule of the site-page style sheet, section 3 (for example "no motivate-a-new-thing rule on this essay"; the no-semicolons rule needs no entry, because the brief drops it for an exploration essay by genre): find the rule in the brief's section 3 and copy its first words, then ask two questions in one call, with the rule's opening words and the reason in the question text: which treatment the author wants for it (header `Treatment`: "Ignore the rule", "Query only" or "Editor's note only") and which level it belongs to (header `Level`: "This repository (Recommended)" or "This document only"). The two answers are the confirmation. End your turn with it. Make a fresh work directory as step 3 of the Steps list does, with the command of its stdin row. Write `{"scalars": {}, "lists": {"<key>": ["\"<opening words>...\" (<why>)"]}}` with the Write tool to its `ENTRY=` path, where `<key>` is `site_page_section3_ignored`, `site_page_section3_query_only` or `site_page_section3_note_only`. The entry has the form `"<opening words>..." (<why>)`: the rule's opening words in double quotes, three dots inside the closing quote, then the reason in parentheses. Run `MEMORY add-entry --level <repo|doc> [--path <path>] --from-stdin < '<entry>'`, then `BRIEF rmtmp '<work>'`. A stdin run has no document level. The next build applies the narrower layer's treatment to that rule.
    - The voice card the editor returned (`voice_card` in the filtered proposal, step 10). A path run only: a stdin run has no document, so it stores no card.
      1. Run `MEMORY voice-card <path>`. When `voice_card` is not null, a card is already stored and this run's brief used it as the anchor: offer nothing, unless the author asks to replace it, and stop here. When it is null (none is stored), go on.
      2. Offer to keep the card as this document's author-approved voice card: later runs start from it instead of rebuilding it from text the editor has already edited. Ask one question, header `Voice card`, with a plain sentence saying what a voice card is (the editor's short description of how this document sounds, kept so later runs hold that voice) and the card text in the question: "Keep this voice card for this document?" with "Keep it (Recommended)" and "Not now". When the author types a change in "Other", show the card with that change and ask once more. End your turn with that question.
      3. When the author says yes by choosing "Keep it", make a fresh work directory as step 3 of the Steps list does and write `{"voice_card": "<the card text>"}` with the Write tool to its `CARD=` path. Store the text as the author left it after any change.
      4. Run `MEMORY voice-card <path> --from-stdin < '<card>'`, then `BRIEF rmtmp '<work>'`.
      5. In your reply, show the stored card back verbatim: copy the `voice_card` text that the command of sub-step 4 printed, whole, into the reply. Do not summarize it, do not paraphrase it, and do not reply "Done" or "Stored" without the text: the author has not seen the card that is now stored until you show it.
    - An edit the author says is never a defect:
      1. Run `MEMORY promote <path> <n> --level <user|repo> --dry-run`, where `n` is the number in `MEMORY rejections <path>`.
      2. Show the entry, quoted exactly as `<old> -> <new>`, taking `old` and `new` from the `entry` of the dry-run output, word for word. Do not paraphrase it, shorten it or describe it in your own words: the author confirms the text that will be stored, so the author must see that text. Then say what it does once stored: the editor is told never to propose that change, and the filter drops any edit that makes it, in every document at that level.
      3. Ask the author to confirm with one `AskUserQuestion` question that carries the entry as `<old> -> <new>` and what it does once stored, with the options "Store it (Recommended)" and "Do not store", and end your turn.
      4. When the author confirms, run the same command without `--dry-run`. The script refuses a real promote that no matching dry run came before (the same rejection and level, within two hours): exit 1 with `dry run` in stderr, nothing stored. Run the dry run, show it, and ask again; never skip it.

## Rules

| Rule |
| --- |
| Never change the document except through `REVIEW apply`. |
| Never write to T2 except through MEMORY and REVIEW. |
| Never pass the author's text in a shell string. |
| On any failure, show stderr and stop. |

## Asking the author

Every question to the author goes through the `AskUserQuestion` tool, so the author picks from a short list instead of writing prose. The steps say what to ask. A question ends the turn's work until the author answers: call the tool, then stop, and never answer for the author. The tool's limits:

| Limit | Rule |
| --- | --- |
| Questions per call | 1 to 4. |
| Options per question | 2 to 4. The tool adds an "Other" choice with free text to every question, so never list one yourself. |
| Option label | At most five words. The description beside it says what choosing it does. |
| Header | A short chip of at most 12 characters. |
| Recommended option | List it first and end its label with `(Recommended)`. |
| Several answers | `multiSelect: true`, for a question where the author may pick more than one. `preview` goes only on a single-select question. |

When `AskUserQuestion` is not available (a headless `claude -p` session) or the call fails, ask the same question in plain text: the question, then its options as a numbered list with each description, the recommended one first. End your turn and read the author's reply as the choice. Never pick for the author because the tool is missing.

What the author must read to choose (a stored passage, an entry, an edit) goes in the question text or an option's description, not only in your reply. The author's pick is the decision; text typed into "Other" is the author's own words.

## Setup run

Setup is a short wizard. It asks only about what is missing, asks every question with `AskUserQuestion` (see above), and changes nothing without the author's pick. Never show the raw JSON of `BRIEF setup` unless the author picks "Show me the JSON".

1. Run `BRIEF setup`. It prints JSON. On any failure, show stderr and stop.
2. `nexus.found` false: say in one plain sentence that prose-edit keeps its memory in Nexus, that Nexus is not installed on this machine, and that `/conexus:setup` installs it, then stop. `t2.reachable` false: say in one sentence what `t2.detail` reports, that Nexus must answer before any run, and that `/conexus:setup` fixes it, then stop.
3. `allow_rules.missing` not empty: say in one sentence why the rules are needed: a run keeps its work files in the temp folder, and without the two rules every read and write of one asks the author and the line-editor cannot read its brief. A plugin cannot ship permission rules. Ask one question, header `Permissions`: "Add the two temp-folder permission rules to ~/.claude/settings.json?" with these options.

   | Option | Description | Then |
   | --- | --- | --- |
   | Add them (Recommended) | I merge the two rules into permissions.allow; Claude Code shows its own approval prompt for that edit. | With the Edit tool, add each rule of `allow_rules.missing` to `permissions.allow` of `~/.claude/settings.json`. Change nothing else in the file and never write `settings.local.json`. Read the file only to place the edit and do not repeat its other contents. When `allow_rules.settings_found` is false (the file is missing or is not valid JSON) or the edit is declined, take "Show me the JSON" instead. Run `BRIEF setup` again and go on only when `allow_rules.missing` is empty. |
   | Show me the JSON | I print the JSON and say where it goes; you add it. | Show `allow_rules.json` as a JSON block to merge into `permissions.allow` of `~/.claude/settings.json`. Both rules are needed: `Edit()` covers the Write tool and the line-editor's Read, and only `Read()` covers the `<` redirect of step 9 of the Steps list. Then ask one question, header `Rules in?`: "Have you added the two rules?" with "Rules are in (Recommended)" and "Skip for now", and end your turn. On "Rules are in" run `BRIEF setup` again and go on from this step; on "Skip for now" do what the Skip row does. |
   | Skip | Nothing changes. | Say that every Read and Write of a work file will ask, and the line-editor will not be able to read its brief, until the rules are added. Go on. |

4. Genres. A genre is the kind of writing a document is; it sets what the editor looks for and whether it may add words. The built-in map covers `docs/rdr/*.md` (rdr), `docs/exploration/*.md` (exploration-essay), top-level `docs/*.md` (reference-doc), `web/*.html` (how-to) and `CHANGELOG.md` (changelog). When `genre_candidates` is empty, go to step 5. When it holds one candidate, skip the `Genres` question and ask that candidate's question below at once. Otherwise ask ONE question first, before any per-folder question, header `Genres`: the question text opens with the sentence "A genre is the kind of writing a document is; it sets what the editor looks for and whether it may add words.", then lists every candidate as `<key> (<files> files) -> <suggested>` (`1 file` for one), one per line, each suggested genre followed by its line from `genre_descriptions`, and the options are "Use my suggestions (Recommended)" (every candidate gets its suggested genre), "Go one by one" (a question for each candidate, below) and "Ask me when I edit" (nothing is mapped; a run on a file asks for its genre then). The author's pick is the confirmation.

   - "Use my suggestions": map every candidate to its `suggested` genre in a single `add-entry` (the entry below, with the key exactly as `genre_candidates` printed it: `notes/=how-to`, `README.md=reference-doc`).
   - "Go one by one": ask one question per candidate, up to four per `AskUserQuestion` call and two calls at most (the report holds eight). Each question: text "What kind of writing is `<key>`?" with the file count and `sample` in it, header the last folder name of the key or the file name, cut to 12 characters (`docs/runbooks/` is `runbooks`, `README.md` is `README.md`), and four options: `suggested` with `(Recommended)`, the next two of `ranked`, and "Leave unmapped". An option's description is that genre's line in `genre_descriptions`; for "Leave unmapped" it is "Files there stay unmapped; a run on one asks for a genre." The three genres the options leave out are named in the question text, which "Other" accepts, but only an exact genre name counts: an "Other" answer that is not exactly one of `rdr`, `reference-doc`, `how-to`, `exploration-essay`, `changelog` or `commit-message` is never stored; say so and ask that question again.
   - "Ask me when I edit": store nothing and go on to the summary.

   To store the picks, make a fresh work directory as step 3 of the Steps list does, with the command of its stdin row, write `{"scalars": {}, "lists": {"genre_map": ["<key>=<genre>", ...]}}` with the Write tool to its `ENTRY=` path, run `MEMORY add-entry --level repo --from-stdin < '<entry>'`, then `BRIEF rmtmp '<work>'`. `MEMORY add-entry` refuses an entry whose genre is not one of the six (exit 1): show stderr and ask again. Leave the entry out when nothing was mapped. Then show one line of what was mapped, such as `Mapped docs/runbooks/ as how-to, README.md as reference-doc.`. When `unmapped_other` is above 0, add one sentence: that many other Markdown and HTML files were not offered, they still work, and a run on one asks for a genre.
5. Run `BRIEF setup` again when step 3 or step 4 changed anything, and read `exemplars`, `genres_in_use`, `ready` and `try_path` from that run. Exemplars: the editor imitates stored example passages, and a genre with none runs on the style sheet alone. When a genre in `genres_in_use` has 0 in `exemplars`, ask one question, header `Examples`, with those genres named in the question text and this sentence in it: "An example is a few lines of your own writing that you like; the editor matches its voice. Without one it follows the general style rules.": "Later (Recommended)" or "Add one now". On "Add one now", for each such genre ask the author in plain words for a passage the author likes (a path and a line range, two to ten lines), Read those lines, then ask one question, header `Store it?`, with the passage in the question text: "Store it (Recommended)" or "Skip this genre". On "Store it", run `MEMORY exemplar-add '<genre>' '<path>:<start>-<end>'` and show what it stored.
6. Close. When `ready` is true, say "Ready." and, in a line or two, what is set: the folders mapped, the genres that have examples, and whether the repository has a site-page layer. Then, when `try_path` is not null, `Try: /conexus-prose-edit:prose-edit '<root>/<try_path>'`, with `<root>` the `root` of the report, so the command works from any folder, in single quotes so a space in the path does no harm; when it is null, say there is no Markdown or HTML document to try yet and a run takes any file path. When `ready` is false, say what is still missing and how to fix it: the permission rules (run `/conexus-prose-edit:prose-edit setup` again and pick "Add them"). Do not call a setup that is not ready "ready".
Pliki w paczce (4)
  • SKILL.md 37 KB
  • scripts/brief.py 103 KB
  • scripts/memory.py 72 KB
  • scripts/review.py 69 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · hellblazer/nexus100AGPL-3.0
hellblazer/nexus100AGPL-3.0
Mikefluff/skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 606481d5b0fa (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90ghostless-edit
    Redaguje własny szkic: skraca, tnie i zgłasza zastrzeżenia, zachowując styl autora i bez dopisywania faktów.
  • 100rdr-research
    Dodaje, śledzi i weryfikuje ustrukturyzowane wyniki researchu dla aktywnego RDR.
  • 87edit
    Przepisuje dokumenty techniczne, plany i specyfikacje według czternastu zasad Hemingwaya: krótkie zdania, strona czynna, konkrety.
  • 85red-pen
    Redaguje tekst pod kątem jasności, zwięzłości i typografii, czyli korekta liniowa bez zmiany sensu.
  • 95writing-prose-like-a-human
    Redaguje tekst tak, by ograniczyć ogólnikowe sformułowania, zawyżone twierdzenia i powtarzalną strukturę, zachowując głos autora.
  • 100rdr-show
    Pokazuje szczegóły wybranego RDR: treść, wyniki researchu i powiązane beads.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.