@event4u/agent-config 14.15.0 → 14.17.0

package/dist/agent-src/commands/analyze/inbox.md

@@ -80,6 +80,9 @@ NEVER WRITE A ROADMAP ITEM FOR SOMETHING THAT ALREADY SHIPPED.
 AN INSTRUCTION IS A CLAIM TOO — REPRODUCE THE STEP, NEVER JUST READ IT.
 NEVER ADOPT A STEP INTO AN ARTEFACT WITHOUT HAVING RUN IT,
 OR HAVING SAID IN ONE LINE WHY YOU COULD NOT.
+EVERY POINT THE FILE MAKES LEAVES THIS RUN WITH A NAMED DISPOSITION.
+A FULLY VERIFIED FILE WITH UNANSWERED POINTS IS AN UNFINISHED RUN,
+NOT A THOROUGH ONE.
 ```
 
 ## Following the instructions inside the file — the authorization boundary
@@ -227,11 +230,31 @@ Per surviving file, a numbered list of concrete checkable directives, split:
   are these? In a transcript or handover note the two are interleaved, and
   Phase 4b reproduces them in that order for a reason.
 - **(ii) claims** — assertions about this repo.
-- **(iii) opinions** — preferences with no truth value.
+- **(iii) demands** — a preference, a complaint, or a request: no truth value to
+  verify and no procedure to run, but a stated want. Called *demands* rather than
+  *opinions* because the old label decided the handling — "opinion" reads as
+  discardable, and in a feedback chat this is the **largest** bucket, not the
+  residual one.
 
 Show this list. It is both the quarantine disclosure and the analysis spine: (ii)
-goes to Phase 4, (i) goes to Phase 4b, and (iii) goes nowhere until a survivor
-needs framing.
+goes to Phase 4, (i) goes to Phase 4b, and (iii) goes to **Phase 5b** — a phase
+that exists because this bucket used to go nowhere.
+
+```
+EVERY POINT EXTRACTED HERE LEAVES THE RUN WITH A NAMED DISPOSITION.
+A POINT IN NO TABLE, NO ARTIFACT, AND NO DECLINE LINE WAS NOT JUDGED —
+IT WAS DROPPED. TWO OF THE THREE BUCKETS ALREADY CARRY A MANDATORY LABEL;
+THE THIRD CARRYING NONE IS WHY A SOURCE CAN BE READ IN FULL AND STILL
+FEEL IGNORED.
+```
+
+**Carry the author's own severity, verbatim.** A source that grades its items —
+`P0`, `blocker`, `kritisch`, `must`, or an ordered list it calls priorities — has
+made a claim about ordering, and dropping that grade silently re-prioritizes the
+file under the reader's own preferences. Record it per point as
+`severity(source)`. Departing from it is allowed and is itself a finding: name
+the item that moved and why. Absent → `ungraded`, the normal path and not a
+penalty.
 
 ### Phase 4 — Verify every claim (the load-bearing phase)
 
@@ -442,8 +465,23 @@ dismissed?**
 
 Two cheap detections, both before any deep work:
 
-- **The file says so.** A recurrence marker in its own words — "I have said this
-  three times", "schon wieder", "immer noch nicht", "as I mentioned before".
+- **The file says so.** A recurrence marker in its own words. The list is
+  bilingual because the corpus is: measured over the 939 files in
+  `agents/tmp.old/` on 2026-09-04, the English-only list this carried before
+  matched **1** file for "said this" and **0** for "as I mentioned", while
+  **"endlich" matched 62 files**, "immer noch" 46, "nach wie vor" 7 and "zum
+  wiederholten Mal" 5. The single most frequent recurrence word in this repo's
+  own inbox was not on the list — so the detection was structurally blind to the
+  language most of its input is written in. (`agents/tmp.old/` is gitignored, so
+  those are dated local counts a clone cannot re-run; the ratio is the finding,
+  and the fix does not depend on the exact figures.)
+  - EN — "I have said this three times", "as I mentioned before", "once again",
+    "still not", "for the Nth time".
+  - DE — "endlich" / "wir brauchen endlich", "schon wieder", "nach wie vor",
+    "zum wiederholten Mal", "immer noch (nicht)". <!-- md-language-check: ignore -->
+  A source that has already done the counting — "der neunte gleiche Befund",
+  "the ninth identical finding" — is the strongest form of this marker and is
+  never treated as rhetoric.
 - **The inbox says so.** `grep` the same subject across `agents/tmp.old/` and the
   roadmaps in `agents/roadmaps/archive/` and `skipped/`. A previously consumed
   file on the same subject is the same signal without the sentence.
@@ -489,6 +527,7 @@ The question is never "what does the file say" but **"what does it become here"*
 | a defect claim | a roadmap item, once verified |
 | a claim that maps onto an existing stub | **not a fresh artifact — a stub-blocked finding, see below** |
 | a consolidation omitting a parent | **not an artifact — a discharge, see below** |
+| a demand — a want with no truth value | **not settled here — Phase 5b, which must discharge it** |
 
 **An omitted parent is discharged, never left silent.** When Phase 2's `lineage`
 column read anything but `n/a` or `complete`, this phase says what happened to
@@ -547,6 +586,64 @@ decide what happens to the stub — promotion is the estate's question and this
 command does not answer it — it only forbids resolving the survivor into prose
 that names no artifact.
 
+**The count is written into the object that was hit, never only into the round's
+own evidence file.**
+
+```
+A RECURRENCE COUNT RECORDED ONLY IN A ROUND-SCOPED ARTIFACT IS NOT A COUNT —
+IT IS A SENTENCE THE NEXT ROUND WILL RE-DERIVE FROM ZERO.
+THE COUNTER LIVES ON THE STUB, THE later/ ROADMAP, OR THE BLOCKER THAT HOLDS IT.
+IT ONLY EVER GOES UP.
+```
+
+This is the failure caught in this repo's own tree. Round `inbox-2026-09-d`
+found its leading item arriving for the **ninth** time, named all four fields
+correctly, and wrote them into
+`agents/evidence/analysis/inbox-2026-09-d-disposition.md` — an artifact created
+by that round, read by no later one. The held object,
+`agents/roadmaps/later/road-to-mixed-trigger-activation-cost.md`, carries no
+arrival count at all, and a `grep` for one across every file under
+`agents/roadmaps/stubs/` and `agents/roadmaps/later/` returns nothing. Its
+disposition closes with *"stated here so the tenth round meets a count rather
+than a fresh argument"* — and the tenth round will not meet it, because the
+count is not where the tenth round looks. Every field was produced; the item
+still arrived nine times.
+
+So the run **edits the held object**, adding or incrementing one line directly
+under its `Source:` header:
+
+```markdown
+> **Arrivals:** 9 — latest `inbox-2026-09-d` (2026-09-04); earlier:
+> `inbox-2026-09-b`, `inbox-2026-08-g`, `road-to-10`, … (codenames only)
+```
+
+Codenames only, per Phase 1 — this line is tracked and quoted like any other.
+Editing a parked roadmap's header is inside this command's authoring scope; it
+adds no step, changes no plan, and touches nothing a Phase-6 executor would run.
+
+**At the third arrival, the escalation is a mandatory output, not a paragraph.**
+The run's reply opens with an **Owner decisions required** block naming, per
+item: the held object, the blocker, the arrival count, and the concrete question
+with numbered options (per
+[`user-interaction`](../../../../rules/user-interaction.md)). One block per run,
+carrying every such item — never one question per item, which is the pacing
+[`ask-when-uncertain`](../../../../rules/ask-when-uncertain.md) forbids. The
+same question is written onto the held object so the next round finds a posed
+question instead of re-deriving one.
+
+> **Three is a stated default, not a measured optimum** — said plainly rather
+> than implying a derivation it lacks. It sits above
+> [`recurring-criticism`](../../../../rules/recurring-criticism.md)'s own
+> trigger, which fires at the *second* arrival: the counter is written from the
+> second, the owner is interrupted from the third. *Revisit-if:* an escalated
+> item turns out to have been answerable from tree evidence without the owner,
+> or an item reaches a fifth arrival without the block having been emitted.
+
+Escalating is never lifting: a spend-bearing or otherwise owner-reserved blocker
+stays owner-reserved ([`decision-revisit-gate`](../../../../rules/decision-revisit-gate.md)
+§ the owner-reserved set). What changes is that the decision reaches a desk
+instead of a file.
+
 Three hard defaults, from this repo's own scar tissue:
 
 - **Extend before you create.** Run the four-surface overlap scan from
@@ -568,6 +665,44 @@ Three hard defaults, from this repo's own scar tissue:
   letting it through silently would empty the Iron Law of everything it applies
   to.
 
+### Phase 5b — Discharge every demand
+
+Phase 5 maps what the file *contains* onto artifact types. This settles what the
+file *wants* — bucket (iii) — and it is the phase that closes the gap between
+"the source was read in full" and "the source was answered".
+
+The repo already treats silence as the failure mode in exactly one place: an
+omitted consolidation parent (Phase 5, three legal discharges). That obligation
+was correct and too narrow — it guards a *bibliography* while the *content* had
+no equivalent. This is the same discipline applied to the points themselves.
+
+Exactly four discharges are legal, one per demand, and the choice is the
+operator's:
+
+| Discharge | What it means | What it costs |
+|---|---|---|
+| `adopted` | it becomes, or joins, an artifact | the artifact path |
+| `already-satisfied` | the tree already does this | one `file:line` |
+| `declined` | judged and not taken | one sentence of reason |
+| `owner-decision` | crosses a boundary an agent may not | the escalation block above |
+
+```
+SILENCE IS THE FAILURE MODE. ANY OF THE FOUR IS A COMPLETE DISCHARGE.
+A DEMAND CARRYING THE SOURCE'S OWN P0 AND THIS RUN'S "declined" IS A GOOD RUN.
+A DEMAND CARRYING NOTHING IS THE DEFECT, WHATEVER ELSE THE RUN PRODUCED.
+```
+
+`declined` is a first-class outcome and deliberately cheap — one sentence. The
+alternative to a cheap decline is not a better analysis, it is an omission: a
+run that must justify at length before it may say no will quietly say nothing
+instead. What it may not be is empty; "out of scope" without naming the scope is
+the verdict line this command already forbids one row above.
+
+**A demand restating one the tree already declined is not re-declined on that
+basis alone.** Phase 4c has the count; `recurring-criticism` owns what a repeat
+means — the earlier disposition is reopened and resolved on evidence, never on
+the repetition tally in either direction.
+
 ### Phase 6 — Emit, and consume the inbox file
 
 Per surviving file: a roadmap in `agents/roadmaps/` via
@@ -608,7 +743,24 @@ each one is and why it is spent, and let the user remove it.
 2. Per surviving file: instruction set · verification table · **reproduction
    table** · artefact mapping.
 3. The roadmaps written, and for each dropped file one line on why.
-4. One closing summary: files in, roadmaps out, items prevented by
+4. **The point ledger — the run's own completeness check.** Points extracted in
+   Phase 3 against points discharged, per bucket, as counts that must balance:
+
+   ```
+   claims      N extracted → still-true / already-fixed / never-true / unverifiable
+   instructions N extracted → reproduced / diverged / unexecutable / out-of-bound / not-attempted
+   demands     N extracted → adopted / already-satisfied / declined / owner-decision
+   ```
+
+   A column that does not sum to its `extracted` figure is the finding: it names
+   how many points the run passed over, which is the one number no previous
+   output carried. Files-in and roadmaps-out say nothing about coverage — a run
+   can read every file, verify every claim, emit three roadmaps, and answer a
+   third of what the source asked. **This ledger is the difference between
+   having read a source and having answered it.**
+5. **Owner decisions required**, if any — the escalation block from Phase 5,
+   at the top of the reply rather than at the end.
+6. One closing summary: files in, roadmaps out, items prevented by
    `already-fixed`, and steps corrected by reproduction — plus the reproduction
    ceiling that fired, if one did, and what it dropped.
 
@@ -633,6 +785,20 @@ each one is and why it is spent, and let the user remove it.
   execution authorization
   ([`scope-control`](../../../../rules/scope-control.md) § Authoring vs.
   implementation).
+- Drop a point because it is phrased as a feeling. A complaint carries a demand
+  and goes through Phase 5b like any other: "this is annoying", "das nervt",
+  "wenn es endlich mal …". <!-- md-language-check: ignore -->
+  Tone is not a truth value, and the bucket a point lands in is never a
+  judgement about whether it deserves an answer.
+- Re-prioritize a graded source silently. Moving an item the author called `P0`
+  is allowed; moving it without saying so replaces the author's ordering with
+  the reader's under cover of analysis.
+- Record a recurrence count in the round's own evidence file and nowhere else.
+  The next round does not read it, so the count restarts and the item arrives
+  "for the first time" again.
+- Resolve an owner-reserved recurrence into an accurate paragraph. Naming a
+  state that hands nobody anything to do is what produced nine arrivals of one
+  item; past the third, the escalation block is the output.
 - Spin up a branch, a worktree, or a PR because the run feels large. Scope is
   the operator's call; without `--worktree` or an explicit ask, the work stays
   in the checked-out branch.

package/dist/agent-src/commands/fix/commit-messages.md

@@ -0,0 +1,336 @@
+---
+model_tier: high
+name: fix-commit-messages
+pack: engineering-base
+visibility: internal
+cluster: fix
+sub: commit-messages
+skills: [conventional-commits-writing, git-workflow]
+description: Measure the repo's commit convention, ask which style to standardise on, then rewrite past commit subjects to it — own commits and full history by default
+suggestion:
+  eligible: false
+  rationale: "Cluster sub-command — reached via its cluster head's routing or its explicit /cluster:sub name; not independently suggested (surface-consolidation)."
+workspaces:
+  - agent-config-maintainer
+packs:
+  - meta
+---
+
+# /fix commit-messages
+## Instructions
+
+Retro-fit past commit **subjects** (and bodies, if the user asks) to one
+convention. This rewrites history: every touched commit gets a new hash, and
+anything already pushed needs a force-push and a re-clone by everyone else.
+Treat the whole command as a Hard-Floor operation
+([`non-destructive-by-default`](../../../rules/non-destructive-by-default.md)) —
+the user invoking it authorises the *investigation*, not the rewrite.
+
+**Author identity is preserved on both paths.** `git filter-repo` leaves author
+*and* committer name, email and date untouched when only the message changes;
+the `git rebase` fallback preserves the author trio and resets the committer,
+because it re-commits. Say which path you are on before asking for the go-ahead
+— and say only what is true of that path.
+
+### 1. Refuse early, on facts, not on caution
+
+Stop and report — do not proceed to step 2 — when any holds:
+
+- **The working tree is dirty.** `git status --porcelain` non-empty → ask the
+  user to commit or stash first. A rewrite over a dirty tree loses work.
+- **A rebase, merge, cherry-pick or bisect is in progress**
+  (`.git/rebase-merge`, `.git/rebase-apply`, `MERGE_HEAD`, `CHERRY_PICK_HEAD`,
+  `BISECT_LOG`). Finish it first.
+- **`git config user.email` is empty.** Step 5's default scope is built from
+  it, and an empty value makes the author filter match everything — the
+  opposite of the default. Ask for the address rather than inferring one.
+- **`git filter-repo` is not installed** (`git filter-repo --version`). Per
+  [`missing-tool-handling`](../../../rules/missing-tool-handling.md): stop and
+  ask with numbered options — install it, or use the `git rebase --exec`
+  fallback in step 7b, which is slower, resets committer metadata, and stops on
+  every conflict. Never install it silently, and never fall back to
+  `git filter-branch`, which Git itself deprecates for exactly this use.
+- **The range contains commits authored by someone whose work is in flight.**
+  There is no metadata that distinguishes "a peer session wrote this" from "you
+  wrote this" — both carry the same `user.email` — so the checkable form is the
+  one to use: `git worktree list` plus `git log <range> --format='%aE' | sort -u`.
+  More than one worktree on this repository, or an author in the range who is
+  not the invoking user, is the case to raise rather than resolve.
+
+### 2. Establish the target convention — measure before offering
+
+Run `## Procedure: Establish the house convention` from
+[`conventional-commits-writing`](../../../skills/conventional-commits-writing/SKILL.md)
+verbatim: tier-1 sources first (opened and read, never taken from a grep hit),
+then the capped-weighted consensus pass with bots, merges, reverts and release
+automation excluded.
+
+Report what it found, in one block, before offering anything:
+
+```
+Configured : none found (no commitlint, .gitmessage, commit-msg hook, CONTRIBUTING § Commits)
+Measured   : ticket-prefix  84% of 118 capped commits (137 eligible, 6 authors, last 24 months)
+Runner-up  : conventional   11%
+Coherence  : stable (newer half 82%, older half 86%)
+Parsers    : none — no semantic-release / git-cliff / conventional-changelog / release-please
+```
+
+The share is quoted against the **capped** total, because that is what it was
+computed over; the raw eligible count sits beside it and is not the denominator.
+
+`Parsers` is the line that changes the recommendation: release automation that
+reads subjects makes Conventional Commits the answer regardless of what the
+history looks like, and a rewrite away from it breaks the release pipeline.
+
+### 3. Ask which style — one question, custom always available
+
+One numbered-options block (per [`user-interaction`](../../../rules/user-interaction.md)),
+recommendation on its own line underneath. The measured family leads when it
+cleared the evidence bar; Conventional Commits leads when it did not, or when a
+parser exists:
+
+```
+1. Keep the house style — `[JIRA-123] Subject` (84% of commits already match)
+2. Conventional Commits — `feat(scope): subject`
+3. Plain imperative — `Add the thing` (no prefix)
+4. My own — describe or paste it (see below)
+```
+
+**Option 4 is never omitted, whatever the measurement found.** Take the user's
+answer as either a template with placeholders (`[{TICKET}] {Subject}`,
+`{type}({scope}): {subject}`) or two or three example subjects, and echo back
+the pattern you derived from it plus one rewritten sample from their real
+history before touching anything. A custom style the user cannot recognise in a
+sample of their own commits is a misread, and this is the cheap moment to catch
+it.
+
+**A tier-1 validator vetoes an incompatible choice.** `git filter-repo` does not
+run `commit-msg` hooks, so a rewrite away from a format the repo *enforces*
+completes silently and then fails commitlint on the next CI run or the next
+local commit. When step 2 found an enforcing source, check the chosen style
+against it — run the validator over one rewritten sample if it can be run at all
+— and if they disagree, say so and stop rather than rewriting into a state the
+repo rejects.
+
+Whatever is chosen, these hold and are not offered as choices — they are floors
+a style selection may not lower (see the skill's *What a measurement may never
+lower*): no attribution or co-author trailers the user did not ask for
+([`no-attribution-footers`](../../../rules/no-attribution-footers.md)), no emoji in
+subjects ([`no-decorative-emojis-in-git-surfaces`](../../../rules/no-decorative-emojis-in-git-surfaces.md)),
+and no secret pulled into a message
+([`secret-vcs-guard`](../../../rules/secret-vcs-guard.md)).
+
+### 4. Ask how far back — default is everything
+
+Second question, its own turn:
+
+```
+1. All commits (default)
+2. Since a date — e.g. 2026-01-01
+3. Since a ref — e.g. the last tag, or origin/main
+```
+
+```bash
+BASE=$(git rev-list -1 --before='<date>' HEAD)   # empty => whole history
+git show -s --format='%h  authored %ad  committed %cd  %s' "$BASE"
+```
+
+**`--before` filters on COMMITTER date, not author date** — so on a rebased,
+cherry-picked or previously-rewritten history the boundary is not where the
+user thinks it is, and a second run of this command resolves against the
+timestamps the *first* run wrote. That is why the second line is not optional:
+show the resolved commit with both dates and let the user confirm it is the
+boundary they meant. Keep the SHA from then on, never the date.
+
+An empty `BASE` means the range reaches the root commit — say that plainly, and
+carry it into step 7, where both paths need a different form for it.
+
+### 5. Scope by author — own commits unless told otherwise
+
+**Default: only commits whose author email matches the current user.** Widen
+only on an explicit instruction the user gave — either in the original
+invocation ("fix all of them", "also [name]'s") or as the answer here. Do not
+offer widening as an option when they did not raise it; rewriting a colleague's
+commit message is their call, not a menu item.
+
+```bash
+ME=$(git config user.email)                       # step 1 refused if this is empty
+git log ${BASE:+$BASE..}HEAD --no-merges --author="<$ME>" --pretty=oneline | wc -l
+```
+
+**The angle brackets are load-bearing.** `--author` is an unanchored regex
+against `Name <email>`, so a bare `m@corp.com` also matches `Tim
+<tim@corp.com>` — every colleague whose address ends with yours lands in the
+default scope. `<$ME>` cannot match inside a longer address.
+
+Also handle the mailmap case: a user with several historical addresses
+(`git log --format='%aE' | sort -u`) should be shown the list and asked which
+are theirs, once, rather than silently missing half their own commits. Carry the
+result as a **set** of addresses — step 7b consumes the same set, and a scope
+the preview and the rewrite disagree on is the defect in step 6's own table.
+
+### 6. Show the plan, get both authorisations
+
+Produce a preview table — old subject → new subject — for every commit in
+scope, capped at 40 rows with a count of the remainder. Include the rows where
+**nothing changes**: a commit already in the target style is a row that proves
+the classifier read it correctly.
+
+The table must be built with the **same** predicate step 7b will apply — the
+author set, merges excluded, the same range. A preview built from `--author`
+substring matching against a rewrite keyed on exact addresses describes a
+different operation than the one the user is approving.
+
+Then, in one block, state:
+
+- the number of commits rewritten and the number left alone;
+- whether the range contains commits that are **already pushed**. Fetch first —
+  `git fetch origin` then `git branch -r --contains <oldest-in-range>` — because
+  the check reads `refs/remotes/`, and a stale tracking ref reports "local only"
+  for a branch a teammate already has;
+- whether the range crosses the **default branch** — rewriting merged history
+  is a different order of disruption and gets its own sentence;
+- the backup ref you are about to write.
+
+**Ask for the rewrite and, when the range is already pushed, the force-push in
+the same block.** [`git-history-discipline`](../../../rules/git-history-discipline.md)
+requires a rewrite of pushed history to be re-pushed in the same turn or not
+performed at all, and
+[`non-destructive-by-default`](../../../rules/non-destructive-by-default.md)
+forbids acting in the turn you ask. Splitting the two questions satisfies
+neither: a "no" to a later push question strands the repository in exactly the
+rewritten-but-unpushed state the first rule forbids. So both answers come first,
+then both actions run, in the turn after the answer. A "no" to either means
+nothing is rewritten at all.
+
+Wait. Do not run anything in the turn you ask.
+
+### 7. Rewrite
+
+**7a. Backup, and capture what the verification will compare against.**
+
+```bash
+git tag "backup/pre-message-fix-$(date +%Y%m%d-%H%M%S)"
+git rev-list --count HEAD > /tmp/precount.txt
+git log ${BASE:+$BASE..}HEAD --pretty=format:'%aN%x09%aE%x09%ad%x09%s' > /tmp/preplan.txt
+```
+
+The count and the subject/author list are captured **before** the rewrite
+because step 7c compares against them. A verification that has no baseline is
+not a verification.
+
+**7b. Rewrite the messages.**
+
+`git filter-repo` with a `--commit-callback`, because the callback needs the
+author email to honour the scope from step 5 — `--message-callback` sees the
+message alone and cannot. A worked example, normalising a ticket prefix to one
+bracketed form:
+
+```bash
+git filter-repo --force --refs "${BASE:+$BASE..}HEAD" \
+  --commit-callback '
+    import re
+    ME = {b"me@example.com"}                  # the step-5 address set, bare, no <>
+    PAT = re.compile(rb"^\[?([A-Z][A-Z0-9]+-[0-9]+)\]?[: ]\s*(.+)$")
+    if len(commit.parents) > 1:
+        return
+    if commit.author_email not in ME:
+        return
+    subject, sep, body = commit.message.partition(b"\n")
+    m = PAT.match(subject)
+    if m:
+        commit.message = b"[" + m.group(1) + b"] " + m.group(2) + sep + body
+  '
+```
+
+Three things that make the difference between this rewriting the history and
+rewriting nothing:
+
+- **`commit.author_email` is the bare address** — `b"me@example.com"`, never
+  `b"<me@example.com>"`. Compared against the bracketed form it is unequal for
+  every commit, the callback returns on every commit, filter-repo prints
+  `Completely finished` and the hashes are identical. The angle brackets belong
+  in `--author` (step 5) and nowhere else, and the two steps are easy to
+  cross-wire precisely because they need opposite forms.
+- **Merges are skipped in the callback too**, or the rewrite touches commits the
+  step-6 table did not list.
+- **`PAT` and the replacement are the step-3 pattern**, substituted for real.
+  A callback that references a helper nothing defines is not a callback that
+  failed loudly — Python evaluates the name only if control reaches it, so a
+  wrong author filter hides the missing helper completely.
+
+`--refs` implies partial mode, which is what keeps the `origin` remote that
+plain `filter-repo` strips as a safety measure; `--partial` is not needed
+alongside it. Keep bodies intact unless the user asked for body edits — the
+question in step 3 was about subjects.
+
+Fallback without `filter-repo`: a script that reads the subject, applies the
+pattern and amends, run once per commit by `git rebase --exec`:
+
+```bash
+git rebase --exec 'agents/tmp/retitle.sh' "$BASE"    # whole history: --root instead of "$BASE"
+```
+
+Not `-i` (it opens the sequence editor for nothing) and not
+`--reset-author=false` (`--reset-author` takes no value — Git rejects it with an
+`option ... takes no value` error, the exec fails, and the rebase stops
+mid-flight; verified against git 2.x). `git commit --amend -m "<new>"` inside the script preserves
+the author trio and resets the committer. `--root` does rewrite the root commit;
+the constraint on the fallback is conflicts and speed, not reachability.
+
+If an exec does fail, the repository is left detached mid-rebase — `git rebase
+--abort` first, then the step-9 recovery command. `git reset --hard` alone does
+not exit that state.
+
+**7c. Verify against the baseline, not against the tree.**
+
+```bash
+git rev-list --count HEAD                                  # equals /tmp/precount.txt
+git diff <backup-tag> HEAD --stat                          # MUST be empty
+git log ${BASE:+$BASE..}HEAD --pretty=format:'%aN%x09%aE%x09%ad%x09%s' > /tmp/postplan.txt
+diff /tmp/preplan.txt /tmp/postplan.txt
+```
+
+The empty `git diff` proves **no content moved** — and it is equally empty when
+the rewrite did nothing at all, so on its own it is a tautology, not evidence.
+The `diff` of the two plan files is what carries the claim: every line that
+differs must differ only in its last field, and the set of changed subjects must
+match the step-6 preview. Author name, email and date are the first three
+fields, so the same diff proves they survived. Report the actual output of both.
+
+### 8. Push
+
+The authorisation was taken in step 6, together with the rewrite's. Push in this
+turn:
+
+```bash
+git push --force-with-lease origin <branch>
+git log --oneline -3 origin/<branch>
+```
+
+`--force-with-lease`, never bare `--force`. Leave the backup tag in place. Tell
+the user its name, and that recovery is `git reset --hard <backup-tag>` — plus a
+force-push, since the rewrite was already pushed.
+
+### 9. Report
+
+- Convention chosen, and how it was established (measured / user-supplied / tier-1).
+- Range, author scope, commits rewritten vs unchanged.
+- The `diff /tmp/preplan.txt /tmp/postplan.txt` result and the
+  `git diff <backup-tag> HEAD --stat` result, both quoted.
+- The backup tag and the one-line recovery command.
+- Whether it was pushed, and to where.
+
+## Do NOT
+
+- Do NOT rewrite anything before both the style answer and the step-6 yes.
+- Do NOT split the rewrite and force-push authorisations across two turns.
+- Do NOT widen past the invoking user's own commits without an explicit
+  instruction — and never by offering it as a menu option they did not raise.
+- Do NOT compare `commit.author_email` against a bracketed address, or pass a
+  bare address to `--author`.
+- Do NOT treat an empty `git diff <backup> HEAD` as proof the rewrite happened.
+- Do NOT use `git filter-branch`, bare `git push --force`, or `--no-verify`.
+- Do NOT rewrite into a style the repo's own validator rejects.
+- Do NOT let a chosen style carry an attribution trailer, a subject emoji, or
+  anything `secret-vcs-guard` would stop at write time.

