@sabaiway/agent-workflow-kit 11.1.0 → 11.2.0

package/CHANGELOG.md

@@ -4,6 +4,72 @@ Semantically versioned ([semver](https://semver.org)), newest first. The `versio
 is the current release. `upgrade` mode reads a project's `docs/ai/.workflow-version` and applies
 every `migrations/<version>-<slug>.md` newer than it, in semver order.
 
+## 11.2.0 — a field report is triaged through a rendered procedure over a checked record (AD-132)
+
+Three consumer field reports were triaged ad hoc — verify each claim on HEAD, record the verdict,
+queue with a hand ratchet bump — with no record shape, no anchor check and nothing rendering the
+steps. The answer is not a skill: a fourth activity, a record grammar a checker can refuse, and a
+procedure the advisor renders. Contract: `docs/ai/specs/kit/feedback-triage.md` (live, S1–S15 bound).
+
+**The fourth activity.** `ACTIVITIES` in `tools/carriers.mjs` gains `feedback-triage` with ONE slot,
+`review`, and `policy: false` — a chore inside a session like `routine`; no `carrier` slot, no
+autonomy block. `procedures feedback-triage` renders the engine's canon section verbatim (Record ·
+Verify · Check · review {recipe} · Rows · Fold; Definition of Done: a checked record, its rows in the
+queue, the ratchet moved by exactly the rows rendered). Every activity list names it (four mode docs name
+it and `recommendations.md` carries the count, both READMEs, the engine SKILL and README, the methodology slot — the outgoing three-activity
+fragment joins `KNOWN_PRIOR_METHODOLOGY_SLOT`); `set-recipe`, `recipes`, `status` and the registry
+survey take the slot; the golden active-recipes line carries `feedback-triage.review = reviewed`
+(computed default); the tarball pin counts 287.
+
+**The record and its checker.** `docs/plans/FEEDBACK-<date>-<slug>.md` — scratch by the in-flight-plan
+prefix — is one grammar, version 1: `# Feedback:` title, `Source:`, `Head: <object id>`, `## Claims`
+and ONE pipe table (`#` · claim · backticked `path:line[-line]` anchors · `confirmed` / `corrected` /
+`refuted` / `works-as-designed` · `queue <ROW-ID>` / `already-queued <ROW-ID>` / `declined: <reason>` /
+`folded: <reason>`), optional `## Notes`. `tools/feedback-record.mjs` (the pure half: parse, judge,
+render rows, render excerpts, the ratchet line — imports nothing) and `tools/feedback-record-cli.mjs`
+(`--check <record>`, `--check <record> --excerpts <out>`, `--rows <record>`; `main(argv, deps)` never
+exits). `--check` reads the record and every anchor no-follow and capped, realpath-contained under
+the cwd, decodes fatally, compares `Head:` to `git rev-parse HEAD` under the git-location leaf with
+`GIT_OPTIONAL_LOCKS=0`, then proves tracking POSITIVELY: each anchor's LEXICAL git-top-relative path
+rides ONE `git status --porcelain -z` and ONE `git ls-files -v -z` as the pathspec `:(literal)<rel>`
+— a rel the index does not list is `anchor-dirty` "not tracked at the stamped HEAD" (`.git/config`,
+an untracked file, a path through a symlinked parent), a tag other than `H` is `anchor-dirty` behind
+a concealing index bit, `H` with a status entry "differs", `H` and clean is proof. Every defect has
+one name from a closed set (`title` · `source` · `head` · `table` · `row-cells` · `claim-id` ·
+`anchor-grammar` · `anchor-path` · `verdict` · `disposition` · `anchor-absent` · `anchor-unreadable`
+· `anchor-line` · `anchor-dirty` · `git-location` · `head-mismatch` · `excerpts-destination` ·
+`excerpts-budget` · `excerpts-write` · `EEXIST`): a structural defect (title, source, head, table)
+ends the read with its name, a row defect is listed per row and an anchor finding per anchor —
+never the first only. Exit 0 accept · 1 findings · 2 usage. `--excerpts` writes the verbatim anchor lines — the `--facts` payload of
+the record's agy review — under `grounding.mjs`'s scratch-destination guard with an exclusive create,
+budgeted at `DEFAULT_MAX_PROMPT_BYTES` minus the record minus `EXCERPTS_FRAMING_RESERVE_BYTES` (4096),
+each text split once, the walk stopped at the budget, tail-trimmed through `trimToBudget`; a text
+that would not begin with an excerpt line is `excerpts-budget`, nothing written. `--rows` prints one
+skeleton queue row per distinct `queue <ROW-ID>` and the `--max-rows` ratchet line read from the git
+top's `docs/ai/gates.json`. Suites: `feedback-record.test.mjs`, `feedback-record-cli.test.mjs`,
+`feedback-record-cli-anchors.test.mjs` (the S9 state table) over the shared
+`feedback-record-cli-harness.test.mjs`.
+
+**The advisor renders the record as the review artifact.** For `feedback-triage` the procedures
+advisor suppresses the driving contracts and the grounding pre-step and renders, after the slot's
+reason, the check line with `--excerpts`, then one line per review member — `codex-review plan
+<record>`, `agy-review plan <record> --facts @<facts>`, a ready lens's brief over the record plus the
+excerpts, a skipped line for a not-ready member — and `review-rounds-cli --artifact <record>
+--activity feedback-triage` followed by the persisted-obligation fact whenever the slot carries a
+bridge obligation (a lens-only roster gets the no-receipt fact); `<record>` and `<facts>` stay
+literal. The JSON key is `feedbackTriage`; the lens survey seam is `ctx.surveyLens ?? ((spec) => …)`.
+
+**The seed note.** The canonical `_README` names four activities and states the defaults honestly —
+the seed keeps its two-activity shape, so `feedback-triage.review` is silent and "reviewed as soon as
+a review backend is ready (solo until then)"; the outgoing four-activity note joins
+`KNOWN_PRIOR_README` and both seed twins carry the canonical byte for byte.
+
+**Recorded tech debt (queue).** The note's "every slot seeded below" clause is a claim about the file;
+the plain-`solo` render of the activity; the status flags decide nothing after the positive proof;
+the registry suite walks one direction only; the import-boundary pin's grammar; S1's wording; a
+submodule anchor reads "not tracked"; `status` / Recommendations drop `r.roster`; the `--kit-tools`
+tier cannot take the checker.
+
 ## 11.1.0 — the bootstrap offers enforcement on every project, and the advisor closes the loop (AD-131)
 
 Bootstrap steps 8–9 (the enforcement scripts + the pre-commit hook) used to decide by the step-1

package/README.md

@@ -232,8 +232,8 @@ file), or run the guarded `/agent-workflow-kit uninstall`.
 | `/agent-workflow-kit gates` | any time | **project gate runner** — runs the verification commands **your project itself declares** in `docs/ai/gates.json` (seeded at deploy; hand-editable `{ id, title, cmd }` entries plus the optional boolean `lcovProducer`, each `cmd` one bash line) as one batch: a per-gate **PASS/FAIL table** + one machine-readable summary line, exit 0 iff all green; a failing gate's own output is shown verbatim; `--only <id>` re-runs one. Honest distinct outcomes for a missing / empty / malformed declaration — never a silent green. The runner writes nothing **by default** and never commits — opt-in `--final` runs the FULL declared matrix and mints ONE final-run receipt into the git-dir core-evidence store (status green/red, pre/post tree fingerprints, the declaration, the consumed lcov's sha; the receipt the commit-guard binds); it executes only your own declared commands (a batching convenience, not a sandbox). The velocity tier auto-approves only the exact no-`--final` form — the recording run stays explicit. |
 | `/agent-workflow-kit setup [backend]` | opt-in, any time | **link-only** auto-setup of a bridge: places the bundled bridge skill (only into an absent / empty / managed dir — never overwrites an unmanaged one) + links its wrappers onto `PATH` via managed symlinks (idempotent; refuses to clobber a non-symlink; try `--dry-run` to preview). The binary install + the one-time subscription login stay **manual**: it prints the exact **login** command and points the binary install at each bridge's `setup/README.md`. POSIX wrappers — on Windows use WSL. Never commits, never runs a subscription CLI. |
 | `/agent-workflow-kit status` | any time | **read-only** single view of **versions + deployment + settings + bridges**: which members (kit / memory / engine / the two bridges) are installed and at what version (with an honest "installed on this machine" note when one is behind) and — in a project — what's deployed (`docs/ai`, the version stamps, and the **visibility**: visible / hidden / unclear), and the **feature-spec adoption state** (`not adopted` / `adopting (N draft)` / `adopted (N live, M draft)` / `could not be read`, plus `declined` when recorded), plus your settings (orchestration recipes, attribution, velocity) and the bridges' readiness. The two version axes (package number vs deployment-structure head) stay decoupled. Never writes, never commits, never runs a subscription CLI. |
