@ersbeth/codelife 0.0.0-bootstrap.0 → 0.11.1

package/skills/audit/templates/lens.md

@@ -0,0 +1,44 @@
+<!-- generated by codelife — /audit -->
+# Lens {{ID}} — {{name}}
+
+*A **domain lens**: specific to this repository, versioned with it in `docs/audit/lenses/{{ID}}.md`, and
+grown by every campaign that runs it. The plugin's own lenses live in the plugin; this one lives
+here because nobody else has this domain.*
+
+*Its `{{ID}}` is the shortest uppercase word or acronym that reads on its own — `GUARD`, `DEPS`,
+`A11Y` — and never a single letter: every finding this lens files carries the id in the tracker's
+list, where a letter tells a reader nothing.*
+
+## Objective
+
+{{Two sentences, copied into the report by /audit. What this lens is for, and what it refuses to
+be about — a lens whose objective is "quality" finds nothing.}}
+
+## Questions
+
+{{What a reader who knows this domain would ask of the code. Written as questions, not as a
+checklist of rules: a question survives a refactor, a rule does not.}}
+
+- {{…}}
+
+## Probes
+
+{{What to search and list — a pattern, over which files — and which of `verify`'s outputs to read,
+with what each answer means. A lens runs no command, and a probe someone else cannot repeat next
+campaign from these lines is not a probe, it is a memory.}}
+
+- {{…}}
+
+## For a change
+
+{{What a change to this domain must hold — or **No** — <why the lens does not bear on a change>,
+a legitimate answer for a lens that only makes sense over a whole tree. `/work`'s plan draws its
+objectives from the plugin's lenses alone, never from this file.}}
+
+## Signals learned
+
+{{Defects actually met in this repository, worth looking for by default from now on. This section
+is the reason a domain lens is versioned rather than improvised: it is where a campaign's
+experience survives the campaign.}}
+
+- {{…}}

package/skills/brainstorm/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: brainstorm
+description: Think a topic through with the user, one question at a time — the options rejected and why, the decisions — then write them into the specification.
+argument-hint: "<topic>"
+---
+
+# /brainstorm
+
+Settles **one topic** with you, keeping a dated note under `docs/brainstorm/` as the session's
+working memory, then writes its decisions into `docs/spec/` and deletes the note in one
+`docs(spec)` commit. It files nothing — `/roadmap` does — decides nothing alone and implements
+nothing.
+
+## Preconditions
+
+- `docs/brainstorm/` exists; absent, stop and name `/setup`, which creates it.
+- `git status --porcelain docs/spec` prints nothing: a hand edit would be swept into the exit's
+  commit. Name the files and stop — unless it is a cut exit's own writing (Parameters).
+- `codelife form spec` holds the specification in the form. A `docs/spec/` with nothing but its
+  `README.md` stops, naming `/setup`, which writes the seven entries. Any other one not in the form
+  takes one topic, the adoption — the personas, the journeys, the domain names and the table *old
+  document → new paths* — whose note is committed settled, with no exit, for the lot that writes it;
+  a committed one waits for that lot: say so and stop. Every other topic stops, quoting the script.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+The **topic and where it came from** — the argument, or inferred and stated: a root cause an audit
+listed, the lead `/review-mr` just filed, the conclusion two messages above. Never invented.
+
+**What is already known**: the topic's terms in a scratchpad file, one per line — the identifiers
+it cites first, then its distinctive words — and `codelife search <file>`. Write the terms and the
+candidates that matter in your reply — a tool's output is not one —, each with its verdict:
+
+- **settled** — a rule or a refusal that answers the topic: show it with `codelife spec <id>`, its
+  date and its rejected options, and **stop** to ask whether to supersede it — a yes starts the
+  note that reverses it, a no ends the run;
+- **constrains** — a decision that bounds the topic without answering it, cited in *Context*;
+- **pending** — a note on this topic: resume it. On another topic, one line, and go on.
+
+**Whether it holds a decision**: a question of fact, or one the code answers once read, is answered
+here, with no note. **Whether it holds one result**: several independent ones are split — the first
+is worked, each other written as a pending note, its *Context* one paragraph saying which note set
+it aside and why, its question its **Open** item.
+
+## Parameters
+
+With the brief, only what applies:
+
+- **resume** a note on the topic — from its **Open** items, or fresh under a new slug. Its
+  decisions are never asked again; a `For spec` item it carries is written as recommended. A note
+  with no **Open** item goes straight to the exit when it is committed, or when `docs/spec/`
+  already holds its partial writing; otherwise to *Before the stop*.
+- **supersede**, asked when a decision settled the topic.
+
+## Steps
+
+**The premise first**, silently, before any question about a solution — proof, counterfactual,
+attachment, simplifier, riskiest assumption, durability — asking only where a gap is real. An
+assumption a read can test is read before asking; one only a run or a measurement can test is not
+run: the decision resting on it names that test. A premise that holds is decision 1 — *do this*,
+rejected *do nothing, and what it costs*. One that fails ends the run on one refusal line,
+`codelife help method refusal`, naming the assumption and what showed it, its `docs(spec)` commit
+deleting the note.
+
+**Questions, one at a time**, the code and the artefacts read first: a question the tree answers is
+not asked. Each carries the situation in two sentences, the options with their consequence and your
+**recommendation first**; one option **removes** — a mechanism, a rule, a file or a step that exists
+and could go, *nothing changed* only when nothing can; a question of a name invents none. On a
+structuring topic, one outside voice inferred from the tree — the maintainer in two years, GPU
+performance — objects in one line beside your recommendation. Wait for the answer, then record the
+decision **with the options it rejected**.
+
+- Only a question put and answered is a decision: an "ok" to a passing remark records nothing.
+- A choice imposed with no option examined gets **one** argued challenge; if it stands, the
+  challenge's option is its rejected one.
+- "As you like" is no answer: restate the recommendation in one line with what it costs if wrong,
+  and ask for a yes. "I can't judge", or a second "as you like": offer to map the territory's
+  decisions with their realistic options; refused, write the recommendation *Assumed, not
+  evaluated* under *What stays open*.
+- A question with no answer is an **Open** item. Never decide for the user.
+
+**The note** — `docs/brainstorm/<date +%F>-<slug>.md` from `templates/note.md`, in English, on disk
+from the first decision and rewritten at each: it is what survives a compaction. The slug is two to
+four words of the subject; a filename that collides is that note's topic. Resuming writes into the
+existing note.
+
+**Before the stop**, once no question is left:
+
+1. **Edges, silently** — the empty, the huge, the concurrent, the interrupted and the repeated, on
+   each decision that changes a behaviour: a question only where one has no case. Then **three
+   ordeals, in your reply**, picked for the topic among pre-mortem, inversion, second-order effects,
+   failure modes and steelmanning — one line each, what it found and what it changes: a rejected
+   option, a case, nothing. A finding that would change a decision is a question.
+2. **Claims** — what the note asserts about the tree, one numbered per line with the `file:line` it
+   cites, in a file outside the repository; dispatch `codelife:ground` with its path and `HEAD`'s
+   sha, never a word of the conversation. Open each `file:line` it returns: *confirmed* goes into
+   the note, *refuted* reopens its decision as a question, *unverifiable* is written *(unverified)*.
+3. **Ready** — `codelife form note <the note>` is green: a decision whose cases span two rules is
+   split, each part put to you as a decision of its own. No decision contradicts another, nor a rule
+   in force it does not name in its **Target.**; one result; the *Worked case* walks every
+   decision. A gap that changes no decision is fixed in place; one that would is a question.
+4. **The stop, in your reply** — the note's path, one line per decision, then two questions: a
+   point to add, which reopens the questions and the ordeals on what it changes; and whether to
+   write here or in a fresh session, recommended from the context's load — after a compaction, or a
+   long session, fresh. Fresh: commit the note, `docs(design): <title>`; `/brainstorm <slug>` there
+   goes to the exit.
+
+**The exit**, on your go — `references/exit.md`. A topic left unfinished, or a run you stop, is
+committed as its note, `docs(design): <what this session settled>`, with an **Open** item naming
+where it stopped: only the stop's own commit leaves none.
+
+## Never
+
+- Implement anything, start the work because it looks small, or file it.
+- Decide for the user, or fold an unanswered question into a decision.
+- Run a lens: a code question that needs one is `/audit targeted <lens>` first.
+- Work two topics in one run; the pieces the brief set aside are the one exception.
+- Commit anything but what `references/exit.md` names, or the note and the pieces set aside —
+  with the file a guard requires to accept them, named; never bypass a guard. Whatever else is
+  pending is named and left alone.
+- Check out, switch, stash or add a worktree.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### brainstorm result
+- Produced: the documents written under `docs/spec/` and the commit — or the note with its path
+  and its commit; each piece the brief set aside — or *nothing to decide, no note written*.
+- Decided: the decisions, by number, each with what it rejected.
+- Left open: the note's **Open** items; the files outside `docs/spec/` and `docs/brainstorm/`
+  still citing a path the writing moved or the note it deleted.
+- Next: `/roadmap` to file what the exit wrote — right away for a small feature, or at the end of
+  a specification phase; `/brainstorm <slug>` when the note is pending.
+```

package/skills/brainstorm/references/exit.md

@@ -0,0 +1,57 @@
+# The exit — a settled note written into the specification
+
+Loaded once the stop is passed: no **Open** item, the ordeals and the claims done. **The writing
+copies**: each rule, case and rejected option in the note's words. What it composes — a rule's text,
+*Internal design*, *What it is for*, a renamed heading, a rewritten link — is what you show, since
+no script compares it.
+
+## Where each part goes
+
+Each decision's **Target.** names a document and, per verb, what it *creates*, *changes*, *retires*
+or *renames* there; it edits them all. An existing target is found by its identifier,
+`codelife spec <id>`. A created capability or journey is drafted from
+`codelife help template capability` or `journey`, at the path the note gives, with its line in `docs/spec/README.md`
+under its domain; a persona is a `##` of `users.md`.
+
+| In the note | In the specification |
+|---|---|
+| *Context* | nothing — but who the capability is for goes to *What it is for*, and **Terms.** to `glossary.md` |
+| a rule and its **Cases.** | *Behaviour*: `### <rule>`, each `#### <case>` in Given / When / Then, as written |
+| how it is built | *Internal design* |
+| a **Rejected.** line | `- <address> — <the line> — <the note's date>`, in the target's `## Rejected` |
+| a state it replaces, *in force since <date>; <cost>* | `- <address> — <the state>, in force <from> → <the note's date> — <the cost> — <the note's date>` |
+| a rule or case it retires | out of *Behaviour*, its identifier on its own `## Rejected` line with the note's cost — a missing cost is a question, never invented |
+| *Worked case* | nothing |
+| *What stays open* | *What stays open*, less what the note answered |
+| a `For spec` item | its recommendation, written as the state |
+
+The `<address>` is the identifier, or `§ <heading>` for what carries none; a refusal concerning no
+capability goes to `principles.md`. *Behaviour* and *Internal design* say what holds, in the present
+tense — never *was changed* or *to implement*. What the writing creates opens on the **next number
+of its letter**, the highest under `docs/spec/` — `## Rejected` lines included — plus one; a moved
+case keeps its number, a retired one is never reused.
+
+A **rename or a move** rewrites every link and `<path> § <heading>` address to it inside
+`docs/spec/`. The note is **deleted**, and each citation of its filename in `docs/spec/` and
+`docs/brainstorm/` rewritten to where what it cited now stands; a file elsewhere is not touched, and
+the result block names it.
+
+## Then
+
+1. `codelife form spec`, then `codelife form fold <the note>`, the note still on disk. A red is the
+   copy's: correct it — never the note, never the script. A red that needs a decision — a decision
+   with no rejected option, a target that resolves to nothing — is a question, its answer written
+   into the note first. An `orphan:` line is a report.
+2. **Show, in your reply**, for one answer: the prose you composed, in full, document by document;
+   the cases and refusal lines you copied, by their headings. Then **stop** for that answer —
+   the go given at the stop was for the writing, and nothing is committed before this one. A
+   correction is rewritten, the checks run again, and only what it changed shown again. A contradiction with a rule in force the note
+   does not name, met while writing, is asked now, and its answer becomes a decision naming that
+   rule in its **Target.**
+3. **Commit**: `codelife commit <message file> <paths>` — the documents written, every file a
+   rename, a move or the deletion rewrote, and the note when git tracks it; nothing else. The
+   message is `docs(spec): <the note's title>`, the title cut at the last whole word within 72
+   characters, and then written whole as the body's first line.
+
+A cut exit resumed — the note on disk, `docs/spec/` already partly written — reads that diff as its
+own and completes it; `codelife form fold` says when it is whole.

package/skills/brainstorm/templates/note.md

@@ -0,0 +1,79 @@
+<!-- generated by codelife — /brainstorm -->
+# {{title}}
+
+*{{date}}. Builds on {{the documents and notes this one reads, by filename}}. Worked case: {{what it was tried on}}.*
+
+## Context
+
+What made this topic worth a session, in two or three paragraphs: the state of the repository, what
+the earlier notes already fix, and the question that is genuinely open. A reader who was not in the
+conversation has to be able to reconstruct why the decisions below were even a choice. A claim about
+the tree carries its status where it is written — here or in a decision — `file:line`, or
+*(unverified)*.
+
+**Terms.** Only when the session fixed any; the exit's writing copies them into the glossary.
+
+- **{{term}}** — {{its definition}} — avoid: {{the synonyms not to use}}
+
+## Decisions
+
+### 1. {{The decision, stated as a sentence}}
+
+**Target.** `{{the document the decision is about}}`
+
+- {{one line per address, opening on one of the four verbs — the exit writes where these say and
+  nowhere else. What exists is named by its identifier, what is created by `<path> § <heading>`,
+  never by a number: the writing assigns it. A heading is created once in a note, and a decision with
+  **Cases.** names exactly one rule — changed, renamed or created — to write them under, and never
+  lists its cases here.}}
+- creates `{{path}} § {{heading}}`
+- changes R-{{n}} — {{its heading}}
+- retires C-{{n}} — {{its heading}}
+- renames C-{{n}} — {{its heading}} → {{the new heading}}
+
+**Decision.** What was decided, and the reasoning that decided it — the constraint that made this
+option the one, not a summary of the option.
+
+**Rejected.** One line per option that was not taken, already in the form the writing copies. This
+list is why the note is worth writing: in six months the alternatives look attractive again, and
+only their recorded cost stops the topic being re-opened from scratch.
+
+- {{option}} — {{what it would have cost}}
+- {{a former state this decision replaces}} — in force since {{date}}; {{what it cost}}
+
+**Cases.** Only when the decision creates or changes a behaviour; the writing copies them as written.
+Each names the values it runs on — a file, a number, a message: a branch of 2 400 changed lines,
+not a large branch — as the *Worked case* does, so that it transcribes almost as is into a test.
+
+#### {{The case, a heading unique in this note}}
+
+Given {{the situation}}
+When {{what is done}}
+Then {{what is observed}}
+
+### 2. {{The next one}}
+
+**Target.** …
+
+**Decision.** …
+
+**Rejected.**
+
+- … — …
+
+## Worked case
+
+One concrete case run end to end against the decisions above — a real file, a real command, a real
+sequence. A decision that cannot be walked through on a case is not finished being decided.
+
+## What stays open
+
+- **Open —** {{a question that blocks a decision and has no answer}} — answered by {{a read, a run,
+  or the user}}. Prefixed `Open` because a resumed run reads exactly these: they are what the next
+  session asks first. A note with any of them reaches no exit.
+- {{what no conversation can settle today}} — settled by {{a case, a measurement, an event}}. No
+  prefix: it is not blocking. An item whose trigger cannot be named is not written here but put to
+  the user in the session; another topic is never a line here, since it lives in its own unfinished
+  note.
+- Assumed, not evaluated: {{what a blindspot the user declined to map leaves standing}} — no
+  prefix either.

package/skills/commit/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: commit
+description: Group the working tree's changes by intention and write one Conventional Commit per intention, each approved before anything is staged.
+---
+
+# /commit
+
+Turns the working tree into commits that say something, for work no skill committed: the hand
+path, whose commits `/mr` names *Not reviewed by codelife*. One commit per **intention** — the
+issue worked, the typo noticed in passing — each shown with its files and its full message before
+anything is staged. It never pushes: that is `/mr`'s, or yours.
+
+## Preconditions
+
+A git repository with something to commit; a clean tree ends the run in one line. The commits go
+on the branch checked out.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+What `git status` shows — the branch and its upstream, the files staged, modified and untracked —
+and the intentions this session named, stated before grouping, so a missing one is caught before
+the proposal.
+
+## Parameters
+
+None: the intentions are the conversation's, and every choice is put to you in the proposal.
+
+## Steps
+
+1. **Group by intention.** The intentions are the conversation's, in its words; the tree only
+   attaches files to them. A test goes with the module it mirrors, an output of `generated[]` in
+   `.claude/codelife.md` with its source, a manifest with the change that needed it. A file
+   matching two intentions is asked about; one matching none is left unstaged and named with its
+   reason; nothing attaching at all is a question — what is this change? — never a diff narrated
+   back. When one group must land first — a rename before its callers — say so.
+2. **Propose**, all at once: each group's exact files and its full message, written as
+   `codelife help method message` prints it, then the leftovers with their reason.
+   *Exit: you agree, or correct a group or a message.*
+3. **Commit**, group by group in that order: the message in a file in the scratchpad, then
+   `codelife commit <message file> '<path>' …`, each `'` in a path written `'\''`. What it prints
+   as `left unstaged` or `not committed` stays so. A refusal — a hook's, or a file staged
+   beforehand — is reported as printed and stops the run: the fix is the code or the message.
+
+## Never
+
+- Sweep a leftover into the nearest group, or invent an intention the conversation never named.
+- Split one intention because its diff is large, or merge two because each is small.
+- Stage before you agreed; bypass a hook; amend, check out, switch, stash, rebase or push.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### commit result
+- Produced: one line per commit: hash and subject.
+- Decided: the grouping, and any message you rewrote.
+- Left open: every file left unstaged or not committed, with its reason.
+- Next: `/mr` on a work branch; nothing on `main`, `develop` or a `support/` line.
+```

package/skills/mr/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: mr
+description: Open the merge request of work committed by hand, or update the one the branch has, its description written from the linked issues, the commit bodies and the diff.
+---
+
+# /mr
+
+Opens the merge request of the current branch, or updates the one it has, for work committed by
+hand: `/work` opens its own. The description is written from the linked issues, the commit bodies
+and the diff, so a fresh session writes the same one; everything else is `codelife mr open`'s, which
+derives the target — the branch's parent, never asked — and pushes only once you confirm what it
+prints.
+
+## Preconditions
+
+`codelife mr open` checks them and prints a `- stop:` line naming the first that fails: a contract
+whose tracker is a forge; a work branch, not `main`, `develop` or a support line, its work not yet
+merged; a parent it can derive.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+Made from the dry run of `codelife mr open` alone: the branch and its target, how far behind it,
+the commits leaving, and whether a merge request opens or `!n` is updated.
+
+## Parameters
+
+None: the target is derived. No `delegate`: nothing leaves the machine before you confirm what will.
+
+## Steps
+
+1. **Prepare** — `codelife mr open`, which sends nothing. A `- stop:` line ends the run, its reason
+   said. A `held:` line ends it too: a held choice is a delegated `/work`'s, validated by
+   `/work <n>` — the umbrella's number for a lot. Each question a line names is put to you; on a
+   yes to merging the target in, `git merge origin/<target>`, then the dry run again.
+2. **Draft the description** — skipped when the dry run says it is kept. As
+   `codelife help method description` prints it, from:
+   - the issues the `linked:` lines name — `codelife issue section <n> <heading>`, and
+     `codelife issue section <n> plan` for its `## Go-ahead` and its proof;
+   - the commit bodies, `git log origin/<target>..HEAD`;
+   - the diff: `git diff --numstat origin/<target>...HEAD`, then file by file
+     `git diff origin/<target>...HEAD -- <file>` — never a deletion, a pure rename, a binary, a
+     lockfile or a `generated:` path; the files the issues or the bodies name first, then the most
+     changed, while they fit 2 000 changed lines, one that does not fit skipped for the next.
+
+   The conversation adds what these do not carry, and is never the only source. On an update, read
+   the description the dry run wrote to a file first, and rewrite only its region; one with no
+   region is a question — wrap and rewrite it, or append below it — answered as `--wrap` or `--append`.
+3. **Confirm** — the description in a file in the scratchpad, `codelife mr open <file>`: what it
+   prints and the draft are the confirmation, never a bare *ready to push?* A `debt:` line whose
+   title is not the issue its line describes: fix or drop the line, and run it again.
+4. **Send** — on your yes, `codelife mr open <file> --send`, with no file when the description is
+   kept. A `- stop:` line is reported as it reads: nothing was sent.
+
+## Never
+
+- Validate, push or refuse a held choice: that is `/work <n>`'s.
+- Write outside the description's region, or guess who wrote a description that has none.
+- List under *Debt noticed* what is not filed: that is `/new-issue`.
+- Run `--send` before you confirmed what `codelife mr open <file>` printed.
+- Check out, switch, stash, add a worktree, force-push or squash.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### mr result
+- Produced: the merge request, its number and link, and the branch pushed.
+- Decided: the target merged in or not, the description — written, or kept when only that merge
+  was new — and the push.
+- Left open: the debt listed, and what the push tier reported without failing on.
+- Next: the merge on the forge, `/mr` again first if the target moves; `/work <n>` when a held
+  choice stopped the run.
+```

package/skills/new-issue/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: new-issue
+description: File one issue — from a subject or from the conversation — after a search of the open issues and of what the specification decided, stopping rather than re-litigating a decision.
+argument-hint: "[subject]"
+---
+
+# /new-issue
+
+Files **one** issue, after searching what is already known: a subject that is two things is two
+runs. What makes it a skill rather than a command: **a subject the specification decided against
+stops it** — reversing a decision is `/brainstorm`'s `supersede`, never an issue. Work already done
+is still filed, its body in the past and left open for the skill that lands it: its number is what
+the branch is named from.
+
+## Preconditions
+
+A contract. Under `tracker.kind: none` the issue is a new file under `issues/`, left for `/commit`;
+the run says so in one line.
+
+## Brief
+
+**Who gave the go-ahead**, and from what, opens it: you, typing the command or answering this
+brief; your confirmed table in a driver, which answers what it named — ask only the rest; the word
+`delegate`; or a session that relayed your words, quoted here — relayed is not delegated. Typed or
+tabled, this brief is an announcement; otherwise the run **stops here** for your go-ahead, after
+nothing but a preparation that only reads.
+
+The subject and **where it came from** — the argument, or the conversation: a lead noticed during
+`/work` or a review, the last ten words — stated, never silently assumed. Then the **origin** its
+title will name: `issue:#<n>` or `mr:!<n>` for the issue or merge request the session is on, none
+for a subject typed from nowhere. A subject about a file of another repository — a submodule —
+stops here, naming that repository: `/new-issue` runs there.
+
+## Parameters
+
+One batch, each with a recommendation: the **nature** — `bug` when the behaviour breaks a promise,
+`feature` when it is defensible but something is missing — and the **severity**, from the impact
+described.
+
+## Steps
+
+1. **Search** — the subject's terms in a file in the scratchpad, one per line: the identifiers it
+   cites first — a function, a script, an error message, a file's basename —, then its distinctive
+   words, never the whole sentence; then `codelife search <file>`. Write its terms and at most five
+   candidates in your reply — a tool's output is not one —, and conclude:
+   - **decided** — a refusal line, or a rule that already answers the subject: show it with
+     `codelife spec <id>`, its date and its rejected options, and **stop**, naming any open
+     candidate beside it. A rule the subject asks to be honoured stops nothing: step 2 cites it;
+   - **duplicate**, on your answer — the `duplicate` comment of `codelife help method comments`
+     in a file, posted by `codelife issue note <n> <file>`; then the origin's link of step 3, its
+     *Already carried by* form, and stop;
+   - **related** — cited in the body, *Related to #n*, or a pending note as the design under way;
+     or nothing: go on.
+2. **Draft** — as `codelife help template bug` or `feature` prints an issue, in a file in the
+   scratchpad whose first line is `# <sentence>`, the symptom in one short sentence; *Where it
+   comes from* names the origin, linked, and the rule it concerns. On a public repository an
+   exploitable reproduction stays in this conversation, the body saying *reproduction withheld*.
+   *Exit: the draft, whole, in your reply, and your agreement or correction — save in a run your
+   confirmed table started, which agreed to it.*
+3. **File** — `codelife issue create <nature> <severity> <origin|-> <file>`. Then, with an origin,
+   its link: the `debt-link` comment of `codelife help method comments` in a file — its first line
+   `codelife: debt-link — /new-issue — <date>`, the title it names `[<origin>] <sentence>` —, posted by
+   `codelife issue note <n> <file>` on an issue — on its **umbrella** when the origin is a member
+   of an open lot, where `/work`'s table offers the join — or `codelife mr post <mr> <file>` on a
+   merge request.
+
+## Never
+
+- File two issues in one run, close the one filed, or refuse it because the work is done.
+- File what a decision of the specification settled, or a near-duplicate of it.
+- Write the issue or its file yourself: `codelife issue create` numbers it, under `none` too.
+- Commit an exploitable reproduction to a public repository.
+- Answer in a language the user did not write in, or write anything but English into the
+  repository or the tracker.
+
+## Output
+
+The run ends on this block, under this exact heading:
+
+```markdown
+### new-issue result
+- Produced: the issue, its number and link, and the link on the origin — or the `duplicate`
+  comment on the issue that already carries the subject.
+- Decided: the nature, the severity, and the search's conclusion.
+- Left open: the candidates found and not merged into it; a decision that stands.
+- Next: `/work <n>` — `/commit` first under `tracker.kind: none`; nothing when the run stopped.
+```