package/dist/agent-src/commands/fix.md

@@ -2,10 +2,10 @@
 model_tier: medium
 name: fix
 disable-model-invocation: true
-argument-hint: "[ci|refs|portability|seeder|pr-comments|pr-comments-loop|comments|quality|route] [args]"
+argument-hint: "[ci|refs|portability|seeder|pr-comments|pr-comments-loop|comments|commit-messages|quality|route] [args]"
 pack: engineering-base
-intent: "Fix-workflow dispatcher — ci, pr-comments, pr-comments-loop, refs, seeder, portability, comments, quality"
-routes_to: [fix-ci, fix-pr-comments, fix-pr-comments-loop, fix-refs, fix-seeder, fix-portability, fix-comments, fix-quality, fix-route]
+intent: "Fix-workflow dispatcher — ci, pr-comments, pr-comments-loop, refs, seeder, portability, comments, commit-messages, quality"
+routes_to: [fix-ci, fix-pr-comments, fix-pr-comments-loop, fix-refs, fix-seeder, fix-portability, fix-comments, fix-commit-messages, fix-quality, fix-route]
 replaces: []
 visibility: advanced
 description: Fix orchestrator — routes to ci, references, portability, seeder, pr-comments, comments, quality
@@ -38,6 +38,7 @@ with a single entry point + sub-command dispatch.
 | `/fix pr-comments` | `commands/fix/pr-comments.md` | Fix and reply to all open review comments — **bot + human, classified per comment**; dedupes by comment id + reply marker |
 | `/fix pr-comments-loop` | `commands/fix/pr-comments-loop.md` | Autonomous loop over `pr-comments` (auto mode): fix → commit+push → re-request Copilot review → wait — repeats until Copilot has no new comments; requires a PR URL |
 | `/fix comments` | `commands/fix/comments.md` | Review the **code comments** in the current branch's diff and simplify, shorten, or remove each one (≠ `pr-comments`, which targets GitHub review threads) |