-| `/agent-workflow-kit recipes` | any time | **read-only** orchestration advisor: presents five named recipes for composing the carriers of a step — the bridges and the full-tool executor subagent — into plan → execute → review — **Solo / Reviewed / Council / Delegated / Subagent** — plans + recommends one for your environment (degrading with a stated reason when a backend isn't ready, or when the executor vehicle is missing/unusable), and offers the choice. The activity/slot registry (three activities) is rendered by `procedures` and by `set-recipe --help`. The orchestrator runs it via the bridge skills or the executor vehicle and **always commits**; the kit never executes a recipe, never runs a subscription CLI, never commits. |
-| `/agent-workflow-kit procedures <activity>` | any time | **read-only** activity-procedures advisor: prints a named activity's ordered steps (`plan-authoring` / `plan-execution` / `routine`) read **live** from the engine, plus the **resolved recipe per slot** from your `docs/ai/orchestration.json` (agent-writable via `set-recipe`, or hand-edited) + carrier readiness (`plan-authoring`: author, fold, review; default Reviewed when a backend is ready, Council on request; slot-aware incl. Delegated and Subagent) — and, for every dispatched backend, the **full driving contract at the point of use** (exact copy-pasteable invocation, grounding levers like agy's `--facts`/`--decided`, the round-2 `--continue` delta, guarded passthrough), verbatim from the bridge manifests (drift-guarded; each wrapper's `--help` prints the same). `--override <slot>=<value>` adjusts one slot per run. Composes with `recipes`; never writes, never commits, never runs a subscription CLI. |
+| `/agent-workflow-kit recipes` | any time | **read-only** orchestration advisor: presents five named recipes for composing the carriers of a step — the bridges and the full-tool executor subagent — into plan → execute → review — **Solo / Reviewed / Council / Delegated / Subagent** — plans + recommends one for your environment (degrading with a stated reason when a backend isn't ready, or when the executor vehicle is missing/unusable), and offers the choice. The activity/slot registry (four activities) is rendered by `procedures` and by `set-recipe --help`. The orchestrator runs it via the bridge skills or the executor vehicle and **always commits**; the kit never executes a recipe, never runs a subscription CLI, never commits. |
+| `/agent-workflow-kit procedures <activity>` | any time | **read-only** activity-procedures advisor: prints a named activity's ordered steps (`plan-authoring` / `plan-execution` / `routine` / `feedback-triage`) read **live** from the engine, plus the **resolved recipe per slot** from your `docs/ai/orchestration.json` (agent-writable via `set-recipe`, or hand-edited) + carrier readiness (`plan-authoring`: author, fold, review; default Reviewed when a backend is ready, Council on request; slot-aware incl. Delegated and Subagent) — and, for every dispatched backend, the **full driving contract at the point of use** (exact copy-pasteable invocation, grounding levers like agy's `--facts`/`--decided`, the round-2 `--continue` delta, guarded passthrough), verbatim from the bridge manifests (drift-guarded; each wrapper's `--help` prints the same) — except `feedback-triage`, whose record-bound block carries the check with `--excerpts`, the resolved member lines (ready bridge commands, the ready lens brief, or explicit skipped members), and either the record round-table command for a bridge obligation or the no-receipt fact otherwise: the record is the artifact. `--override <slot>=<value>` adjusts one slot per run. Composes with `recipes`; never writes, never commits, never runs a subscription CLI. |
 | `/agent-workflow-kit set-recipe` | any time | **config writer** for `docs/ai/orchestration.json`: tell the agent your preference in plain language and it maps it to explicit `--set <activity>.<slot>=<value>` / `--unset` ops; the kit validates, **previews by default**, and writes only on `--write` (deployment-gated, atomic, symlink/TOCTOU-safe), resolving the effective recipe vs live readiness. Writes **only** that file — **never runs a backend or a subagent, never commits**; hand-editing stays fully supported. |
 | `/agent-workflow-kit review-state` | any time | **read-only review-receipt checker** — makes "reviewed ≠ shipped" detectable: the bridge review wrappers append a receipt per successful review (into a file inside the git dir — never committable); this checks that every backend your configured `plan-execution.review` recipe names holds a **fresh, grounded receipt for the current uncommitted tree** (any later edit moves the fingerprint and stales the receipt; a review continuation never re-attests a folded tree). `--check` gives a gate exit code to declare in `docs/ai/gates.json` **by hand or via the consent-gated seeder** (preview → your explicit yes; never without consent). `--await [--timeout <s>]` (AD-049) BLOCKS until every recipe-named backend has receipted the current tree — the durable completion signal is the receipt, never a process event — so you wait for the bridges instead of hand-polling. Never writes, never commits, never runs a subscription CLI; it spawns read-only `git` queries to fingerprint the tree — and `git commit --no-verify` stays possible (discipline, not a sandbox). |
 | `/agent-workflow-kit sandbox-masks` | any time | **cosmetic exclude lane for sandbox device masks** — an OS sandbox (Claude Code) injects character-device masks into the work tree as untracked `git status` noise; the review domain already ignores them **by construction** (never-committable untracked classes — char/block devices, FIFOs, sockets — are excluded from the fingerprint, the assembled review payload, and the clean checks). This mode hides them from `git status` too: flagless = read-only probe (derives the CURRENT mask set from the unfiltered walk + lstat — never a frozen list — and revalidates fenced entries, loudly flagging one that became a real path); `--apply` = consent-gated FULL-BLOCK replace of its own fenced block in `git rev-parse --git-path info/exclude` (stale masks drop by construction; `--clear` always means REMOVE the block — it takes precedence over the derivation). Writes ONLY its fence — never `.gitignore`, never global config; symlinked/non-regular exclude paths and malformed fences fail closed. Watch note: a real file at an excluded path is silently skipped by bulk staging (`git add -A`/`git add .`) — delete the stale line first; the probe flags exactly this case. |

package/SKILL.md

@@ -3,7 +3,7 @@ name: agent-workflow-kit
 description: Deploy or upgrade a portable AI-agent memory-and-workflow system in any project. Use when the user wants to bootstrap `docs/ai/` + an entry-point `AGENTS.md` (+ `CLAUDE.md` alias) + cap/archive/index enforcement in a new or existing repo, set up the Memory Map and session protocols, install the docs-rotation pre-commit hook, or run `/agent-workflow-kit` / `/agent-workflow-kit upgrade`. Triggers on phrases like "set up the memory system", "deploy the AI workflow here", "bootstrap docs/ai", "upgrade the workflow".
 disable-model-invocation: true
 metadata:
-  version: '11.1.0'
+  version: '11.2.0'
 ---
 
 # agent-workflow-kit

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "11.1.0",
+  "version": "11.2.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/references/modes/procedures.md

@@ -4,11 +4,12 @@
 
 Read-only **activity-procedures advisor**. Answers *"what are the steps of this named activity, and which recipe applies at each slot here?"* It composes the orchestration recipes (`${CLAUDE_SKILL_DIR}/references/modes/recipes.md`) into **named activities** with **typed recipe slots**. It **never writes, never commits, never runs a subscription CLI** — the deterministic resolution lives in the kit; the orchestrator runs the resolved recipe via the bridge skills or the executor vehicle and **owns any commit when the activity has a commit boundary** (every other carrier never commits). Not every activity commits: `plan-authoring` ends at approval and produces no commit (plans are ephemeral, never committed); `plan-execution` commits per ledger row.
 
-The three activities (canon in the **installed engine**, `references/procedures.md`; the registry is `tools/carriers.mjs`):
+The four activities (canon in the **installed engine**, `references/procedures.md`; the registry is `tools/carriers.mjs`):
 
 - **`plan-authoring`** (slots: `author`, `fold`, `review`) — research → draft (the resolved `author` carrier drafts: Solo writes it, Subagent drafts from the orchestrator's brief) → self-review with the readers sweep first → **review {recipe}** → consult, then fold/loop through the resolved `fold` carrier → present for approval; enforce the mandatory Cleanup.
 - **`plan-execution`** (slots: `execute`, `review`) — per ledger row: resolve the recipe → if Delegated, dispatch execution first; if Subagent, dispatch file-disjoint slices to the executor vehicle and verify each returned slice → implement → self-review → **review {recipe}** → gates → commit boundary; after the last row, the project-declared stages and Phase: Cleanup run as rows of their own.
 - **`routine`** (slots: `carrier`, `parallel`) — name the chore and its file-disjoint slices → resolve → carry it (Solo, or Subagent: a read-only slice rides a placed read-only vehicle, a write-capable one rides the executor; `parallel` on → concurrently) → verify every returned slice; the commit boundary is unchanged.
+- **`feedback-triage`** (slot: `review`) — record → verify every claim by code on the stamped HEAD → `feedback-record-cli --check` → **review {recipe}** over the record, the excerpts as agy's `--facts` payload → `--rows` renders the queue rows and the ratchet line → fold only a false statement in shipped copy.
 
 Value sets per slot type: `review` accepts `solo | reviewed | council`; `execute` accepts `solo | delegated | subagent`; a carrier slot (`author`, `fold`, `carrier`) accepts `solo | subagent`; `parallel` is a **switch**, `on | off`, resolved outside the recipe lattice. Defaults when the config is silent: `review` → Reviewed if a review-capable backend is ready, else Solo; `author`, `fold`, `execute`, `carrier` → Solo (a placed executor never flips a default); `parallel` → on. The orchestrator owns every commit; every other carrier — a bridge or a subagent — never commits.
 
@@ -38,6 +39,8 @@ Run **`node ${CLAUDE_SKILL_DIR}/tools/procedures.mjs <activity> [--override <slo
 
 **Robustness-brief block (`plan-execution` only).** The advisor renders `node ${CLAUDE_SKILL_DIR}/tools/robustness-brief.mjs --plan <plan>` populated when exactly one plan is in flight and names the zero/several-plan placeholder reason otherwise. `--json` carries the identical lines under **`robustnessBrief`**, an empty array outside `plan-execution`; human and structured renders share one block.
 
+**Record-bound review block (`feedback-triage` only).** In place of the driving contracts and the grounding pre-step the advisor renders the check-with-excerpts line, then one line per review member — a ready bridge's plan-mode command, a ready lens's brief (the record plus the excerpts), a skipped line for a not-ready member — and the round-table line while the slot carries a bridge obligation (a roster naming no bridge: the no-receipt fact in its place; a fully degraded reviewed or council slot keeps the line). The round-table line is followed by the standing fact that the table judges the obligation `review-rounds-cli` resolves from `docs/ai/orchestration.json`, never this run's `--override`. `--json` carries the identical lines under **`feedbackTriage`** (an empty array for the other activities).
+
 **Cap-soft-skip degradation (the feature's only AUTO route).** The activity procedures are auto-discoverable only through the one-line **`workflow:methodology`** pointer (this kit + the engine carry `disable-model-invocation:true`, so NL like "write a plan" does **not** auto-load this skill). On a deployment whose methodology pointer was cap-soft-skipped — or whose pre-existing customized pointer lacks the procedures clause — the procedures are still reachable by **explicitly** invoking `/agent-workflow-kit procedures`; surface that plainly rather than treating it as a gap.
 
 **Invariants:** read-only · never writes · never commits · never runs a subscription CLI · the deterministic resolution is the kit's, the recipe execution is the orchestrator's.

package/references/modes/recipes.md

@@ -16,7 +16,7 @@ The five recipes (defined over each bridge's `provides` roles — `codex`: execu
 2. **Offer the choice** via **`AskUserQuestion` where your agent supports it** (`AskUserQuestion` in Claude Code) — one option per recipe, the `recommendRecipe` choice listed **first** — otherwise in prose. Then print `planRecipe(chosen, detection)` (the per-stage dispatch + degradation reasons + quota/health notes) so the user sees exactly what running it entails.
 3. **Availability = `readiness === ready`, full stop.** Every other readiness supplies the human reason (needs-skill → "not installed — `/agent-workflow-kit setup`"; needs-cli → "install the CLI"; needs-credentials → "log in"; degraded → "wrapper not on PATH — `/agent-workflow-kit setup`"). This is set-up state only — **never** a claim that a backend's service is responsive (the detector cannot observe a runtime stall; `agy`'s Issue-001 is a *standing advisory*, not a readiness signal).
 
-**The activities and their slots.** One registry (`tools/carriers.mjs`, re-exported by `recipes.mjs`) names **three** activities and their typed slots: `plan-authoring` → `author`, `fold`, `review`; `plan-execution` → `execute`, `review`; `routine` → `carrier`, `parallel`. Each slot's accepted values follow its TYPE — `review` accepts `solo|reviewed|council`; `execute` accepts `solo|delegated|subagent`; `carrier` accepts `solo|subagent`. **`parallel` is a flag (`on|off`), not a recipe:** it resolves OUTSIDE the recipe lattice, never degrades, and never reaches the planner. A silent slot takes its **computed default** — `solo` for `author`, `fold`, `execute` and `carrier` (placing the executor vehicle never flips a default; the subagent carrier is opt-in exactly as `delegated` is), `reviewed`/`solo` by readiness for `review`, and `on` for `parallel`.
+**The activities and their slots.** One registry (`tools/carriers.mjs`, re-exported by `recipes.mjs`) names **four** activities and their typed slots: `plan-authoring` → `author`, `fold`, `review`; `plan-execution` → `execute`, `review`; `routine` → `carrier`, `parallel`; `feedback-triage` → `review`. Each slot's accepted values follow its TYPE — `review` accepts `solo|reviewed|council`; `execute` accepts `solo|delegated|subagent`; `carrier` accepts `solo|subagent`. **`parallel` is a flag (`on|off`), not a recipe:** it resolves OUTSIDE the recipe lattice, never degrades, and never reaches the planner. A silent slot takes its **computed default** — `solo` for `author`, `fold`, `execute` and `carrier` (placing the executor vehicle never flips a default; the subagent carrier is opt-in exactly as `delegated` is), `reviewed`/`solo` by readiness for `review`, and `on` for `parallel`.
 
 **The configured-recipe line (`--active-line`, read-only).** `node ${CLAUDE_SKILL_DIR}/tools/recipes.mjs --active-line` prints exactly **one** machine-composed line: the **CONFIGURED** recipe of every activity/slot, resolved from the target project's `docs/ai/orchestration.json` (read from the current directory) + live readiness — each slot with its source (configured vs computed default), its degradation stated, and its dispatched wrapper set — explicitly contrasted with the readiness **recommendation** (which is informational; the configured recipes are what runs). Paste it verbatim: it fills the session-start discovery step (the deployed `agent_rules.md` §1.1) and the handover "Active recipes:" slot; `set-recipe` echoes the same line after every successful write. A malformed config fails loud (exit 1), never a silent fallback.
 

package/references/modes/recommendations.md

@@ -20,7 +20,7 @@ Run `node ${CLAUDE_SKILL_DIR}/tools/recommendations.mjs --cwd <project-root> [--
 3. **The apply-through-agent lane — an explicit informed-consent checkpoint:** after presenting, OFFER to apply; the user selects items in plain language; for each selected item you **surface its posture note inline** where one exists (the per-item notes below cover exactly the risk-marked keys; for `sandbox-lane` the note INCLUDES the sandbox-lanes ladder — present the whole ladder inline at the consent moment, never as a bare pointer). The user **explicitly confirms**, and **only then** — **no command runs before confirmation** — do you run the rendered command. Do NOT infer safety from the presence or absence of an `--apply` flag: most items' rendered command IS the mutation and completes on that one run, **including a no-`--apply` mutation** such as `family-freshness`'s `npx … init`. Some items instead render a **dry-run preview** that changes nothing and prints an explicit follow-up `--apply`/mutating command to run NEXT (e.g. `sandbox-lane`'s ack-write — a NEUTRAL recipe fingerprint into the family-owned `docs/ai/acks.json`, never a security key — and the `gates-declaration` seeder): after the SAME confirmation you run that printed follow-up command — no second ask, no improvisation (each writer keeps its own consent semantics: previews, `--apply` flags, refusals). An item marked **HAND-APPLY** (e.g. the `read-lane` stale/missing arms) is **never run by you and never written by the kit** — hand the user its rendered line together with its posture note; HAND-APPLY is **maintainer territory wherever it renders** — the apply slot or the `recipe:` line. For `worktrees-dir` the two classes COMPOSE in one item and the ORDER is part of the contract: its `recipe:` line is the HAND-APPLY grant advice, its apply one-liner is the dry-run ack preview, and you **wait for the maintainer to confirm the grant is applied (or the terminal fallback chosen)** before running that preview and the exact `--apply` command it prints — the ack RECORDS a choice that must already have been made, and against a trusted host NO the item renders no ack at all.
 4. Registry strings (benefits + item texts) are frozen tool data, fact-true, ONE line under the pinned shape cap — posture/risk detail lives in the notes below at the consent moment, never inline in the overview. The dual velocity+security wording (`safer — blast radius bounded by the OS sandbox, not human attention`) rides ONLY the items with a real security delta (the autonomy render, the sandbox provisioning); the bridge-wrappers item claims **velocity only**.
 
-**The `executor-vehicle` item (the carrier the project already CONFIGURED — beside the `agents` offer, never the same item).** It fires on ONE pair of facts: a slot in `docs/ai/orchestration.json` names `subagent` while the executor vehicle (`.claude/agents/executor.md`) is `missing` or `unusable` — so every such slot silently degrades to solo. That is a configured declaration that is broken, hence **`attention`**, not an offer; its text names the state, its reason and how many configured slots are affected across the three activities. **`placed` and `customized` render NOTHING** (a working vehicle is not a recommendation), a config naming no `subagent` slot renders nothing, and a config the validated reader refuses is a stated **skip**, never an item computed over a shape nothing accepted. It is deliberately DISTINCT from its two neighbours, neither of which can observe this state: the `agents` offer converges the moment nothing is left to PLACE — which a present-but-unusable executor also satisfies — and the review-recipe probe skips a slot configured `subagent` by construction. Its apply is the agents writer's own `cheap-agents.mjs --apply` (the same writer the `agents` item previews; here the rendered line IS the mutation, so read the item's state before confirming), and its `recipe:` line is the hidden-mode reconcile follow-up (`hide-footprint --reconcile`), for a hidden deployment only. Honest limit on convergence: the apply places an ABSENT vehicle, so it clears `missing`; it never overwrites a diverged file and STOPs on a symlink, so on `unusable` the item's apply line carries a `HAND-APPLY:` precondition (fix or remove the file, then run the writer) and an `unusable` vehicle converges only after the maintainer fixes or deletes the file the reason names (the delete-to-reseed the agents mode documents) and applies then. Risk profile: create-only writes under `.claude/agents/` — never `settings.json`, never a commit.
+**The `executor-vehicle` item (the carrier the project already CONFIGURED — beside the `agents` offer, never the same item).** It fires on ONE pair of facts: a slot in `docs/ai/orchestration.json` names `subagent` while the executor vehicle (`.claude/agents/executor.md`) is `missing` or `unusable` — so every such slot silently degrades to solo. That is a configured declaration that is broken, hence **`attention`**, not an offer; its text names the state, its reason and how many configured slots are affected across the four activities. **`placed` and `customized` render NOTHING** (a working vehicle is not a recommendation), a config naming no `subagent` slot renders nothing, and a config the validated reader refuses is a stated **skip**, never an item computed over a shape nothing accepted. It is deliberately DISTINCT from its two neighbours, neither of which can observe this state: the `agents` offer converges the moment nothing is left to PLACE — which a present-but-unusable executor also satisfies — and the review-recipe probe skips a slot configured `subagent` by construction. Its apply is the agents writer's own `cheap-agents.mjs --apply` (the same writer the `agents` item previews; here the rendered line IS the mutation, so read the item's state before confirming), and its `recipe:` line is the hidden-mode reconcile follow-up (`hide-footprint --reconcile`), for a hidden deployment only. Honest limit on convergence: the apply places an ABSENT vehicle, so it clears `missing`; it never overwrites a diverged file and STOPs on a symlink, so on `unusable` the item's apply line carries a `HAND-APPLY:` precondition (fix or remove the file, then run the writer) and an `unusable` vehicle converges only after the maintainer fixes or deletes the file the reason names (the delete-to-reseed the agents mode documents) and applies then. Risk profile: create-only writes under `.claude/agents/` — never `settings.json`, never a commit.
 
 **Per-item posture notes (the consent moment — surface BEFORE running or handing over the apply):**
 

package/references/modes/set-recipe.md

@@ -21,13 +21,14 @@ mapping their wording onto them is your job, not a shipped phrase list.
 
 Run **`node ${CLAUDE_SKILL_DIR}/tools/set-recipe.mjs [--set <activity>.<slot>=<value>]… [--unset <activity>.<slot>]… [--write] [--json]`**:
 
-1. **Grammar — always fully-qualified `<activity>.<slot>`** (the kit never guesses the activity; a bare `review=council` is rejected). The writer takes **every slot of the three activities**, and `--help` prints the registry (`tools/carriers.mjs`) as two blocks:
+1. **Grammar — always fully-qualified `<activity>.<slot>`** (the kit never guesses the activity; a bare `review=council` is rejected). The writer takes **every slot of the four activities**, and `--help` prints the registry (`tools/carriers.mjs`) as two blocks:
 
    ```
    Activities and their slots:
      plan-authoring → author, fold, review
      plan-execution → execute, review
      routine → carrier, parallel
+     feedback-triage → review
 
    Accepted values per slot type:
      review slots accept solo | reviewed | council

package/references/modes/status.md

@@ -13,7 +13,7 @@ Run `node ${CLAUDE_SKILL_DIR}/tools/family-registry.mjs --json [--dir <project>]
 > **Status reads `refresh`; the shared version block + the bootstrap/upgrade footers stay `notes`-based (unchanged this release).** `${CLAUDE_SKILL_DIR}/references/modes/status.md` has its OWN status-only render (above), keyed on `installed[].refresh.behind` / `refresh.recommend`. The shared **version block** (under *The version block + welcome mat* in `${CLAUDE_SKILL_DIR}/references/shared/report-footer.md`) and the bootstrap (step 11) + every upgrade (steps 4 / 8) report footer still consume `installed[].notes` verbatim — that wiring is deliberately **untouched** here (their migration onto `refresh` is deferred). Do not rewrite those footers onto `refresh`.
 2. **Deployment (`--dir`)** (from `project`): whether `docs/ai/` is deployed + the deploy stamps by `display`; and **visibility** — render `project.visibility.state` in **user-safe words only**: *visible (tracked)* / *hidden (git-ignored, local-only)* / *unclear (uncommitted or partially set up)* — **never** the words "hidden fence" or any marker term. A `visibility.error` → surface it plainly. When `project.adrLayout` is **`old`** or **`old-unrotated`**, add a plain-language note that the project still uses an **older ADR layout** and should run the opt-in **`/agent-workflow-kit migrate-adr-store`** to move to the one-file-per-ADR store (preview first; it never commits) — the note is the SAME for both, they differ only in how the older layout was detected (`old` = a retired archive file is still on disk; `old-unrotated` = the project's deployed rotation script predates the store); `migrated` / `none` need no note. Then **one `specs` line, always** (from `project.specs` — the feature-spec layer's adoption state, judged from the store alone): `not adopted` (no `docs/ai/specs/` — the layer was never seeded), `adopting (N draft)` (a store with no live contract yet), `adopted (N live, M draft)`, or `could not be read — <reason>` (the store or a document in it could not be observed; never counted as any of the other three). A recorded decline (`project.specs.declined`) appends ` — declined` to the first two. The internal tokens are `not-adopted` / `adopting` / `adopted` / `unreadable`; render the plain phrases above, never the tokens. An envelope without the field says the installed kit predates it — say so rather than inventing a state.
 3. **Settings (`--dir`, one line each)** (from `project.settings`):
-   - **recipes** — the effective recipe per slot, **one line per slot** over the three activities (`plan-authoring.author` / `.fold` / `.review`, `plan-execution.execute` / `.review`, `routine.carrier` / `.parallel`); each line also carries **where the value came from** (`source` — the project's config, an explicit override, or a computed default) and, when the resolved recipe is not the one that was asked for, **what it degraded from** (`degradedFrom`). Say both in plain words (never the field names): an effective recipe alone cannot tell a deliberate choice from a default, nor a degrade from a config that really names the resolved recipe — and a slot showing `solo` after a degrade from `subagent` is exactly the case the **subagents** line below explains. Detail → `/agent-workflow-kit procedures` / `recipes`; a `recipes.detectError` → say the backends couldn't be checked, so bridge-backed recipes floored at solo; the executor vehicle is unaffected.
+   - **recipes** — the effective recipe per slot, **one line per slot** over the four activities (`plan-authoring.author` / `.fold` / `.review`, `plan-execution.execute` / `.review`, `routine.carrier` / `.parallel`, `feedback-triage.review`); each line also carries **where the value came from** (`source` — the project's config, an explicit override, or a computed default) and, when the resolved recipe is not the one that was asked for, **what it degraded from** (`degradedFrom`). Say both in plain words (never the field names): an effective recipe alone cannot tell a deliberate choice from a default, nor a degrade from a config that really names the resolved recipe — and a slot showing `solo` after a degrade from `subagent` is exactly the case the **subagents** line below explains. Detail → `/agent-workflow-kit procedures` / `recipes`; a `recipes.detectError` → say the backends couldn't be checked, so bridge-backed recipes floored at solo; the executor vehicle is unaffected.
    - **attribution** — `includeCoAuthoredBy` effective; call out a **local override** only when `local` is non-null **and** differs from `project` (a `null` `local` means the key is absent there, so the project value stands — that is not an override).
    - **velocity** — the effective `permissions.defaultMode` + whether an allowlist is seeded (detail → `/agent-workflow-kit velocity`).
    - **subagents** — how many of the kit's subagent vehicles are placed (`agents.placed` of `agents.bundled`; zero placed → the optional `/agent-workflow-kit agents` opt-in), then the **split the line always states separately**: the **read-only vehicles** (`agents.readOnly` — four; none of them grants a shell, three ride a cheap model for mechanical work and one is a read-only review lens) and the **ONE full-tool `executor`**, whose own state is `agents.executor`: *placed* / *customized* (both dispatchable) / *unusable* (`agents.executorReason` carries the reason — say it) / *missing*. That state is what decides whether a slot configured `subagent` can ride it: on **unusable** or **missing** every such slot runs solo instead, so surface it plainly beside the recipes lines and point at `/agent-workflow-kit agents` to place it. It is a claim about the FILE, never about the host. An envelope with no executor state says the installed kit predates the field — say so rather than inventing a state.

package/references/templates/orchestration.json

@@ -1,5 +1,5 @@
 {
-  "_README": "Per-project orchestration config: the recipe used at each step (slot) of each named activity. Easiest: tell the agent in plain language and run the `set-recipe` writer — it interprets your intent, previews the change, and writes valid JSON for you. You can still hand-edit this file directly whenever you prefer; that option never goes away. Three activities are configured independently, and so is each slot within them: 'plan-authoring' (slots author, fold, review), 'plan-execution' (slots execute, review) and 'routine' (slots carrier, parallel). A slot's value is a recipe: a 'review' slot accepts solo | reviewed | council (you self-review / one backend reviews / both review and you synthesize), or an explicit roster array such as [\"codex-review\", \"agy-review\", \"review-lens\"] in hand-edit form; an 'execute' slot accepts solo | delegated | subagent (you implement / a backend runs a bounded sub-task / a full-tool frontier subagent carries a bounded slice you verify); the carrier slots 'plan-authoring.author', 'plan-authoring.fold' and 'routine.carrier' accept solo | subagent. 'routine.parallel' is a flag rather than a recipe: it accepts on | off and decides whether file-disjoint subagent slices dispatch concurrently. The default below is 'solo' for every recipe and carrier slot, and 'on' for the parallel switch — no execution backend required. Raise a slot to reviewed or council for a second opinion, or to delegated to hand off execution; those need an execution backend set up first. 'subagent' needs the executor vehicle placed in this project — the composition root's `agents` writer places it; without it the slot resolves to solo with the reason stated. Remove a slot's line, or a whole activity block (or run `set-recipe --unset <activity>.<slot>`), to fall back to the computed default: reviewed when a review backend is ready and otherwise solo for a review slot, solo for author, fold, execute and carrier, on for parallel. Run the read-only procedures advisor to see an activity's steps plus the recipe resolved for your environment. Strict JSON — no comments.",
+  "_README": "Per-project orchestration config: the recipe used at each step (slot) of each named activity. Easiest: tell the agent in plain language and run the `set-recipe` writer — it interprets your intent, previews the change, and writes valid JSON for you. You can still hand-edit this file directly whenever you prefer; that option never goes away. Four activities are configured independently, and so is each slot within them: 'plan-authoring' (slots author, fold, review), 'plan-execution' (slots execute, review), 'routine' (slots carrier, parallel) and 'feedback-triage' (slot review). A slot's value is a recipe: a 'review' slot accepts solo | reviewed | council (you self-review / one backend reviews / both review and you synthesize), or an explicit roster array such as [\"codex-review\", \"agy-review\", \"review-lens\"] in hand-edit form; an 'execute' slot accepts solo | delegated | subagent (you implement / a backend runs a bounded sub-task / a full-tool frontier subagent carries a bounded slice you verify); the carrier slots 'plan-authoring.author', 'plan-authoring.fold' and 'routine.carrier' accept solo | subagent. 'routine.parallel' is a flag rather than a recipe: it accepts on | off and decides whether file-disjoint subagent slices dispatch concurrently. Every slot seeded below is 'solo' — no execution backend required. A slot the seed leaves silent takes the computed default stated further down: 'feedback-triage.review' is reviewed as soon as a review backend is ready (solo until then); 'plan-authoring.author', 'plan-authoring.fold' and 'routine.carrier' stay 'solo', and 'routine.parallel' stays 'on'. Raise a slot to reviewed or council for a second opinion, or to delegated to hand off execution; those need an execution backend set up first. 'subagent' needs the executor vehicle placed in this project — the composition root's `agents` writer places it; without it the slot resolves to solo with the reason stated. Remove a slot's line, or a whole activity block (or run `set-recipe --unset <activity>.<slot>`), to fall back to the computed default: reviewed when a review backend is ready and otherwise solo for a review slot, solo for author, fold, execute and carrier, on for parallel. Run the read-only procedures advisor to see an activity's steps plus the recipe resolved for your environment. Strict JSON — no comments.",
   "plan-authoring": {
     "review": "solo"
   },

package/tools/carriers.mjs

@@ -15,6 +15,7 @@ export const ACTIVITIES = {
   'plan-authoring': { slots: { author: 'carrier', fold: 'carrier', review: 'review' }, policy: true },
   'plan-execution': { slots: { execute: 'execute', review: 'review' }, policy: true },
   routine: { slots: { carrier: 'carrier', parallel: 'switch' }, policy: false },
+  'feedback-triage': { slots: { review: 'review' }, policy: false },
 };
 
 export const POLICY_ACTIVITIES = Object.fromEntries(

package/tools/feedback-record-cli.mjs

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+// Feedback-record filesystem and argv shell. Governing contract:
+// docs/ai/specs/kit/feedback-triage.md.
+import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { fail } from '../references/scripts/markdown-blocks.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { readFileBytesNoFollowCapped } from './fs-read-nofollow.mjs';
+import { GIT_MAX_BUFFER, resolveGitLocation, stripGitLocationEnv, withGitPath } from './git-env.mjs';
+import { assertScratchDestination, DEFAULT_MAX_PROMPT_BYTES, trimToBudget } from './grounding.mjs';
+import { judgeAnchors, parseRecord, ratchetLine, REFUSALS, renderExcerpts, renderRows } from './feedback-record.mjs';
+
+const RECORD_MAX_BYTES = 1024 * 1024;
+export const EXCERPTS_FRAMING_RESERVE_BYTES = 4096;
+const GATES_REL = 'docs/ai/gates.json';
+const QUEUE_GATE_TOKEN = 'queue-audit-cli.mjs';
+const MODE_FLAGS = Object.freeze(['--check', '--rows']);
+const FATAL_PARSE_REFUSALS = Object.freeze(REFUSALS.slice(0, 4));
+const FINDING_NAMES = Object.freeze({
+  anchorPath: 'anchor-path', anchorDirty: 'anchor-dirty', gitLocation: 'git-location',
+  headMismatch: 'head-mismatch', excerptsDestination: 'excerpts-destination',
+  excerptsBudget: 'excerpts-budget', excerptsWrite: 'excerpts-write', exists: 'EEXIST',
+});
+const GIT_ENV_LOCALE = 'C';
+const GIT_OPTIONAL_LOCKS_DISABLED = '0';
+const EXCLUSIVE_CREATE_FLAG = 'wx';
+const EMPTY_ANSWER_OK = new Set(['status', 'ls-files']);
+const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+const readValue = (argv, index, flag) => {
+  const value = argv[index + 1];
+  if (value === undefined || value === '' || value.startsWith('--')) throw fail(2, `${flag} takes a value`);
+  return value;
+};
+
+const parseArgv = (argv) => {
+  const options = { mode: null, record: null, excerpts: null };
+  const seen = new Set();
+  for (const [index, arg] of argv.entries()) {
+    if (seen.has(index)) continue;
+    if (MODE_FLAGS.includes(arg)) {
+      if (options.mode !== null) throw fail(2, 'name exactly one of --check or --rows');
+      options.mode = arg.slice(2);
+      options.record = readValue(argv, index, arg);
+      seen.add(index + 1);
+    } else if (arg === '--excerpts') {
+      if (options.excerpts !== null) throw fail(2, '--excerpts was given twice');
+      options.excerpts = readValue(argv, index, arg);
+      seen.add(index + 1);
+    } else throw fail(2, `unknown argument: ${arg}`);
+  }
+  if (options.mode === null) throw fail(2, 'one of --check or --rows is required');
+  if (options.excerpts !== null && options.mode !== 'check') throw fail(2, '--excerpts is available only with --check');
+  return options;
+};
+
+const decodeBytes = (bytes) => {
+  try { return FATAL_UTF8.decode(bytes); }
+  catch { return null; }
+};
+const countLines = (text) => text === '' ? 0 : text.split('\n').length - (text.endsWith('\n') ? 1 : 0);
+const getHeadLine = (text) => Math.max(1, text.split('\n').findIndex((line) => line.replace(/\r$/u, '').startsWith('Head: ')) + 1);
+const formatFinding = (record, finding) =>
+  `${String(record).replace(/[\r\n]+/gu, ' ')}:${finding.line}: ${finding.name}: ${String(finding.message).replace(/[\r\n]+/gu, ' ')}`;
+const reportFindings = (record, findings, error) => {
+  for (const finding of findings) error(formatFinding(record, finding));
+  return findings.length === 0 ? 0 : 1;
+};
+
+const readRecord = (recordPath, io) => {
+  const result = readFileBytesNoFollowCapped(recordPath, RECORD_MAX_BYTES, io);
+  if (result.outcome !== 'ok') {
+    const reason = result.outcome === 'over-cap' ? `over the ${RECORD_MAX_BYTES}-byte cap` : result.code ?? result.className ?? result.outcome;
+    throw fail(2, `cannot read regular feedback record ${recordPath}: ${reason}`);
+  }
+  const text = decodeBytes(result.bytes);
+  if (text === null) throw fail(2, `cannot read regular feedback record ${recordPath}: invalid UTF-8`);
+  return { bytes: result.bytes, text };
+};
+
+const isContained = (root, target) => {
+  const rel = relative(root, target);
+  return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+};
+const inspectAnchors = (claims, cwd, io) => {
+  const anchors = claims.flatMap((claim) => claim.anchors);
+  const paths = [...new Set(anchors.map((anchor) => anchor.path))];
+  const facts = Object.create(null);
+  const texts = Object.create(null);
+  const targets = Object.create(null);
+  const findings = [];
+  const resolvedRoot = (() => {
+    try { return { root: realpathSync(cwd), reason: null }; }
+    catch (err) { return { root: null, reason: err?.code ?? err?.message ?? String(err) }; }
+  })();
+  if (paths.length === 0) return { anchors, facts, texts, targets, paths, findings, root: resolvedRoot.root };
+  if (resolvedRoot.root === null) {
+    for (const path of paths) {
+      facts[path] = { kind: 'regular', lines: Number.MAX_SAFE_INTEGER };
+      for (const anchor of anchors.filter((candidate) => candidate.path === path)) {
+        findings.push({ name: FINDING_NAMES.anchorPath, line: anchor.line, path, message: `the working directory cannot be resolved (${resolvedRoot.reason})` });
+      }
+    }
+    return { anchors, facts, texts, targets, paths, findings, root: resolvedRoot.root };
+  }
+  for (const path of paths) {
+    const occurrences = anchors.filter((anchor) => anchor.path === path);
+    const full = resolve(cwd, path);
+    const parent = (() => {
+      try { return realpathSync(dirname(full)); }
+      catch { return null; }
+    })();
+    if (parent === null) {
+      facts[path] = { kind: 'absent' };
+      continue;
+    }
+    const target = join(parent, basename(full));
+    if (!isContained(resolvedRoot.root, target)) {
+      facts[path] = { kind: 'regular', lines: Number.MAX_SAFE_INTEGER };
+      for (const anchor of occurrences) findings.push({ name: FINDING_NAMES.anchorPath, line: anchor.line, path, message: `anchor resolves outside the working tree: ${path}` });
+      continue;
+    }
+    const result = readFileBytesNoFollowCapped(target, RECORD_MAX_BYTES, io);
+    if (result.outcome === 'absent' || result.outcome === 'foreign') {
+      facts[path] = { kind: result.outcome === 'absent' ? 'absent' : 'other' };
+    } else if (result.outcome === 'over-cap' || result.outcome === 'error') {
+      const reason = result.outcome === 'over-cap' ? `over the ${RECORD_MAX_BYTES}-byte cap` : result.code ?? 'read failed';
+      facts[path] = { kind: 'unreadable', reason };
+    } else {
+      const text = decodeBytes(result.bytes);
+      if (text === null) facts[path] = { kind: 'unreadable', reason: 'invalid UTF-8' };
+      else {
+        facts[path] = { kind: 'regular', lines: countLines(text) };
+        texts[path] = text;
+        targets[path] = target;
+      }
+    }
+  }
+  return { anchors, facts, texts, targets, paths, findings, root: resolvedRoot.root };
+};
+
+const runGit = (spawn, cwd, env, args) => {
+  const options = {
+    cwd, env: withGitPath({
+      ...stripGitLocationEnv(env), LC_ALL: GIT_ENV_LOCALE, GIT_OPTIONAL_LOCKS: GIT_OPTIONAL_LOCKS_DISABLED,
+    }),
+    encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, windowsHide: true,
+  };
+  const attempted = (() => {
+    try { return { result: spawn('git', args, options), error: null }; }
+    catch (err) { return { result: null, error: `git threw synchronously (${err?.message ?? err})` }; }
+  })();
+  if (attempted.error !== null) return { error: attempted.error };
+  const result = attempted.result;
+  if (result == null || typeof result !== 'object') return { error: 'the git runner returned no result' };
+  if (result.error) return { error: `git could not run (${result.error.code ?? result.error.message ?? result.error})` };
+  if (result.signal) return { error: `git ${args[0]} was killed by ${result.signal}` };
+  const stderr = String(result.stderr ?? '').trim();
+  if (result.status !== 0) return { error: `git ${args[0]} exited ${result.status}${stderr ? ` (${stderr})` : ''}` };
+  const stdout = String(result.stdout ?? '');
+  if (stdout.length === 0 && !EMPTY_ANSWER_OK.has(args[0])) return { error: `git ${args[0]} answered nothing` };
+  return { stdout };
+};
+
+const parseDirtyPaths = (stdout) => stdout.split('\0').filter(Boolean).map((entry) => entry.slice(3));
+
+const inspectGit = ({ cwd, env, spawn, head, headLine, anchors }) => {
+  const findings = [];
+  const location = resolveGitLocation(cwd, { spawn, env });
+  if (location.state !== 'work-tree') {
+    return { findings: [{ name: FINDING_NAMES.gitLocation, line: headLine, message: `${location.state}: "${location.cause ?? 'unknown cause'}"` }], top: null };
+  }
+  const checkout = runGit(spawn, cwd, env, ['rev-parse', 'HEAD']);
+  if (checkout.error) return { findings: [{ name: FINDING_NAMES.gitLocation, line: headLine, message: checkout.error }], top: null };
+  const actualHead = checkout.stdout.trim();
+  if (actualHead === '') findings.push({ name: FINDING_NAMES.gitLocation, line: headLine, message: 'git rev-parse HEAD answered nothing' });
+  else if (actualHead.toLowerCase() !== head.toLowerCase()) findings.push({ name: FINDING_NAMES.headMismatch, line: headLine, message: `record head ${head} does not match checkout head ${actualHead}` });
+  const resolvedTop = (() => {
+    try { return { value: realpathSync(location.top), error: null }; }
+    catch (err) { return { value: null, error: err?.code ?? err?.message ?? String(err) }; }
+  })();
+  if (resolvedTop.error !== null) {
+    return { findings: [...findings, { name: FINDING_NAMES.gitLocation, line: headLine, message: `the work-tree top cannot be resolved (${resolvedTop.error})` }], top: location.top };
+  }
+  const top = resolvedTop.value;
+  const rels = Object.fromEntries(Object.keys(anchors.targets).map((path) => [
+    path, relative(top, resolve(anchors.root, path)).split(sep).join('/'),
+  ]));
+  if (Object.keys(rels).length === 0) return { findings, top: location.top };
+  const pathspecs = Object.values(rels).map((rel) => `:(literal)${rel}`);
+  const status = runGit(spawn, location.top, env, ['status', '--porcelain', '-z', '--untracked-files=all', '--ignored=traditional', '--', ...pathspecs]);
+  if (status.error) return { findings: [...findings, { name: FINDING_NAMES.gitLocation, line: headLine, message: `${FINDING_NAMES.anchorDirty} cannot be judged: ${status.error}` }], top: location.top };
+  const dirty = new Set(parseDirtyPaths(status.stdout));
+  const listing = runGit(spawn, location.top, env, ['ls-files', '-v', '-z', '--', ...pathspecs]);
+  if (listing.error) return { findings: [...findings, { name: FINDING_NAMES.gitLocation, line: headLine, message: `${FINDING_NAMES.anchorDirty} cannot be judged: ${listing.error}` }], top: location.top };
+  const listed = new Map();
+  for (const entry of listing.stdout.split('\0').filter(Boolean)) {
+    listed.set(entry.slice(2), entry[0]);
+  }
+  for (const path of Object.keys(rels)) {
+    const rel = rels[path];
+    const tag = listed.get(rel);
+    const message = tag === undefined
+      ? `anchor is not tracked at the stamped HEAD: ${path}`
+      : tag !== 'H'
+        ? `the index conceals the working tree for ${path} (ls-files tag ${tag})`
+        : dirty.has(rel)
+          ? `anchor differs from the stamped HEAD: ${path}`
+          : null;
+    if (message === null) continue;
+    for (const anchor of anchors.anchors.filter((candidate) => candidate.path === path)) {
+      findings.push({ name: FINDING_NAMES.anchorDirty, line: anchor.line, path, message });
+    }
+  }
+  return { findings, top: location.top };
+};
+
+const readRatchet = (cwd, rows) => {
+  const path = join(cwd, GATES_REL);
+  const parsed = (() => {
+    try { return { value: JSON.parse(readFileSync(path, 'utf8')), error: null }; }
+    catch (err) { return { value: null, error: err }; }
+  })();
+  if (parsed.error?.code === 'ENOENT') return `ratchet: ${GATES_REL} is absent`;
+  if (parsed.error) return `ratchet: ${GATES_REL} cannot be read (${parsed.error.message})`;
+  const gate = Array.isArray(parsed.value?.gates)
+    ? parsed.value.gates.find((entry) => typeof entry?.cmd === 'string' && entry.cmd.includes(QUEUE_GATE_TOKEN))
+    : null;
+  return gate ? ratchetLine(gate.cmd, rows) : `ratchet: gate carrying ${QUEUE_GATE_TOKEN} is absent`;
+};
+
+const writeExcerpts = ({ options, cwd, recordBytes, anchors, error }) => {
+  const destination = (() => {
+    try { return { value: assertScratchDestination(options.excerpts, cwd), error: null }; }
+    catch (err) { return { value: null, error: err }; }
+  })();
+  if (destination.error) {
+    error(`${FINDING_NAMES.excerptsDestination}: ${String(destination.error.message ?? destination.error).replace(/^--out/u, '--excerpts')}`);
+    return 2;
+  }
+  const budget = DEFAULT_MAX_PROMPT_BYTES - recordBytes - EXCERPTS_FRAMING_RESERVE_BYTES;
+  if (budget <= 0) return reportFindings(options.record, [{ name: FINDING_NAMES.excerptsBudget, line: 1, message: 'the record leaves no byte budget for excerpts' }], error);
+  const payload = renderExcerpts(anchors.anchors, anchors.texts, budget);
+  const trimmed = trimToBudget(payload, budget);
+  if (trimmed.trimmedBytes > 0 && !/^[^\n]/u.test(trimmed.text)) {
+    return reportFindings(options.record, [{ name: FINDING_NAMES.excerptsBudget, line: 1, message: `the ${budget}-byte budget leaves no excerpt line beside the trim marker` }], error);
+  }
+  const written = (() => {
+    try { writeFileSync(destination.value.path, trimmed.text, { flag: EXCLUSIVE_CREATE_FLAG }); return null; }
+    catch (err) { return err; }
+  })();
+  if (written === null) return 0;
+  const name = written.code === FINDING_NAMES.exists ? FINDING_NAMES.exists : FINDING_NAMES.excerptsWrite;
+  return reportFindings(options.record, [{ name, line: 1, message: written.message ?? String(written) }], error);
+};
+
+export const main = (argv, deps = {}) => {
+  const cwd = deps.cwd ?? process.cwd();
+  const env = deps.env ?? process.env;
+  const spawn = deps.spawn ?? spawnSync;
+  const log = deps.log ?? console.log;
+  const error = deps.error ?? console.error;
+  const io = deps.io ?? {};
+  const now = deps.now ?? (() => new Date());
+  const options = (() => {
+    try { return { value: parseArgv(argv), error: null }; }
+    catch (err) { return { value: null, error: err }; }
+  })();
+  if (options.error) { error(options.error.message); return options.error.exitCode ?? 2; }
+  const loaded = (() => {
+    try { return { value: readRecord(resolve(cwd, options.value.record), io), error: null }; }
+    catch (err) { return { value: null, error: err }; }
+  })();
+  if (loaded.error) { error(loaded.error.message); return loaded.error.exitCode ?? 2; }
+  const parsed = parseRecord(loaded.value.text);
+  if (parsed.refusals.some((finding) => FATAL_PARSE_REFUSALS.includes(finding.name))) {
+    return reportFindings(options.value.record, parsed.refusals, error);
+  }
+  const anchors = inspectAnchors(parsed.claims, cwd, io);
+  const git = inspectGit({ cwd, env, spawn, head: parsed.head, headLine: getHeadLine(loaded.value.text), anchors });
+  const findings = [
+    ...parsed.refusals,
+    ...anchors.findings,
+    ...judgeAnchors(parsed.claims, anchors.facts),
+    ...git.findings,
+  ];
+  if (reportFindings(options.value.record, findings, error) !== 0) return 1;
+  if (options.value.mode === 'rows') {
+    const rows = renderRows(parsed, { date: now().toISOString().slice(0, 10), recordPath: options.value.record });
+    for (const row of rows) log(row);
+    log(readRatchet(git.top, rows));
+  }
+  if (options.value.excerpts !== null) {
+    return writeExcerpts({ options: options.value, cwd, recordBytes: loaded.value.bytes.length, anchors, error });
+  }
+  return 0;
+};
+
+if (isDirectRun(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/tools/feedback-record.mjs

@@ -0,0 +1,243 @@
+// Feedback-record grammar and pure judgments. Governing contract:
+// docs/ai/specs/kit/feedback-triage.md.
+
+const REFUSAL_NAMES = Object.freeze({
+  title: 'title', source: 'source', head: 'head', table: 'table', rowCells: 'row-cells',
+  claimId: 'claim-id', anchorGrammar: 'anchor-grammar', anchorPath: 'anchor-path',
+  verdict: 'verdict', disposition: 'disposition', anchorAbsent: 'anchor-absent',
+  anchorUnreadable: 'anchor-unreadable', anchorLine: 'anchor-line',
+});
+export const VERDICTS = Object.freeze(['confirmed', 'corrected', 'refuted', 'works-as-designed']);
+export const REFUSALS = Object.freeze(Object.values(REFUSAL_NAMES));
+
+const TITLE_PREFIX = '# Feedback: ';
+const SOURCE_PREFIX = 'Source: ';
+const HEAD_PREFIX = 'Head: ';
+const CLAIMS_HEADING = '## Claims';
+const NOTES_HEADING = '## Notes';
+const TABLE_HEADER = '| # | Claim | Evidence | Verdict | Disposition |';
+const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu;
+const ANCHOR = /^`([^`,\s]+):([1-9][0-9]*)(?:-([1-9][0-9]*))?`$/u;
+const ROW_ID = '[A-Z0-9][A-Z0-9-]*';
+const QUEUE = new RegExp(`^queue (${ROW_ID})$`, 'u');
+const ALREADY_QUEUED = new RegExp(`^already-queued (${ROW_ID})$`, 'u');
+const REASONED_DISPOSITION = /^(?:declined|folded): (.+)$/u;
+const LINE_JOINER = '\n';
+
+const makeRefusal = (name, line, message) => ({ name, line, message });
+const getLineNumber = (lines, index) => Math.min(index + 1, Math.max(lines.length, 1));
+const findNextContent = (lines, start) => {
+  const index = lines.findIndex((line, offset) => offset >= start && line.trim() !== '');
+  return index === -1 ? lines.length : index;
+};
+const makeFatalResult = (record, name, line, message) => ({
+  ...record, claims: [], refusals: [makeRefusal(name, line, message)],
+});
+
+const splitCells = (line) => {
+  if (!line.startsWith('|') || !line.endsWith('|')) return null;
+  const body = line.slice(1, -1);
+  const parsed = Array.from(body).reduce((state, byte, index) => {
+    if (state.skip) state.skip = false;
+    else if (byte === '\\' && body[index + 1] === '|') { state.cell += '|'; state.skip = true; }
+    else if (byte === '|') { state.cells.push(state.cell.trim()); state.cell = ''; }
+    else state.cell += byte;
+    return state;
+  }, { cells: [], cell: '', skip: false });
+  return [...parsed.cells, parsed.cell.trim()];
+};
+
+const parsesDelimiter = (line) => {
+  const cells = splitCells(line);
+  return cells?.length === 5 && cells.every((cell) => /^-{3,}$/u.test(cell));
+};
+
+const RECORD_STATES = Object.freeze([
+  { name: REFUSAL_NAMES.title, fixed: true, accepts: (line) => line.startsWith(TITLE_PREFIX) && line.slice(TITLE_PREFIX.length).trim() !== '', assigns: (record, line) => { record.title = line.slice(TITLE_PREFIX.length); }, message: `line 1 must be ${TITLE_PREFIX}<title>` },
+  { name: REFUSAL_NAMES.source, accepts: (line) => line.startsWith(SOURCE_PREFIX) && line.slice(SOURCE_PREFIX.length).trim() !== '', assigns: (record, line) => { record.source = line.slice(SOURCE_PREFIX.length); }, message: `expected ${SOURCE_PREFIX}<one line>` },
+  { name: REFUSAL_NAMES.head, accepts: (line) => line.startsWith(HEAD_PREFIX) && OBJECT_ID.test(line.slice(HEAD_PREFIX.length)), assigns: (record, line) => { record.head = line.slice(HEAD_PREFIX.length); }, message: `expected ${HEAD_PREFIX}<object id>` },
+  { name: REFUSAL_NAMES.table, accepts: (line) => line === CLAIMS_HEADING, assigns: () => {}, message: `expected ${CLAIMS_HEADING}` },
+  { name: REFUSAL_NAMES.table, accepts: (line) => line === TABLE_HEADER, assigns: () => {}, message: `expected ${TABLE_HEADER}` },
+  { name: REFUSAL_NAMES.table, accepts: parsesDelimiter, assigns: () => {}, message: 'expected a five-cell table delimiter' },
+]);
+
+const hasUnsafePath = (path) =>
+  path.startsWith('/') || path.includes('\\') || path.split('/').includes('..');
+
+const parseAnchors = (value, line) => {
+  const tokens = value.split(/,\s*/u);
+  if (tokens.length === 0 || tokens.some((token) => token === '')) {
+    return { refusal: makeRefusal(REFUSAL_NAMES.anchorGrammar, line, 'Evidence must name one or more backticked anchors') };
+  }
+  const anchors = [];
+  for (const token of tokens) {
+    const match = ANCHOR.exec(token);
+    if (!match || match[1].includes('|')) {
+      return { refusal: makeRefusal(REFUSAL_NAMES.anchorGrammar, line, `invalid anchor grammar: ${token}`) };
+    }
+    const [, path, startText, endText] = match;
+    if (hasUnsafePath(path)) {
+      return { refusal: makeRefusal(REFUSAL_NAMES.anchorPath, line, `anchor path is not repository-relative: ${path}`) };
+    }
+    const start = Number(startText);
+    const end = endText === undefined ? start : Number(endText);
+    if (start > end) {
+      return { refusal: makeRefusal(REFUSAL_NAMES.anchorGrammar, line, `anchor range starts after it ends: ${token}`) };
+    }
+    anchors.push({ path, start, end, line });
+  }
+  return { anchors };
+};
+
+const parsesDisposition = (value) =>
+  QUEUE.test(value) || ALREADY_QUEUED.test(value) || REASONED_DISPOSITION.test(value);
+
+const parseClaim = (lineText, line, expectedId) => {
+  const cells = splitCells(lineText);
+  if (cells?.length !== 5) {
+    return { refusal: makeRefusal(REFUSAL_NAMES.rowCells, line, 'claim row must contain exactly five cells') };
+  }
+  const [idText, claim, evidence, verdict, disposition] = cells;
+  if (idText !== String(expectedId)) {
+    return { refusal: makeRefusal(REFUSAL_NAMES.claimId, line, `claim id must be ${expectedId}, got ${idText || '(empty)'}`) };
+  }
+  const parsedAnchors = parseAnchors(evidence, line);
+  if (parsedAnchors.refusal) return parsedAnchors;
+  if (!VERDICTS.includes(verdict)) {
+    return { refusal: makeRefusal(REFUSAL_NAMES.verdict, line, `unknown verdict: ${verdict || '(empty)'}`) };
+  }
+  if (!parsesDisposition(disposition)) {
+    return { refusal: makeRefusal(REFUSAL_NAMES.disposition, line, `invalid disposition: ${disposition || '(empty)'}`) };
+  }
+  return {
+    claim: { id: expectedId, claim, anchors: parsedAnchors.anchors, verdict, disposition, line },
+  };
+};
+
+export const parseRecord = (text) => {
+  const lines = String(text).split('\n').map((line) => line.replace(/\r$/u, ''));
+  const record = { head: null, title: null, source: null, claims: [], refusals: [] };
+  const structure = RECORD_STATES.reduce((state, spec) => {
+    if (state.refusal !== null) return state;
+    const index = spec.fixed ? 0 : findNextContent(lines, state.index + 1);
+    const line = lines[index] ?? '';
+    if (!spec.accepts(line)) return { index, refusal: makeRefusal(spec.name, getLineNumber(lines, index), spec.message) };
+    spec.assigns(record, line);
+    return { index, refusal: null };
+  }, { index: -1, refusal: null });
+  if (structure.refusal !== null) {
+    return makeFatalResult(record, structure.refusal.name, structure.refusal.line, structure.refusal.message);
+  }
+  const delimiterIndex = structure.index;
+  const table = lines.slice(delimiterIndex + 1).reduce((state, lineText, offset) => {
+    const line = delimiterIndex + offset + 2;
+    if (state.notes || state.fatal !== null) return state;
+    if (state.done) {
+      if (lineText.trim() === '') return state;
+      if (lineText === NOTES_HEADING) return { ...state, notes: true };
+      return {
+        ...state,
+        fatal: makeRefusal(
+          REFUSAL_NAMES.table,
+          line,
+          `the claims table ended at line ${state.endedLine}; only ${NOTES_HEADING} or the end of the record may follow`,
+        ),
+      };
+    }
+    if (lineText === NOTES_HEADING) return { ...state, done: true, notes: true };
+    if (lineText.trim() === '') return { ...state, done: true, endedLine: line };
+    const parsed = parseClaim(lineText, delimiterIndex + offset + 2, state.expectedId);
+    return {
+      expectedId: state.expectedId + 1,
+      done: false,
+      notes: false,
+      endedLine: null,
+      fatal: null,
+      claims: parsed.claim ? [...state.claims, parsed.claim] : state.claims,
+      refusals: parsed.refusal ? [...state.refusals, parsed.refusal] : state.refusals,
+    };
+  }, { expectedId: 1, done: false, notes: false, endedLine: null, fatal: null, claims: [], refusals: [] });
+  if (table.fatal !== null) {
+    return makeFatalResult(record, table.fatal.name, table.fatal.line, table.fatal.message);
+  }
+  if (table.claims.length === 0 && table.refusals.length === 0) {
+    return makeFatalResult(record, REFUSAL_NAMES.table, delimiterIndex + 1, 'the claims table carries no row');
+  }
+  record.claims = table.claims;
+  record.refusals = table.refusals;
+  return record;
+};
+
+export const judgeAnchors = (claims, facts) => {
+  const findings = [];
+  for (const claim of claims) {
+    for (const anchor of claim.anchors) {
+      const fact = Object.hasOwn(facts, anchor.path) ? facts[anchor.path] : { kind: 'absent' };
+      if (fact.kind === 'absent' || fact.kind === 'other') {
+        findings.push({ name: REFUSAL_NAMES.anchorAbsent, line: anchor.line, path: anchor.path, message: `anchor is absent or not a regular file: ${anchor.path}` });
+      } else if (fact.kind === 'unreadable') {
+        findings.push({ name: REFUSAL_NAMES.anchorUnreadable, line: anchor.line, path: anchor.path, message: `anchor cannot be read: ${anchor.path} (${fact.reason ?? 'unknown reason'})` });
+      } else if (anchor.end > fact.lines) {
+        findings.push({ name: REFUSAL_NAMES.anchorLine, line: anchor.line, path: anchor.path, message: `anchor line ${anchor.end} exceeds ${fact.lines} lines in ${anchor.path}` });
+      }
+    }
+  }
+  return findings;
+};
+
+const rendersAnchor = (anchor) => `${anchor.path}:${anchor.start}${anchor.end === anchor.start ? '' : `-${anchor.end}`}`;
+
+const makeRange = (start, end) => ({
+  [Symbol.iterator]: () => {
+    const state = { next: start };
+    return {
+      next: () => state.next > end
+        ? { done: true }
+        : { done: false, value: state.next++ },
+    };
+  },
+});
+
+export const renderExcerpts = (anchors, texts, budget) => {
+  const rendered = [];
+  const state = { bytes: 0 };
+  const sources = new Map();
+  for (const anchor of anchors) {
+    if (!sources.has(anchor.path)) {
+      const text = Object.hasOwn(texts, anchor.path) ? texts[anchor.path] : '';
+      sources.set(anchor.path, String(text ?? '').split(LINE_JOINER));
+    }
+    const sourceLines = sources.get(anchor.path);
+    for (const number of makeRange(anchor.start, anchor.end)) {
+      const line = `${anchor.path}:${number}: ${sourceLines[number - 1] ?? ''}`;
+      state.bytes += Buffer.byteLength(line, 'utf8') + (rendered.length === 0 ? 0 : Buffer.byteLength(LINE_JOINER));
+      rendered.push(line);
+      if (state.bytes > budget) return rendered.join(LINE_JOINER);
+    }
+  }
+  return rendered.join(LINE_JOINER);
+};
+
+export const renderRows = (record, { date, recordPath }) => {
+  const ids = [];
+  for (const claim of record.claims) {
+    const id = QUEUE.exec(claim.disposition)?.[1];
+    if (id && !ids.includes(id)) ids.push(id);
+  }
+  return ids.map((id) => {
+    const claims = record.claims.filter((claim) => QUEUE.exec(claim.disposition)?.[1] === id);
+    return [
+      `- [ ] ${id}: ${claims[0].claim} (${date})`,
+      ...claims.map((claim) => `  - ${claim.claim}; verdict ${claim.verdict}; evidence ${claim.anchors.map(rendersAnchor).join(', ')}`),
+      `  - record: ${recordPath}`,
+      `  - head: ${record.head}`,
+    ].join('\n');
+  });
+};
+
+export const ratchetLine = (gateCmd, newRows) => {
+  const match = /(?:^|\s)--max-rows\s+([0-9]+)(?=\s|$)/u.exec(String(gateCmd));
+  if (!match) return 'ratchet: queue-audit --max-rows is absent from the gate command';
+  const current = Number(match[1]);
+  return `ratchet: queue-audit --max-rows ${current} \u2192 ${current + newRows.length}`;
+};

package/tools/inject-methodology.mjs

@@ -88,6 +88,8 @@ export const KNOWN_PRIOR_METHODOLOGY_SLOT = [
   '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. Full vocabulary, lifecycle, and the plan-then-execute split live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe. **Communication:** user-facing messages deliver the artifact inline (paste the prompt / diff / command — never "see §X" as a substitute), lead with the result, show exactly what was asked, and never read as mockery (a large artifact: a real summary inline + a link).',
   // engine 4.2.0 — the two-activity pointer, before `routine` joined the named activities.
   '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. The plan shape, its caps and lifecycle live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe. **Communication:** user-facing messages deliver the artifact inline (paste the prompt / diff / command — never "see §X" as a substitute), lead with the result, show exactly what was asked, and never read as mockery (a large artifact: a real summary inline + a link).',
+  // engine 4.6.0 — the three-activity pointer, before feedback-triage joined the named activities.
+  '> **Workflow methodology** — plan → execute → review. Plans are ephemeral `docs/plans/*.md` (gitignored, **never committed**); every Plan ends with a mandatory **Phase: Cleanup**; series order lives in `docs/plans/queue.md`. The plan shape, its caps and lifecycle live in the project\'s **planning skill** (it overrides the generic `writing-plans`); summary in `docs/ai/agent_rules.md` §5. Named activities (plan-authoring, plan-execution, routine) have procedures — see `/agent-workflow-kit procedures <activity>` for the steps + resolved recipe. **Communication:** user-facing messages deliver the artifact inline (paste the prompt / diff / command — never "see §X" as a substitute), lead with the result, show exactly what was asked, and never read as mockery (a large artifact: a real summary inline + a link).',
 ];
 export const KNOWN_PRIOR_ORCH_SLOT = [
   // v1.3.0 — pre-read-at-start orchestration pointer (recipes vocabulary, no orchestration.json clause).

package/tools/orchestration-readme.mjs

@@ -50,12 +50,22 @@ const ROSTER_README = V3_README.replace(
   "a 'review' slot accepts solo | reviewed | council (you self-review / one backend reviews / both review and you synthesize), or an explicit roster array such as [\"codex-review\", \"agy-review\", \"review-lens\"] in hand-edit form",
 );
 
-export const CANON_README = ROSTER_README
+const FOLD_README = ROSTER_README
   .replace("'plan-authoring' (slots author, review)", "'plan-authoring' (slots author, fold, review)")
   .replace("the carrier slots 'plan-authoring.author' and 'routine.carrier'", "the carrier slots 'plan-authoring.author', 'plan-authoring.fold' and 'routine.carrier'")
   .replace('solo for author, execute and carrier', 'solo for author, fold, execute and carrier');
 
-export const KNOWN_PRIOR_README = Object.freeze([V1_README, V2_README, V3_README, ROSTER_README]);
+const FOUR_README = FOLD_README.replace(
+  "Three activities are configured independently, and so is each slot within them: 'plan-authoring' (slots author, fold, review), 'plan-execution' (slots execute, review) and 'routine' (slots carrier, parallel).",
+  "Four activities are configured independently, and so is each slot within them: 'plan-authoring' (slots author, fold, review), 'plan-execution' (slots execute, review), 'routine' (slots carrier, parallel) and 'feedback-triage' (slot review).",
+);
+
+export const CANON_README = FOUR_README.replace(
+  "The default below is 'solo' for every recipe and carrier slot, and 'on' for the parallel switch — no execution backend required.",
+  "Every slot seeded below is 'solo' — no execution backend required. A slot the seed leaves silent takes the computed default stated further down: 'feedback-triage.review' is reviewed as soon as a review backend is ready (solo until then); 'plan-authoring.author', 'plan-authoring.fold' and 'routine.carrier' stay 'solo', and 'routine.parallel' stays 'on'.",
+);
+
+export const KNOWN_PRIOR_README = Object.freeze([V1_README, V2_README, V3_README, ROSTER_README, FOLD_README, FOUR_README]);
 
 export const refreshReadme = (config) => {
   if (config == null || typeof config !== 'object' || Array.isArray(config)) return { config, changed: false };

package/tools/procedures.mjs

@@ -22,6 +22,8 @@ import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { detectBackends, wrapperCmdFor, wrapperContractFor } from './detect-backends.mjs';
+import { surveyVehicle as surveyReviewVehicle } from './cheap-agents-read.mjs';
+import { isReadyMember, skippedLine } from './review-roster-resolve.mjs';
 // The host-level bridge-settings registry (manifest-as-source) + its allowed-value labels. READ-ONLY
 // core only — never the writer — so this read-only advisor never imports the atomic-write core.
 import { loadRegistry, allowedLabel } from './bridge-settings-read.mjs';
@@ -150,7 +152,7 @@ export const extractSection = (text, activity) => {
 
 // ── resolution + rendering ─────────────────────────────────────────────────────────
 
-const resolveAllSlots = ({ activity, config, detection, overrides }) => {
+const resolveAllSlots = ({ activity, config, detection, overrides, surveyLens }) => {
   // The host-level settings knobs (manifest-as-source), best-effort: a corrupt bundle degrades to none
   // and the advisor never crashes. Attached per wrapper cmd via each knob's `appliesTo`. Fact-only —
   // model/effort are not knobs, so no model claim can ride here.
@@ -163,7 +165,7 @@ const resolveAllSlots = ({ activity, config, detection, overrides }) => {
   })();
   const knobsFor = (cmd) => [...registry.values()].filter((k) => (k.appliesTo ?? []).includes(cmd));
   return Object.entries(ACTIVITIES[activity].slots).map(([slot, slotType]) => {
-    const resolved = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity, slot, override: overrides[slot] });
+    const resolved = resolveActivityRecipe({ config: config ?? {}, readiness: detection, activity, slot, override: overrides[slot], surveyLens });
     if (isSwitchSlot(slotType)) return { slot, slotType, ...resolved, backends: [], contracts: [], vehicles: [] };
     // The concrete wrapper set this slot's EFFECTIVE recipe dispatches (empty for solo). Reuse
     // planRecipe's drift-guarded dispatch for WHICH backends, then resolve each (backend, role) to its
@@ -177,7 +179,7 @@ const resolveAllSlots = ({ activity, config, detection, overrides }) => {
     // pairs, BEFORE they are flattened to wrapper names (the name array cannot reconstruct the role).
     // Every slot with a non-empty dispatch gets contracts — including execute=delegated; the contract
     // is NEVER gated by REVIEW_RECIPES (that set gates only the review-loop economics block).
-    const contracts = bridged
+    const contracts = activity === 'feedback-triage' ? [] : bridged
       .map((d) => ({ backend: d.backend, role: d.role, cmd: wrapperCmdFor(d.backend, d.role), contract: wrapperContractFor(d.backend, d.role) }))
       .filter((c) => c.cmd && c.contract)
       // `retired` rides along: without it this surface advertised a RETIRED key as an ordinary
@@ -271,8 +273,40 @@ const reviewLoopAdvice = (slots, activity, flowArmed = false, plans = []) =>
 export const GROUNDING_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'grounding.mjs');
 export const REVIEW_ROUNDS_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'review-rounds-cli.mjs');
 export const REPO_SEARCH_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'repo-search.mjs');
+export const FEEDBACK_RECORD_TOOL = join(dirname(fileURLToPath(import.meta.url)), 'feedback-record-cli.mjs');
+const FEEDBACK_TRIAGE = 'feedback-triage';
 const GROUNDING_FACTS_OUT = '/tmp/review-facts.md';
 const MINTS_RECEIPT = Object.freeze({ mintsReceipt: true });
+const FEEDBACK_BRIDGE_LINES = Object.freeze({
+  'codex-review': 'codex-review plan <record>',
+  'agy-review': 'agy-review plan <record> --facts @<facts>',
+});
+const FEEDBACK_LENS_LINE = 'the Agent tool, read-only, in the background — the brief carries <record> plus <facts>';
+const mintsReceipts = (review) => review.roster == null
+  ? (review.backends ?? []).length > 0 || REVIEW_RECIPES.has(review.degradedFrom)
+  : review.roster.some((row) => row.kind === 'bridge');
+
+const renderFeedbackTriageAdvice = (activity, slots) => {
+  if (activity !== FEEDBACK_TRIAGE) return [];
+  const review = slots.find((slot) => slot.slot === 'review');
+  const members = review.roster == null
+    ? review.backends.map((name) => `  then: ${FEEDBACK_BRIDGE_LINES[name]}`)
+    : review.roster.map((row) => !isReadyMember(row)
+      ? `  then: ${row.member} — ${skippedLine(row)}`
+      : row.kind === 'bridge'
+        ? `  then: ${FEEDBACK_BRIDGE_LINES[row.member]}`
+        : `  then: ${row.member} — ${FEEDBACK_LENS_LINE}`);
+  return [
+    `  run:  node ${renderToolPath(FEEDBACK_RECORD_TOOL)} --check <record> --excerpts <facts>`,
+    ...members,
+    ...(mintsReceipts(review)
+      ? [
+          `  then: node ${renderToolPath(REVIEW_ROUNDS_TOOL)} --artifact <record> --activity feedback-triage`,
+          ROUND_RENDER_FACT_LINE,
+        ]
+      : [ROUND_RENDER_NO_BRIDGE_LINE]),
+  ];
+};
 
 // The round table judges what review-rounds-cli resolves from the config (S27), never this render's
 // override or degradation, so the advisor states that fact beneath the command instead of predicting
@@ -285,10 +319,7 @@ const roundRenderAdvice = (slots, plans) => {
   const review = slots.find((s) => s.slot === 'review');
   if (review === undefined) return [];
   const roster = review.roster ?? null;
-  const shouldRenderCommand = roster === null
-    ? (review.backends ?? []).length > 0 || REVIEW_RECIPES.has(review.degradedFrom)
-    : roster.some((row) => row.kind === 'bridge');
-  if (!shouldRenderCommand) return [ROUND_RENDER_NO_BRIDGE_LINE];
+  if (!mintsReceipts(review)) return [ROUND_RENDER_NO_BRIDGE_LINE];
   const lensMembers = (roster ?? []).filter((row) => row.kind === 'lens').map((row) => row.member);
   const operand = populatedPlan(plans, MINTS_RECEIPT);
   return [
@@ -345,6 +376,7 @@ const slotSkewWarning = (section, activity) => {
   return [`the installed engine's canon lists slots (${listed.join(', ')}) for ${activity} while this kit's registry names (${registry.join(', ')}) — the resolved lines follow the registry; the engine and this kit are out of step — /agent-workflow-kit status names which member is behind: upgrade that one. Tell the user.`];
 };
 const groundingPreStepAdvice = (activity, slots, plans) => {
+  if (activity === FEEDBACK_TRIAGE) return [];
   if (!slots.some((s) => (s.backends ?? []).includes('agy-review'))) return [];
   const operand = populatedPlan(plans);
   const planArg = operand === null ? '--plan <path>' : `--plan ${operand}`;
@@ -621,6 +653,7 @@ const formatHuman = ({ activity, section, slots, warnings, plans, autonomy, flow
       ? `  ${parallelLine({ value: s.recipe, carrier })} — ${SOURCE_LABEL[s.source]}`
       : `  ${s.slot}: ${s.recipe} — ${SOURCE_LABEL[s.source]}${arrow}${backendSetLabel(s.backends)}`);
     if (s.reason) lines.push(`      ↳ ${s.reason}`);
+    if (s.slot === 'review') lines.push(...renderFeedbackTriageAdvice(activity, slots));
     // The form replaces the one-line vehicle mention: a carrier never told how to carry is a name,
     // not an instruction. Indented like the driving contracts beside it.
     for (const v of s.vehicles ?? []) {
@@ -664,6 +697,7 @@ const buildJson = ({ activity, section, slots, configSource, warnings, plans, au
   readersSweep,
   // ADDITIVE (AD-038): the populated grounding pre-step, structured (empty when agy is not dispatched).
   groundingPreStep: groundingPreStepAdvice(activity, slots, plans),
+  feedbackTriage: renderFeedbackTriageAdvice(activity, slots),
   // ADDITIVE (cost-tiered execution): the unconditional cost-lane advisory, structured.
   costLanes: costLanesAdvice(),
   // ADDITIVE (the fold channel): the finding-scope block, structured (empty outside plan-execution).
@@ -737,7 +771,8 @@ export const main = (argv, ctx = {}) => {
         `backend detection failed (${(err && err.message) || err}) — treating every bridge as not ready; recipes needing a bridge degrade to solo (the executor vehicle is unaffected).`,
       ),
     });
-    const slots = resolveAllSlots({ activity, config, detection, overrides });
+    const surveyLens = ctx.surveyLens ?? ((spec) => surveyReviewVehicle(cwd, spec, ctx));
+    const slots = resolveAllSlots({ activity, config, detection, overrides, surveyLens });
     const warnings = [...detectWarnings, ...collectWarnings(slots), ...slotSkewWarning(section, activity)];
     const plans = plansInFlight(cwd);
     // The autonomy facts (AD-044 Plan 4): resolved levels + red-lines from the policy file. A