mandrel 2.1.0 → 2.2.0

package/.agents/agents/acceptance-critic.md

@@ -34,7 +34,15 @@ verdicts, their commit-message justifications-as-proof, or any prior verdict
 file they authored. You grade the **work product**, not the homework the maker
 turned in about it. Your only trusted inputs are:
 
-- the working **diff** (`git diff origin/<baseBranch>...HEAD`),
+- the **change set** your caller hands you: the list of files this Story
+  touched, computed **once** per delivery by the shared `computeChangeSet`
+  enumerator (`.agents/scripts/lib/orchestration/change-set.js`) and threaded
+  into your spawn context. Read those files and inspect their changes to see
+  the work product. Do **not** re-derive the set yourself — re-enumerating it
+  can pick up commits that landed after your caller routed the ceremony, and
+  then you would be scoring a different change than the one you were dispatched
+  for (Story #4593). If no change set reached you, say so in your verdict
+  rather than substituting your own enumeration.
 - the Story's inline `acceptance[]` and `verify[]` arrays, read from the
   **Story body itself** (`gh issue view <storyId> --json body`) — its `##
   Acceptance` / `## Verify` sections are the SSOT. The `story-init` structured
@@ -58,7 +66,8 @@ given.
 
 For each acceptance item in your cluster:
 
-1. **Inspect the diff** for the change that would satisfy the criterion.
+1. **Inspect the change set** — read the files your caller named and look for
+   the change that would satisfy the criterion.
 2. **Run the relevant `verify[]` commands** and consume their output as
    **required evidence**. A criterion cannot be scored `met` without the
    supporting `verify[]` evidence where a `verify[]` command is relevant to it.

package/.agents/agents/story-worker.md

@@ -101,8 +101,10 @@ self-eval loop (below) may share `lint` / `typecheck` evidence with close via
 After the implementation commits land and **before** flipping to `closing`, run
 the bounded acceptance self-eval loop (see
 [`acceptance-self-eval.md`](../workflows/helpers/acceptance-self-eval.md)). It
-scores the working diff against **each** `acceptance[]` item and consumes the
-`verify[]` command output as **required evidence**. The gate returns one of:
+scores the change set you computed once and injected into the critic — never
+one the critic re-derives (Story #4593) — against **each** `acceptance[]` item,
+and consumes the `verify[]` command output as **required evidence**. The gate
+returns one of:
 
 - **`proceed`** (every criterion met) → flip to `closing` and close.
 - **`redraft`** (rounds remaining) → fix the flagged criteria, commit, re-eval.

package/.agents/docs/SDLC.md

@@ -40,8 +40,9 @@ From zero to shipped:
 
    `/plan` is a **single path** — there is no Epic/Story router, no
    scope-triage `epic|story` verdict, and no `deliveryShape`. All GitHub
-   reads happen in `plan-context.js`, all writes in `plan-persist.js`, and
-   two HITL gates bracket the authoring middle. Duplicate search targets
+   reads happen in `plan-context.js`, the issue-creating writes in
+   `plan-persist.js`, and two HITL gates bracket the authoring middle.
+   Duplicate search targets
    open **Stories** (`type::story`), never Epics.
 
    1. **Interrogate** — `plan-context.js` emits the single authoring
@@ -54,6 +55,12 @@ From zero to shipped:
       Binding criteria live in top-level `acceptance[]` / `verify[]`;
       changes/references are `{ path, assumption }` objects. Split into
       N>1 only under the default-single split policy.
+   2.5. **Critics** — `plan-critics.js` evaluates the consolidation +
+      pre-mortem dispatch conditions against the authored draft and ledgers
+      every skip. This is the **only** critic gate (#4592 moved it out of
+      `plan-persist.js` into workflow prose), so skipping it silently skips
+      both critics: run it before Persist, per
+      [`/plan`](../workflows/plan.md) step 2.5.
    3. **Persist** — **gate #2** (raised only by an explicit `--force-review`)
       then `plan-persist.js` runs every deterministic gate and
       creates Story issue(s) with `type::story` + `agent::ready`, writing
@@ -76,8 +83,8 @@ From zero to shipped:
    2. **Implement** — the agent delivers the Story in one guarded session
       against its inline `acceptance[]` / `verify[]` contract (optional
       `## Slicing` intra-session checkpoints).
-   3. **Acceptance self-eval** — a bounded critic loop scores the working
-      diff against each acceptance item before close (see
+   3. **Acceptance self-eval** — a bounded critic loop scores the
+      caller-injected change set against each acceptance item before close (see
       [`helpers/acceptance-self-eval`](../workflows/helpers/acceptance-self-eval.md)).
    4. **Ceremony** — acceptance critic mode and review depth, both routed off
       the change level derived from the Story's own diff

package/.agents/docs/configuration.md

@@ -263,7 +263,7 @@ top-level keys are validation errors.
 | `codeReview.autoFixSeverity` | No | `"high"` \| `"medium"` | `"medium"` | Severity threshold for on-branch remediation in /deliver Phase 5 (code-review). `medium` (default) routes 🔴/🟠/🟡 findings into the host-LLM focused-fix routing (Mediums batched per lens: one commit per lens, a single validation + rescan at the end) while 🟢 suggestions still graduate to follow-up issues; `high` reproduces the pre-4399 Critical/High-only routing. Hard cutover — no back-compat flag. |
 | `refactorStage` | No | `object` | — | Opt-in, config-gated post-green refactor checkpoint wired into story-deliver (Story #3430, Epic #3418). Strictly additive and default-OFF: when disabled, story-deliver behaves exactly as before. Advisory only — never changes existing close-validation gate semantics. |
 | `refactorStage.enabled` | No | `boolean` | `false` | When true, story-deliver runs an advisory post-green refactor stage (core/code-review-and-quality skill, Post-Green Refactor Pass) after the suite is green. Default false — when unset the stage is skipped and close-validation gate semantics are unchanged. |
-| `acceptanceEval` | No | `object` | — | Story #3819. Bounded per-Story acceptance self-eval loop. After the implementation commits land and before the Story-implementation phase flips to `closing`, an independent (fresh-context) critic pass scores the working diff against each inline `acceptance[]` item, redrafts the unmet items, and re-evaluates — capped at `maxRounds` redraft rounds, then escalates to `agent::blocked` when criteria remain unmet. There is no `enabled` flag: the loop is a hard cutover (always on). |
+| `acceptanceEval` | No | `object` | — | Story #3819. Bounded per-Story acceptance self-eval loop. After the implementation commits land and before the Story-implementation phase flips to `closing`, an independent (fresh-context) critic pass scores the caller-injected change set against each inline `acceptance[]` item, redrafts the unmet items, and re-evaluates — capped at `maxRounds` redraft rounds, then escalates to `agent::blocked` when criteria remain unmet. There is no `enabled` flag: the loop is a hard cutover (always on). |
 | `acceptanceEval.maxRounds` | No | `integer` | — | Maximum number of redraft rounds before escalation. Default 2; clamped into [1, hard ceiling] by lib/config/acceptance-eval.js so the cap can never be disabled (maxRounds: 0 clamps up to 1). |
 | `acceptanceEval.clusterCeiling` | No | `integer` | — | Epic #4475 (M4-B). Max acceptance criteria one single-delivery acceptance critic scores in a single fresh-context pass. Single delivery clusters the Epic ## Acceptance Table ACs into ceil(totalACs / clusterCeiling) groups and spawns one maker-blind critic per cluster, restoring the distributed acceptance coverage the per-Story critic fan-out gave for free. Default 4; clamped into [1, 8] by lib/config/acceptance-eval.js so a large value cannot collapse the fan-out to a single diluted critic. Ignored on the fan-out route. |
 | `ci` | No | `object` | — | Nested configuration block. |

package/.agents/docs/quality-gates.md

@@ -260,9 +260,9 @@ per-round mechanic lives in
 with the gate CLI at
 [`.agents/scripts/acceptance-eval.js`](../scripts/acceptance-eval.js)).
 Each round, a fresh-context **critic pass** — independent of the
-implementing agent — scores the working diff against every inline
-`acceptance[]` item, using `verify[]` output as evidence, and yields one
-of three decisions:
+implementing agent — scores the change set its caller injected (never one
+it re-derives) against every inline `acceptance[]` item, using `verify[]`
+output as evidence, and yields one of three decisions:
 
 - **proceed** — all criteria met; the Story continues to close.
 - **redraft** — unmet criteria are redrafted and re-implemented, then

package/.agents/rules/gherkin-standards.md

@@ -23,6 +23,16 @@ scenarios. Use the canonical set below; do not invent ad-hoc tags.
 - `@flaky` — operational quarantine tag. Scenarios carrying this tag are
   excluded from the gating suite and run in a dedicated non-blocking job
   until stabilized. Treat `@flaky` as a debt marker, not a permanent label.
+- `@skip` — scaffold-gating tag. Applied to scenarios scaffolded ahead of
+  their implementation (e.g. by a wave-0 BDD scaffold Story); the scenario
+  is excluded from the gating suite until the implementing Story removes
+  the tag (the "de-skip" edit). Unlike `@flaky`, `@skip` marks planned
+  not-yet-implemented behavior, never a stability problem.
+
+Retired: the `@epic-<id>-ac-N` namespaced AC tag. Its consumer
+(`acceptance-spec-reconciler.js`) was deleted in the v2 Epic removal, so
+the tag is inert — do not apply it to new scenarios. The `mandrel update`
+migration strips surviving instances from consumer feature files.
 
 Rules:
 

package/.agents/schemas/acceptance-eval-verdict.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "acceptance-eval-verdict",
   "title": "Acceptance Self-Eval Verdict",
-  "description": "Structured output of one independent (fresh-context) acceptance self-eval round (Story #3819). Produced by the critic pass in the Story-implementation phase (helpers/deliver-story.md Step 1a), written under the gitignored temp tree, and consumed by acceptance-eval.js to enforce the bounded round cap and decide whether the Story proceeds to `closing`, redrafts, or escalates to `agent::blocked`. The author MUST NOT be the evaluator — the verdict is an independent judgment of the working diff against each inline acceptance[] item.",
+  "description": "Structured output of one independent (fresh-context) acceptance self-eval round (Story #3819). Produced by the critic pass in the Story-implementation phase (helpers/deliver-story.md Step 1a), written under the gitignored temp tree, and consumed by acceptance-eval.js to enforce the bounded round cap and decide whether the Story proceeds to `closing`, redrafts, or escalates to `agent::blocked`. The author MUST NOT be the evaluator — the verdict is an independent judgment of the caller-injected change set against each inline acceptance[] item.",
   "type": "object",
   "required": ["storyId", "schemaVersion", "round", "criteria"],
   "properties": {
@@ -52,7 +52,7 @@
           "verdict": {
             "type": "string",
             "enum": ["met", "partial", "unmet"],
-            "description": "Per-criterion judgment of the working diff. `met` clears the criterion; `partial` and `unmet` both trigger a redraft round (subject to the cap)."
+            "description": "Per-criterion judgment of the caller-injected change set. `met` clears the criterion; `partial` and `unmet` both trigger a redraft round (subject to the cap)."
           },
           "evidence": {
             "type": "string",

package/.agents/schemas/agentrc.schema.json

@@ -1246,7 +1246,7 @@
     },
     "acceptanceEval": {
       "type": "object",
-      "description": "Story #3819. Bounded per-Story acceptance self-eval loop. After the implementation commits land and before the Story-implementation phase flips to `closing`, an independent (fresh-context) critic pass scores the working diff against each inline `acceptance[]` item, redrafts the unmet items, and re-evaluates — capped at `maxRounds` redraft rounds, then escalates to `agent::blocked` when criteria remain unmet. There is no `enabled` flag: the loop is a hard cutover (always on).",
+      "description": "Story #3819. Bounded per-Story acceptance self-eval loop. After the implementation commits land and before the Story-implementation phase flips to `closing`, an independent (fresh-context) critic pass scores the caller-injected change set against each inline `acceptance[]` item, redrafts the unmet items, and re-evaluates — capped at `maxRounds` redraft rounds, then escalates to `agent::blocked` when criteria remain unmet. There is no `enabled` flag: the loop is a hard cutover (always on).",
       "properties": {
         "maxRounds": {
           "type": "integer",

package/.agents/scripts/acceptance-eval.js

@@ -4,8 +4,8 @@
  * acceptance-eval.js — bounded per-Story acceptance self-eval gate (Story #3819).
  *
  * The Story-implementation phase runs an independent (fresh-context)
- * critic pass that scores the working diff against each inline
- * `acceptance[]` item, emitting one verdict file per round
+ * critic pass that scores the caller-injected change set against each
+ * inline `acceptance[]` item, emitting one verdict file per round
  * (`.agents/schemas/acceptance-eval-verdict.schema.json`). This CLI is the
  * deterministic substrate that turns that verdict into the loop's next
  * action:

package/.agents/scripts/lib/config/acceptance-eval.js

@@ -3,8 +3,8 @@
  *
  * Resolves `.agentrc.json → delivery.acceptanceEval` into the canonical
  * shape the per-Story acceptance self-eval loop consumes. The loop scores
- * the working diff against each inline `acceptance[]` item, redrafts the
- * unmet items, and re-evaluates — capped at `maxRounds` redraft rounds,
+ * the caller-injected change set against each inline `acceptance[]` item,
+ * redrafts the unmet items, and re-evaluates — capped at `maxRounds` rounds,
  * then escalates to `agent::blocked` when criteria remain unmet.
  *
  * ## The undisableable cap

package/.agents/scripts/lib/config-settings-schema-delivery.js

@@ -249,9 +249,9 @@ const REFACTOR_STAGE_SCHEMA = {
  * `delivery.acceptanceEval` — bounded per-Story acceptance self-eval loop
  * (Story #3819). After the implementation commits land and before the
  * Story-implementation phase flips to `closing`, an independent
- * (fresh-context) critic pass scores the working diff against each inline
- * `acceptance[]` item, redrafts the unmet items, and re-evaluates — capped
- * at `maxRounds` redraft rounds.
+ * (fresh-context) critic pass scores the caller-injected change set against
+ * each inline `acceptance[]` item, redrafts the unmet items, and
+ * re-evaluates — capped at `maxRounds` redraft rounds.
  *
  * `maxRounds` is the operator-tunable redraft ceiling (default 2 via
  * `lib/config/acceptance-eval.js`). It is a soft knob inside an

package/.agents/scripts/lib/orchestration/change-set.js

@@ -0,0 +1,103 @@
+/**
+ * lib/orchestration/change-set.js — the **one** Story change-set enumerator
+ * (Story #4593).
+ *
+ * ## Why this exists
+ *
+ * A single Story delivery used to enumerate `git diff --name-only
+ * <base>...<head>` three to four separate times: once for the ceremony
+ * derivation in `helpers/deliver-story`, once inside `runCodeReview` (to derive
+ * the review depth), once for the Story-scope local-lens roster, and once more
+ * per fresh acceptance critic. Every one of those consumers must agree about
+ * *what changed* — ceremony level and review depth both flow from
+ * `deriveChangeLevel`, so two enumerations straddling a commit could route the
+ * same Story two different ways. Computing the set once and injecting it closes
+ * that window and drops the redundant git calls.
+ *
+ * ## Contract
+ *
+ * {@link computeChangeSet} is **total**: it never throws. A diff it cannot
+ * enumerate (git failure, missing ref, spawn error) yields
+ * `{ files: null, enumerated: false }` — the neutral "diff unknown" signal that
+ * `deriveChangeLevel` / `resolveDepth` already fail safe on (`standard` depth, a
+ * `fresh` critic). `null` is deliberately distinct from `[]`: an empty array is
+ * the *fact* that nothing changed, whereas `null` is the *absence* of evidence,
+ * and only the latter must never buy a change less checking.
+ *
+ * The returned `files` are trimmed, de-duplicated, and sorted, so two consumers
+ * comparing the same change set compare byte-identical lists. The refs the set
+ * was computed against ride along on the envelope so a downstream consumer can
+ * report (or assert) its provenance rather than re-deriving it.
+ *
+ * @typedef {{
+ *   baseRef: string,
+ *   headRef: string,
+ *   files: string[]|null,
+ *   enumerated: boolean,
+ * }} ChangeSet
+ *
+ * @typedef {typeof gitSpawn} GitSpawnFn
+ */
+
+import { gitSpawn } from '../git-utils.js';
+
+/**
+ * Trim, drop empties, de-duplicate, and sort raw `git diff --name-only` output.
+ * Pure.
+ *
+ * @param {string} stdout
+ * @returns {string[]}
+ */
+function normalizeFileList(stdout) {
+  const seen = new Set();
+  for (const line of stdout.split('\n')) {
+    const file = line.trim();
+    if (file.length > 0) seen.add(file);
+  }
+  return [...seen].sort();
+}
+
+/**
+ * Compute the change set for the `baseRef...headRef` diff **once**, for every
+ * consumer that needs to know what a Story touched.
+ *
+ * Total — never throws; see the module header for the `null` vs `[]` contract.
+ *
+ * @param {{
+ *   baseRef: string,
+ *   headRef: string,
+ *   cwd?: string,
+ *   gitSpawnFn?: typeof gitSpawn,
+ * }} args
+ * @returns {ChangeSet}
+ */
+export function computeChangeSet({
+  baseRef,
+  headRef,
+  cwd = process.cwd(),
+  gitSpawnFn = gitSpawn,
+} = {}) {
+  const unknown = { baseRef, headRef, files: null, enumerated: false };
+  if (typeof baseRef !== 'string' || baseRef.length === 0) return unknown;
+  if (typeof headRef !== 'string' || headRef.length === 0) return unknown;
+
+  try {
+    const result = gitSpawnFn(
+      cwd,
+      'diff',
+      '--name-only',
+      `${baseRef}...${headRef}`,
+    );
+    if (!result || result.status !== 0 || typeof result.stdout !== 'string') {
+      return unknown;
+    }
+    return {
+      baseRef,
+      headRef,
+      files: normalizeFileList(result.stdout),
+      enumerated: true,
+    };
+  } catch {
+    return unknown;
+  }
+}

package/.agents/scripts/lib/orchestration/code-review.js

@@ -41,7 +41,7 @@
 
 import { hasSurvivingCritical } from '../audit-suite/findings.js';
 import { resolveConfig } from '../config-resolver.js';
-import { gitSpawn } from '../git-utils.js';
+import { computeChangeSet } from './change-set.js';
 import { deriveChangeLevel, resolveDepth } from './review-depth.js';
 import {
   countBySeverity,
@@ -65,36 +65,6 @@ import { upsertStructuredComment } from './ticketing.js';
  * @typedef {import('./review-depth.js').ReviewDepth} ReviewDepth
  */
 
-/**
- * Enumerate the files changed in the `baseRef...headRef` diff via
- * `git diff --name-only`. Returns the file list, or `null` when the diff
- * cannot be enumerated (git failure, missing ref). A `null` list is the neutral
- * "diff unknown" signal both {@link deriveChangeLevel} and {@link resolveDepth}
- * tolerate by failing safe to `standard`. Best-effort — never throws.
- *
- * @param {{ baseRef: string, headRef: string, gitSpawnFn?: typeof gitSpawn }} args
- * @returns {string[]|null}
- */
-function listChangedFiles({ baseRef, headRef, gitSpawnFn = gitSpawn }) {
-  try {
-    const result = gitSpawnFn(
-      process.cwd(),
-      'diff',
-      `${baseRef}...${headRef}`,
-      '--name-only',
-    );
-    if (!result || result.status !== 0 || typeof result.stdout !== 'string') {
-      return null;
-    }
-    return result.stdout
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0);
-  } catch {
-    return null;
-  }
-}
-
 /**
  * Resolve the project base branch fallback used when a caller omits
  * `baseRef`.
@@ -192,7 +162,7 @@ function resolveScopeEnvelope(opts, config) {
  *   changedFileCount?: number|null,
  *   storyId?: number|null,
  *   reviewProvider?: { runReview: Function },
- *   gitSpawnFn?: typeof gitSpawn,
+ *   gitSpawnFn?: import('./change-set.js').GitSpawnFn,
  *   resolveConfigFn?: typeof resolveConfig,
  *   createReviewProviderFn?: typeof createReviewProvider,
  *   upsertCommentFn?: typeof upsertStructuredComment,
@@ -229,6 +199,27 @@ function resolveProviderName(codeReviewConfig) {
   return 'native';
 }
 
+/**
+ * Resolve the change set the depth derivation reads (Story #4593).
+ *
+ * `opts.changedFiles` is an injection with three distinct states,
+ * and the difference is load-bearing: an **array** is the change set to use
+ * verbatim; an explicit **null** is a caller (`runStoryReviewCore`) reporting
+ * that it already tried and the diff is unenumerable — re-running git here would
+ * only fail again, so it degrades straight to the fail-safe tier; **absent**
+ * means no caller enumerated at all, so the shared {@link computeChangeSet}
+ * enumerator runs as the fallback (standalone CLI use). On the close path the
+ * spine always injects, so the diff is enumerated exactly once per delivery and
+ * this pillar can never disagree with the lens pass about what changed.
+ */
+function resolveInjectedChangedFiles({ opts, baseRef, headRef }) {
+  if (opts.changedFiles === undefined) {
+    return computeChangeSet({ baseRef, headRef, gitSpawnFn: opts.gitSpawnFn })
+      .files;
+  }
+  return Array.isArray(opts.changedFiles) ? opts.changedFiles : null;
+}
+
 /**
  * Build the provider `runReview` input, resolving the review depth from the
  * diff under review: its changed files derive the change level (sensitive path
@@ -238,9 +229,7 @@ function resolveProviderName(codeReviewConfig) {
  * Story #4075 — extracted from `runCodeReview`.
  */
 function buildReviewInput({ opts, scope, ticketId, baseRef, headRef }) {
-  const changedFiles = Array.isArray(opts.changedFiles)
-    ? opts.changedFiles
-    : listChangedFiles({ baseRef, headRef, gitSpawnFn: opts.gitSpawnFn });
+  const changedFiles = resolveInjectedChangedFiles({ opts, baseRef, headRef });
   const changedFileCount =
     typeof opts.changedFileCount === 'number'
       ? opts.changedFileCount

package/.agents/scripts/lib/orchestration/plan-context.js

@@ -361,17 +361,12 @@ export function buildDeliveryShapeSignal({ body } = {}) {
  * authoritative from day one); the decompose prompt reuses the existing
  * Story #4162 carrier including the risk-heuristics suffix.
  *
- * @param {{ heuristics?: string[], maxTickets?: number, epicId?: number|null }} args
+ * @param {{ heuristics?: string[], maxTickets?: number }} args
  * @returns {{ spec: string, acceptance: string, decompose: string }}
  */
-export function buildSystemPrompts({
-  heuristics = [],
-  maxTickets,
-  epicId = null,
-} = {}) {
+export function buildSystemPrompts({ heuristics = [], maxTickets } = {}) {
   const decompose = buildDecomposerSystemPrompt(heuristics, {
     maxTickets,
-    epicId,
   });
   return {
     spec: renderTechSpecSystemPrompt(),
@@ -500,7 +495,6 @@ async function buildSeedFileModeEnvelope({
     systemPrompts: buildSystemPrompts({
       heuristics,
       maxTickets: limits.maxTickets,
-      epicId: null,
     }),
     planState: null,
     // N=1 default: author one Story; skip Epic-scale decompose ceremony.
@@ -654,7 +648,6 @@ async function buildTicketsModeEnvelope({
     systemPrompts: buildSystemPrompts({
       heuristics,
       maxTickets: limits.maxTickets,
-      epicId: null,
     }),
     planState: null,
     planProfile:

package/.agents/scripts/lib/orchestration/plan-critic-conditions.js

@@ -2,15 +2,15 @@
  * plan-critic-conditions.js — size/heuristic-conditional dispatch decisions for
  * the /plan author-step critics (Epic #4474 PR6, design §4).
  *
- * The collapsed plan flow keeps the consolidation (8.3) and pre-mortem
- * (8.5) critics as fresh-context sub-agent dispatches, but makes each
- * dispatch **conditional** instead of unconditional — the dominant plan
- * cost is turns × standing context, and an unconditional critic pays a
- * full sub-agent spawn even when it provably has nothing to find. This
- * module computes those decisions deterministically so the workflow never
- * judges its own dispatch conditions:
+ * The collapsed plan flow keeps the consolidation and pre-mortem critics as
+ * fresh-context sub-agent dispatches, but makes each dispatch
+ * **conditional** instead of unconditional — the dominant plan cost is
+ * turns × standing context, and an unconditional critic pays a full
+ * sub-agent spawn even when it provably has nothing to find. This module
+ * computes those decisions deterministically so the workflow never judges
+ * its own dispatch conditions:
  *
- *   - **Consolidation (8.3)**: dispatch only when the existing
+ *   - **Consolidation**: dispatch only when the existing
  *     `evaluateConsolidationPrecondition` gate says `dispatch: true` AND
  *     (the draft has more than `CONSOLIDATION_STORY_THRESHOLD` stories OR
  *     the precondition confirmed a divergence from the Delivery Slicing
@@ -18,7 +18,7 @@
  *     small draft is NOT a confirmed divergence — it skips, because a
  *     ≤-threshold draft is small enough for gate #2's single-view review
  *     to catch a distorted shape without a dedicated sub-agent.
- *   - **Pre-mortem (8.5)**: dispatch when the ticket count is at least half
+ *   - **Pre-mortem**: dispatch when the ticket count is at least half
  *     of `maxTickets`, OR any configured `planning.riskHeuristics` phrase
  *     matches the plan text (case-insensitive substring). Story #4542 removed
  *     its third condition — the authored risk verdict's overall level — along
@@ -28,18 +28,19 @@
  * Under-firing risk (design PR6 note): the persist validators are
  * unchanged hard gates and G2's cohort re-measures plan quality; every
  * skip decision this module produces is logged to the plan-metrics ledger
- * (`appendCriticSkip`) by the callers so under-firing is auditable.
+ * (`appendCriticSkip`) by the caller so under-firing is auditable.
  *
- * Pure, synchronous, no I/O — the folded pre-write phase inside
- * `plan-persist.js` owns reading the authored artifacts and the resolved
- * config.
+ * Pure, synchronous, no I/O. The single caller is `plan-critics-evaluate.js`,
+ * driven by the `plan-critics.js` CLI that `/plan` runs between Author and
+ * Persist (Story #4592); the CLI owns reading the authored artifacts and the
+ * resolved config.
  */
 
 import { evaluateConsolidationPrecondition } from './consolidation-precondition.js';
 
 /**
  * Draft-story count above which the consolidation critic fires even
- * without a confirmed slicing divergence (design §6 PR6: "> 5 stories").
+ * without a confirmed slicing divergence (#4474 PR6: "> 5 stories").
  */
 export const CONSOLIDATION_STORY_THRESHOLD = 5;
 
@@ -53,7 +54,7 @@ export const CONSOLIDATION_STORY_THRESHOLD = 5;
  */
 
 /**
- * Decide the 8.3 consolidation dispatch: precondition AND size/divergence.
+ * Decide the consolidation dispatch: precondition AND size/divergence.
  *
  * @param {object} input
  * @param {object[]} input.draftStories - The draft `tickets.json` array
@@ -106,7 +107,7 @@ export function evaluateConsolidationDispatch({ draftStories, specText }) {
 }
 
 /**
- * Decide the 8.5 pre-mortem dispatch: size ≥ ½ budget, or a risk-heuristic
+ * Decide the pre-mortem dispatch: size ≥ ½ budget, or a risk-heuristic
  * phrase match.
  *
  * @param {object} input

package/.agents/scripts/lib/orchestration/plan-critics-evaluate.js

@@ -1,20 +1,22 @@
 /**
  * plan-critics-evaluate.js — shared critic-dispatch evaluation for the
- * collapsed /plan flow (#4496 fix 6; extracted from the `plan-critics.js`
- * CLI so the persist surface folds the same evaluation in as a pre-write
- * phase).
+ * collapsed /plan flow (#4496 fix 6).
  *
- * Two consumers:
- *   - `plan-persist.js` (via `runPlanPersist`) — evaluates the dispatch
- *     conditions as a deterministic pre-write phase, prints the verdicts,
- *     and records every skip on the plan-metrics ledger, so the headless
- *     path never pays a standalone CLI turn for the same decision.
- *   - `plan-critics.js` — the standalone CLI survives one release as a
- *     thin shim over this module for the attended pre-gate evaluation
- *     (the verdict folds into gate #2's view before the persist runs).
+ * One consumer: the `plan-critics.js` CLI, which `/plan` runs between its
+ * Author and Persist steps. The CLI loads the draft artifacts, calls this
+ * module, prints the verdict as JSON, and records every skip on the
+ * plan-metrics ledger; the workflow dispatches a fresh-context critic
+ * sub-agent on a `dispatch: true` verdict and folds the findings into a
+ * re-author round before persist.
+ *
+ * Story #4592 moved that evaluation here from `run-plan-persist.js`, which
+ * ran it after authoring was finished and immediately before
+ * `createStoryIssues` — the one point where a `dispatch: true` verdict has
+ * no re-author loop to route to. Persist no longer evaluates critics; this
+ * module has exactly one evaluation point.
  *
  * Pure evaluation: no file I/O, no GitHub calls, no ledger writes — the
- * callers own artifact loading and skip recording.
+ * caller owns artifact loading and skip recording.
  *
  * @module lib/orchestration/plan-critics-evaluate
  */
@@ -24,6 +26,7 @@ import {
   evaluateConsolidationDispatch,
   evaluatePremortemDispatch,
 } from './plan-critic-conditions.js';
+import { evaluateTextHygiene } from './plan-text-hygiene.js';
 
 /**
  * Resolve the planning risk heuristics list from the canonical config
@@ -41,8 +44,7 @@ function resolveRiskHeuristics(config = {}) {
 
 /**
  * Evaluate the consolidation + pre-mortem critic dispatch conditions over
- * the authored planning artifacts (design §4 / #4474 PR6 conditions,
- * unchanged):
+ * the authored planning artifacts (#4474 PR6 conditions, unchanged):
  *
  *   - Consolidation: skipped outright when `tickets` is null/absent (the
  *     single-delivery shape authors no draft tickets); otherwise the
@@ -50,6 +52,11 @@ function resolveRiskHeuristics(config = {}) {
  *   - Pre-mortem: ticket count at least half `maxTickets`, OR any
  *     `planning.riskHeuristics` phrase matching the plan text. Story #4542
  *     retired its authored-risk-level condition with the verdict itself.
+ *   - Text hygiene (Story #4599, advisory-only): deterministic body lints
+ *     (dangling-citation / open-question / slicing-mass) over the draft
+ *     stories. It has no `dispatch` semantics and spawns nothing — its
+ *     `findings[]` are re-author-round input, and the consolidation /
+ *     premortem dispatch verdicts are untouched by it.
  *
  * @param {{
  *   techSpecContent: string,
@@ -59,6 +66,7 @@ function resolveRiskHeuristics(config = {}) {
  * @returns {{
  *   consolidation: { critic: string, dispatch: boolean, reasons: string[] },
  *   premortem: { critic: string, dispatch: boolean, reasons: string[] },
+ *   textHygiene: { critic: string, findings: Array<object> },
  * }}
  */
 export function evaluatePlanCritics({
@@ -91,5 +99,10 @@ export function evaluatePlanCritics({
     ].join('\n'),
   });
 
-  return { consolidation, premortem };
+  const textHygiene = {
+    critic: 'text-hygiene',
+    findings: evaluateTextHygiene({ draftStories: ticketList }).findings,
+  };
+
+  return { consolidation, premortem, textHygiene };
 }

package/.agents/scripts/lib/orchestration/plan-persist/run-plan-persist.js

@@ -44,7 +44,6 @@ import { anchorTempRoot, tempRootFrom } from '../../config/temp-paths.js';
 import { getLimits, PROJECT_ROOT } from '../../config-resolver.js';
 import { gitSpawn } from '../../git-utils.js';
 import { Logger } from '../../Logger.js';
-import { evaluatePlanCritics } from '../plan-critics-evaluate.js';
 import {
   appendCriticSkip,
   readPlanMetrics,
@@ -438,29 +437,6 @@ export async function runPlanPersist({
     );
   }
 
-  const critics = evaluatePlanCritics({
-    techSpecContent: techSpecContent ?? '',
-    tickets: rawStories,
-    config,
-  });
-  for (const decision of [critics.consolidation, critics.premortem]) {
-    Logger.info(
-      `[plan-persist] critic ${decision.critic}: ` +
-        `${decision.dispatch ? 'dispatch' : 'skip'} — ` +
-        decision.reasons.join('; '),
-    );
-    if (!decision.dispatch) {
-      await appendCriticSkip(
-        {
-          critic: decision.critic,
-          reasons: decision.reasons,
-          cli: 'plan-persist',
-        },
-        config,
-      );
-    }
-  }
-
   // Split policy + inline Spec fold (over-budget Specs fail closed — no docs/).
   const { stories } = assemblePlanStories(rawStories, {
     sharedSpec: techSpecContent,
@@ -580,7 +556,6 @@ export async function runPlanPersist({
     stories: created,
     primaryStoryId: primary.id,
     forceReview,
-    critics,
     reachability,
     freshness,
     waveTable,