+| `/fix commit-messages` | `commands/fix/commit-messages.md` | Measure the repo's commit convention, ask which style (custom always offered) and how far back, then rewrite past commit **subjects** to it — own commits by default, author identity preserved, backup tag + explicit rewrite/push gates |
 | `/fix quality` | `commands/fix/quality.md` | Run the quality pipeline (type-checker / linter / formatter, PHP and/or JS/TS) and fix every error — auto-detects language from changed files |
 | `/fix route` | `commands/fix/route.md` | Classify a vaguely-described problem and dispatch to the right fix sub (or name the specialist when it is not a fix task) — the `/smart-fix` front door, folded into the `fix` verb |
 
@@ -60,6 +61,7 @@ the `auto_detect` kill-switch, rollback). Detection table:
 | Source-code comments are the target ("simplify/clean up the comments in my branch", "trim comment noise") | `fix/comments` | HIGH |
 | Seeder / FK breakage named | `fix/seeder` | HIGH |
 | Type-checker / linter / formatter errors in context ("fix the quality errors", PHPStan/tsc/eslint output) | `fix/quality` | HIGH |
+| Past commit **messages** are the target ("clean up my commit messages", "make the history conventional") | `fix/commit-messages` | HIGH |
 | Project-specific leakage in shared package named | `fix/portability` | MEDIUM |
 | No clear signal, or ≥ 2 conflict | — | LOW → menu (interactive) / `ambiguous_routing` (CI) |
 

package/dist/agent-src/rules/commit-conventions.md

@@ -18,7 +18,7 @@ obligation_frequency: "per-commit"
 
 # Commit Conventions
 
-**Iron Law.** Use Conventional Commits (`feat:`, `fix:`, `chore:` …); branches `<type>/<short-slug>`; never invent your own format. Subjects + branch names stay emoji-free per [`no-decorative-emojis-in-git-surfaces`](no-decorative-emojis-in-git-surfaces.md); body emojis allowed only with an in-artifact legend.
+**Iron Law.** Match the repo's configured or approved convention; else Conventional Commits (`feat:`, `fix:` …), branches `<type>/<short-slug>`; never invent one. Subjects + branch names stay emoji-free per [`no-decorative-emojis-in-git-surfaces`](no-decorative-emojis-in-git-surfaces.md); body emojis need an in-artifact legend.
 
 Body migrated to `skill:conventional-commits-writing` (per P4 of `road-to-kernel-and-router.md`).
 Trigger-set above activates this routing on demand, independent of the discipline profile (ADR-110).

package/dist/agent-src/rules/security-sensitive-stop.md

@@ -3,11 +3,8 @@ type: "auto"
 tier: "2a"
 alwaysApply: false
 description: "Security-sensitive paths (auth, billing, tenants, secrets, uploads, webhooks) — threat-model BEFORE editing"
-# Trigger set disjoint from secret-vcs-guard by design (2026-08-04): bare
-# `secret` / `password` belong to the VCS-write surface (secret-vcs-guard);
-# this rule keeps the conversational security surface (editing auth/billing/
-# tenant/webhook paths and secrets *infrastructure*, not committing a
-# credential).
+# Disjoint from secret-vcs-guard by design (2026-08-04): bare `secret` /
+# `password` are that rule's VCS-write surface, not this rule's.
 triggers:
   - keyword: "auth"
   - keyword: "billing"
@@ -15,6 +12,11 @@ triggers:
   - keyword: "webhook"
   - keyword: "oauth"
   - keyword: "signing key"
+  - keyword: "file upload"
+  - keyword: "ssrf"
+  - keyword: "api resource"
+  - keyword: "public endpoint"
+  - keyword: "status endpoint"
 validator_ignore:
   - type: "substring"
     pattern: "../../docs/"