mandrel 2.65.0 → 2.67.0

package/.agents/scripts/single-story-init.js

@@ -229,10 +229,60 @@ export function decideStoryBranchSeed({ localHas, remoteHas }) {
 }
 
 /**
- * Reap merged `story-*` branches (excluding the current one). Never blocks
- * init. Protected candidates (unpushed work, dirty worktree, open Story) are
- * skipped; the lockfile is shared with `boot-sweep.js` via
- * `resolveSweepLockPath` so concurrent reaps cannot race.
+ * Remove closed-Story `.worktrees/story-<id>` trees through the boot sweep's
+ * own seam (`runWorktreeSweep`: same lock, same invariants). The Story being
+ * initialized is always kept, whatever its ticket state. Never throws: a
+ * failure lands in the returned outcome, which rides the init envelope.
+ *
+ * @returns {Promise<object>} `{ ok, reaped, skipped, reason?, error? }`.
+ */
+export async function reapClosedStoryWorktrees({
+  cwd,
+  storyBranch,
+  provider,
+  lockPath,
+  lockTimeoutMs,
+  worktreeSweepFn,
+  acquireLockFn,
+}) {
+  const logger = {
+    info: (m) => progress('CLEANUP', m),
+    warn: (m) => progress('CLEANUP', `⚠️ ${m}`),
+  };
+  try {
+    const { runWorktreeSweep } = await import('./boot-sweep.js');
+    const outcome = await runWorktreeSweep({
+      root: cwd,
+      provider,
+      lockPath,
+      lockTimeoutMs,
+      ...(worktreeSweepFn ? { sweepFn: worktreeSweepFn } : {}),
+      ...(acquireLockFn ? { acquireLockFn } : {}),
+      logger,
+      logTag: '[worktree-sweep]',
+      keepPaths: [path.join(cwd, '.worktrees', storyBranch)],
+    });
+    if (outcome.reaped?.length > 0) {
+      progress(
+        'CLEANUP',
+        `🧹 removed ${outcome.reaped.length} closed-Story worktree(s).`,
+      );
+    }
+    return outcome;
+  } catch (err) {
+    const msg = err?.message ?? String(err);
+    logger.warn(`worktree sweep threw (init continues): ${msg}`);
+    return { ok: false, error: msg, reaped: [], skipped: [] };
+  }
+}
+
+/**
+ * Reap merged `story-*` branches (excluding the current one), then the
+ * closed-Story worktrees. Never blocks init. Protected candidates (unpushed
+ * work, dirty worktree, open Story) are skipped; the lockfile is shared with
+ * `boot-sweep.js` via `resolveSweepLockPath` so concurrent reaps cannot race.
+ *
+ * @returns {Promise<{ worktreeSweep: object }>}
  */
 export async function reapMergedStoryBranches({
   cwd,
@@ -241,6 +291,8 @@ export async function reapMergedStoryBranches({
   config,
   provider,
   injectedSweep,
+  worktreeSweepFn,
+  acquireLockFn,
 }) {
   const sweepFn =
     injectedSweep ??
@@ -248,7 +300,37 @@ export async function reapMergedStoryBranches({
   const tempRoot = config?.project?.paths?.tempRoot ?? 'temp';
   const lockPath = resolveSweepLockPath({ cwd, tempRoot });
   const lockTimeoutMs =
-    config.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
+    config?.delivery?.worktreeIsolation?.sweepLockMs ?? 60_000;
+  await reapMergedBranches({
+    cwd,
+    baseBranch,
+    storyBranch,
+    provider,
+    sweepFn,
+    lockPath,
+    lockTimeoutMs,
+  });
+  const worktreeSweep = await reapClosedStoryWorktrees({
+    cwd,
+    storyBranch,
+    provider,
+    lockPath,
+    lockTimeoutMs,
+    worktreeSweepFn,
+    acquireLockFn,
+  });
+  return { worktreeSweep };
+}
+
+async function reapMergedBranches({
+  cwd,
+  baseBranch,
+  storyBranch,
+  provider,
+  sweepFn,
+  lockPath,
+  lockTimeoutMs,
+}) {
   try {
     const sweep = await sweepFn({
       cwd,
@@ -300,9 +382,12 @@ export async function reapMergedStoryBranches({
  * @param {object} opts.config
  * @param {object} opts.provider
  * @param {Function|undefined} opts.injectedSweep
+ * @param {Function} [opts.worktreeSweepFn] Test override for the
+ *   closed-Story worktree sweep.
  * @param {Function} opts.progress
  * @param {import('./lib/git/cached-fetch.js').FetchCache} [opts.fetchCache]
  *   Test override; production shares the module singleton.
+ * @returns {Promise<{ worktreeSweep: object }>}
  */
 export async function materializeBaseBranch({
   cwd,
@@ -311,6 +396,7 @@ export async function materializeBaseBranch({
   config,
   provider,
   injectedSweep,
+  worktreeSweepFn,
   progress,
   fetchCache,
 }) {
@@ -326,13 +412,14 @@ export async function materializeBaseBranch({
     );
   }
 
-  await reapMergedStoryBranches({
+  const { worktreeSweep } = await reapMergedStoryBranches({
     cwd,
     baseBranch,
     storyBranch,
     config,
     provider,
     injectedSweep,
+    worktreeSweepFn,
   });
 
   if (!branchExistsLocally(baseBranch, cwd)) {
@@ -342,10 +429,19 @@ export async function materializeBaseBranch({
         `Failed to fetch base branch ${baseBranch}: ${r.stderr || '(no stderr)'}`,
       );
     }
-    return;
+    return { worktreeSweep };
   }
 
-  // `git fetch` leaves local base at the old tip until fast-forwarded.
+  fastForwardBase({ cwd, baseBranch, progress });
+  return { worktreeSweep };
+}
+
+/**
+ * `git fetch` leaves local base at the old tip until fast-forwarded.
+ *
+ * @param {{ cwd: string, baseBranch: string, progress: Function }} opts
+ */
+function fastForwardBase({ cwd, baseBranch, progress }) {
   const ffPlan = planFastForward({ cwd, baseBranch });
   const ff = executeFastForward({
     cwd,
@@ -461,6 +557,7 @@ export async function runSingleStoryInit({
   injectedProvider,
   injectedConfig,
   injectedSweep,
+  injectedWorktreeSweep,
   injectedAcquireLease,
   steal = false,
   injectedVerifyRemote,
@@ -533,6 +630,7 @@ export async function runSingleStoryInit({
   let workCwd = cwd;
   let worktreeCreated = false;
   let installStatus = { status: 'skipped', reason: 'dry-run' };
+  let worktreeSweep = null;
 
   if (!dryRun) {
     const acquire = injectedAcquireLease ?? acquireStoryLease;
@@ -563,15 +661,17 @@ export async function runSingleStoryInit({
     await rollUpContainerEpic(provider, storyId, config);
 
     try {
-      await injectedMaterialize({
-        cwd,
-        baseBranch,
-        storyBranch,
-        config,
-        provider,
-        injectedSweep,
-        progress,
-      });
+      ({ worktreeSweep } =
+        (await injectedMaterialize({
+          cwd,
+          baseBranch,
+          storyBranch,
+          config,
+          provider,
+          injectedSweep,
+          worktreeSweepFn: injectedWorktreeSweep,
+          progress,
+        })) ?? {});
       injectedSeedBranch({ cwd, storyBranch, baseBranch, progress });
       ({ workCwd, worktreeCreated, installStatus } =
         await injectedProvisionWorktree({
@@ -610,6 +710,9 @@ export async function runSingleStoryInit({
     installStatus,
     dependenciesInstalled,
     installFailed: installStatus.status === 'failed',
+    // Closed-Story worktree sweep outcome; a failure degrades here, never
+    // into an init failure. `null` under --dry-run.
+    worktreeSweep: worktreeSweep ?? null,
     dryRun,
     remoteVerified: remote.remoteVerified,
     remoteProbe: { remoteUrl: remote.remoteUrl, detail: remote.detail },

package/.agents/skills/core/idea-refinement/SKILL.md

@@ -22,12 +22,12 @@ description:
 
 ## Activation
 
-Called from [`/mandrel-plan`](../../../workflows/mandrel-plan.md) during ideation when the
-operator supplies `--seed "<text>"` (or runs ideation with no seed and the host
-collects one interactively). The skill sharpens freeform intent into the
-canonical planning sections that `/mandrel-plan` then folds into a Story. There is no
-separate Epic Clarity Gate path in v2 — N=1 Story authoring with a folded
-`## Spec` is the lean default.
+Invoked directly by the operator (`idea-refine` / `ideate`), ahead of
+planning — it is not a step of
+[`/mandrel-plan`](../../../workflows/mandrel-plan.md), whose Gate #1 stops only
+for a HITL unknown or a duplicate. The skill sharpens freeform intent into the
+canonical planning sections, so a saved one-pager feeds
+`/mandrel-plan <path>` (seed-file mode) directly.
 
 ## Detailed Instructions
 

package/.agents/skills/stack/qa/qa-harness/SKILL.md

@@ -109,8 +109,7 @@ not a soft preference.
   convenience to work around. Confirm authenticated state with a
   `take_snapshot` before driving.
 - **No headless fallback.** The chrome-devtools MCP surface is a host-provided
-  runtime dependency. If it is unavailable, degrade with a clear error and stop
-  — never fall back to the retired headless BDD runner.
+  runtime dependency. If it is unavailable, report a clear error and stop.
 
 ## 4. Mode — Known-Scenario Sweep (`/qa-run`)
 

package/.agents/workflows/audit-architecture.md

@@ -23,10 +23,11 @@ Per the core's Scope interpretation:
 
 ## Execution strategy
 
-This is a **heavyweight lens**: dispatch it as a single `subagent_type: auditor`
-call, or fan its dimensions out per-dimension across parallel `auditor`
-subagents (parallel-tooling Rule 3) and merge under the self-cross-check.
-Sequential inline execution is the fallback (see the core's Execution strategy).
+Dispatch this lens as one `subagent_type: auditor` call. Fan its dimensions
+out across parallel `auditor` subagents (parallel-tooling Rule 3), merging
+under the self-cross-check, only when the operator explicitly asks for
+per-dimension fan-out. Sequential inline execution is the fallback (see the
+core's Execution strategy).
 
 ## Step 0: Tool-first detection (mandatory — run before any LLM dimension)
 

package/.agents/workflows/audit-documentation.md

@@ -62,11 +62,11 @@ with the config-driven target set above.
 
 ## Execution strategy
 
-This is a **heavyweight lens**: dispatch it as a single `subagent_type: auditor`
-call, or fan its per-doc / per-dimension verification out across parallel
-`auditor` subagents (parallel-tooling Rule 3) and merge under the
-self-cross-check. Sequential inline execution is the fallback (see the core's
-Execution strategy).
+Dispatch this lens as one `subagent_type: auditor` call. Fan its per-doc /
+per-dimension verification out across parallel `auditor` subagents
+(parallel-tooling Rule 3), merging under the self-cross-check, only when the
+operator explicitly asks for per-dimension fan-out. Sequential inline
+execution is the fallback (see the core's Execution strategy).
 
 ## Step 1: Deterministic Signal First
 

package/.agents/workflows/audit-performance.md

@@ -27,18 +27,18 @@ Per the core's Scope interpretation:
 
 ## Execution strategy
 
-This is a **heavyweight lens**: dispatch it as a single `subagent_type: auditor`
-call, or fan its resource dimensions out per-dimension across parallel `auditor`
-subagents (parallel-tooling Rule 3) and merge under the self-cross-check.
-Sequential inline execution is the fallback (see the core's Execution strategy).
+Dispatch this lens as one `subagent_type: auditor` call. Fan its resource
+dimensions out across parallel `auditor` subagents (parallel-tooling Rule 3),
+merging under the self-cross-check, only when the operator explicitly asks for
+per-dimension fan-out. Sequential inline execution is the fallback (see the
+core's Execution strategy).
 
 > **Measurement is non-mutating, not forbidden.** This lens is read-only with
-> respect to source, but it MUST be allowed to *run* measurements. The
-> orchestrated path grants its measurement agents a `Bash` tool restricted to a
-> **non-mutating command allowlist** (profilers, timers, bundle-stat and
-> file-size probes — never a command that writes source, installs, or mutates
-> git/labels). See the allowlist in the harness-generated
-> `.claude/workflows/audit-performance.workflow.js`.
+> respect to source, but the auditor MUST be allowed to *run* measurements. It
+> runs only **non-mutating** commands — profilers, timers, bundle-stat and
+> file-size probes — and never a command that writes source, installs
+> packages, or mutates git state or labels. The one write is the report
+> artifact.
 
 ## Step 0: Measure before you judge (mandatory)
 

package/.agents/workflows/{git-cleanup.md → clean-git.md}

@@ -5,9 +5,9 @@ description: >-
   `git stash` entries — each step gated by operator confirmation.
 ---
 
-# /git-cleanup [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--include-content-merged] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
+# /clean-git [--fast-forward-main] [--prune-remotes] [--branches] [--stashes] [--execute] [--remote] [--yes] [--include-content-merged] [--drop-stashes <ref>] [--exclude <pattern>] [--json]
 
-`/git-cleanup` folds the four cleanup steps operators routinely run by hand
+`/clean-git` folds the four cleanup steps operators routinely run by hand
 after a busy session into a single pipeline with per-step confirmation. It is a
 **recovery tool**, not a routine chore: the delivering flows already reap their
 own merged refs and fast-forward the base branch (see
@@ -22,13 +22,13 @@ Reach for it when the automated hygiene left an unusual state behind.
 > skill citation.
 
 The enumeration + reap logic lives in
-[`git-cleanup.js`](../scripts/git-cleanup.js) — it computes the candidate list,
+[`clean-git.js`](../scripts/clean-git.js) — it computes the candidate list,
 the skip taxonomy, the detection signals, and the JSON envelope, and prints them
 itself. Without `--execute` the script is a **dry-run preview**; nothing is
 mutated. When no phase flag is passed, **all four phases run** sequentially; a
 phase flag narrows the run. A failure in one phase does not short-circuit the
 others — each runs and reports independently. The script documents its own
-flags: `node .agents/scripts/git-cleanup.js --help`.
+flags: `node .agents/scripts/clean-git.js --help`.
 
 ## Phases
 
@@ -65,24 +65,24 @@ merged-PR branch in scope unless `--exclude`d.
 
 ```bash
 # Preview all four phases (no mutation).
-node .agents/scripts/git-cleanup.js
+node .agents/scripts/clean-git.js
 
 # Run everything non-interactively, including origin refs. Branches detected
 # only by content-equivalence keep their origin ref — see the note below.
-node .agents/scripts/git-cleanup.js --execute --remote --yes
+node .agents/scripts/clean-git.js --execute --remote --yes
 
 # Same, but also delete the origin refs of content-merged branches. Nobody is
 # watching, so opting in is the whole confirmation this delete ever gets.
-node .agents/scripts/git-cleanup.js --execute --remote --yes \
+node .agents/scripts/clean-git.js --execute --remote --yes \
   --include-content-merged
 
 # Only fast-forward main.
-node .agents/scripts/git-cleanup.js --fast-forward-main --execute
+node .agents/scripts/clean-git.js --fast-forward-main --execute
 
 # Only sweep merged branches + their origin refs.
-node .agents/scripts/git-cleanup.js --branches --execute --remote
+node .agents/scripts/clean-git.js --branches --execute --remote
 
 # Drop specific stashes under --yes.
-node .agents/scripts/git-cleanup.js --stashes --execute --yes \
+node .agents/scripts/clean-git.js --stashes --execute --yes \
   --drop-stashes 'stash@{0}' --drop-stashes 'stash@{2}'
 ```

package/.agents/workflows/clean-temp.md

@@ -0,0 +1,67 @@
+---
+description: >-
+  Clear the temp-tree backlog the land-time purge cannot attribute: sort every
+  top-level entry under the project's tempRoot into framework, closed-issue,
+  aged and kept buckets, preview by default, and delete only confirmed buckets.
+---
+
+# /clean-temp [--execute] [--yes] [--json]
+
+The land-time and boot-time purges only reap what they can attribute: the
+framework's own temp layouts and `temp/scratch/`. Everything else an agent
+dropped at the temp root is reported and left alone, so a busy consumer's temp
+tree grows without bound. `/clean-temp` is the operator's catch-up for that
+backlog. It classifies and deletes through the same temp-retention engine the
+purges use — there is no second walker.
+
+The script documents its own flags:
+`node .agents/scripts/clean-temp.js --help`. Without `--execute` it is a
+**dry-run preview**; nothing is deleted.
+
+## Buckets
+
+Every top-level entry under tempRoot lands in exactly one:
+
+| Bucket | What it holds | Unattended (`--yes`) |
+| --- | --- | --- |
+| **framework** | A framework layout holding artifacts the auto-purge would take — Story-keyed on a closed Story, or past `staleDays`. | Deleted |
+| **closed-issue** | An unrecognized entry whose basename names exactly one issue id, and that issue reads `closed`. | Deleted |
+| **aged** | An unrecognized entry naming no id, or several, older than `staleDays`. | **Never** — an age heuristic has no attribution, so it needs a human |
+| **kept** | Everything else, with the reason: issue open, issue read failed, too recent, reserved, or nothing spent. | Kept |
+
+An id is a standalone run of up to seven digits in the basename. A basename
+naming two ids is never attributed to either — it is treated as id-less.
+
+## Constraint
+
+> [!WARNING] `--execute` deletes files. Interactive runs confirm each bucket;
+> `--yes` deletes the framework and closed-issue buckets only.
+
+- Reads fail safe: an open issue, or one whose read fails, keeps its entry.
+- `qa/`, `cache/`, `*.lock` and `signals.ndjson` at any depth are never
+  deleted.
+- Project-scoped: the script exits 1 without deleting anything when the
+  resolved tempRoot is not inside the project root it was invoked from. It
+  never touches `$TMPDIR` or a sibling checkout.
+
+## Steps
+
+1. Preview and read the table (bucket, entry, size, age, reason):
+
+   ```bash
+   node .agents/scripts/clean-temp.js
+   ```
+
+2. Delete, confirming each bucket:
+
+   ```bash
+   node .agents/scripts/clean-temp.js --execute
+   ```
+
+   Unattended, `--execute --yes` deletes the framework and closed-issue buckets
+   and reports the aged bucket as left for a human. `--json` emits the envelope
+   (per-bucket totals and `bytesReclaimed`) instead of the table.
+
+Going forward, put ad-hoc scratch under `temp/scratch/story-<id>/` (or
+`temp/scratch/` with no Story): a Story's landing reaps its scratch directory,
+and the boot sweep age-floors the rest.

package/.agents/workflows/clean-worktrees.md

@@ -0,0 +1,63 @@
+---
+description: >-
+  Reclaim disk from dead worktrees: list every worktree of this project as a
+  removal candidate (closed Story, merged branch, orphaned directory, detached
+  HEAD) or as kept with a reason, then remove candidates only on `--execute`.
+---
+
+# /clean-worktrees [--execute] [--yes] [--json]
+
+Every Story worktree carries its own `node_modules`, so a worktree left behind
+costs gigabytes. Workflow boot already removes `.worktrees/story-<id>` trees
+whose Story is closed or `agent::done` (the boot sweep in
+[`boot-sweep.js`](../scripts/boot-sweep.js)); `/clean-worktrees` is the
+**recovery tool** for everything that sweep does not own — the backlog, trees
+on non-Story branches, directories git no longer registers, and detached
+trees such as the Claude Code app's `.claude/worktrees/*`.
+
+The enumeration, classification and removal live in
+[`clean-worktrees.js`](../scripts/clean-worktrees.js), which documents its own
+flags: `node .agents/scripts/clean-worktrees.js --help`.
+
+## Steps
+
+1. **Preview.** Run `node .agents/scripts/clean-worktrees.js` (dry-run, the
+   default). It prints one row per worktree — class, path, size, branch/HEAD,
+   action — and removes nothing. Show the operator the table.
+2. **Confirm.** Ask the operator which candidates to remove. Do not proceed
+   on your own judgment.
+3. **Remove.** Re-run with `--execute`. In a terminal it asks per entry;
+   `--execute --yes` removes every non-`detached` candidate without asking.
+   `--json` emits the envelope, including `bytesReclaimed`.
+
+## Classes
+
+| Class | Candidate when |
+| --- | --- |
+| `closed-story` | `.worktrees/story-<id>` on `story-<id>` whose Story is closed or `agent::done`. |
+| `merged-branch` | Any other branch whose PR is MERGED and whose HEAD is the merged head. |
+| `orphan-dir` | A directory under `.worktrees/` that `git worktree list` does not register. |
+| `detached` | A registered worktree with a detached HEAD. |
+
+Everything else is **kept** with its reason: the main checkout, an open Story,
+an unmerged branch, a dirty tree, unpushed commits, a tree in use.
+
+## Constraint
+
+> [!WARNING] `--execute` deletes worktree directories. Without it the script
+> only previews.
+
+- **Project-scoped.** Only worktrees inside the invoking checkout's project
+  root are candidates; one registered elsewhere is reported, never removed.
+- **Unique work survives.** A dirty tree, or a HEAD no remote-tracking ref
+  contains, is never removed.
+- **Live trees survive.** The tree this process runs from is never removed;
+  on macOS and Linux a tree any live process uses is refused outright.
+- **`detached` needs a person.** A detached tree carries no Story label and a
+  live session may own it (a blanket prune once destroyed a live delivery's
+  worktree), so it is removed only on a per-entry interactive yes — never
+  under `--yes`.
+- **Removal goes through the worktree removal seam** (Windows lock retry and
+  the pending-cleanup hand-off), never raw deletion.
+- **Branches are untouched.** Deleting local or remote branches is
+  [`/clean-git`](clean-git.md)'s job.

package/.agents/workflows/git-deliver.md

@@ -77,7 +77,7 @@ node .agents/scripts/boot-sweep.js \
   --current "$(git rev-parse --abbrev-ref HEAD)"
 ```
 
-The safe subset of the `/git-cleanup` phases: fast-forwards the base branch,
+The safe subset of the `/clean-git` phases: fast-forwards the base branch,
 prunes stale remote-tracking refs, and reaps merged branches. It never
 touches the stash, never reaps a candidate with unpushed work / dirty
 worktree / open parent ticket, and always exits `0` — a failed sweep is

package/.agents/workflows/helpers/acceptance-self-eval.md

@@ -32,8 +32,8 @@ per-criterion, mid-delivery, and evaluates the actual work product.
    authors the Story's verdict, and it covers **every** `acceptance[]` item in
    one file. Which pass is named by the ceremony decision
    (`verdictOwner: 'fresh-critic' | 'inline-self-eval'` from
-   `resolveCeremonyForRisk`), and since Story #5343 that follows the
-   **ceremony profile alone**:
+   `resolveCeremonyForRisk`), which follows the **ceremony profile
+   alone**:
 
    > ```bash
    > node <main-repo>/.agents/scripts/ceremony-derive.js --story <storyId> --cwd <workCwd>
@@ -43,9 +43,8 @@ per-criterion, mid-delivery, and evaluates the actual work product.
    > classes **for review depth**, and resolves the owner (`mode`, `reason`,
    > `verdictOwner`): **`minimal` / `standard` → `inline`** (the default — you
    > author the verdict yourself), **`strict` → `fresh`** (dispatch the
-   > maker-blind critic). The derived level no longer routes this decision;
-   > it escalates `review-depth.js` instead, which still resolves `deep` for
-   > any sensitive path.
+   > maker-blind critic). The derived level feeds `review-depth.js`, not
+   > this decision; review depth resolves `deep` for any sensitive path.
 
    **Never run both**, and never run a preliminary self-assessment before
    dispatching a fresh critic — the redundant pre-pass buys no measurable
@@ -72,9 +71,10 @@ per-criterion, mid-delivery, and evaluates the actual work product.
    > system prompt, no entry-doc @-closure) carrying the maker-blind
    > invariant and the verdict schema standalone. With the kill-switch off
    > (`roleScopedAgents: false`), fall back to
-   > `subagent_type: general-purpose`. This loop already runs inside a Story
-   > delivery sub-agent, so the critic sits at nesting depth 2 — supported by
-   > any harness that carries `Agent` into sub-agents (Claude Code ≥ 2.1.202).
+   > `subagent_type: general-purpose`. Under sub-agent dispatch this loop
+   > runs inside a `story-worker`, so the critic sits at nesting depth 2
+   > (depth 1 inline) — supported by any harness that carries `Agent` into
+   > sub-agents (Claude Code ≥ 2.1.202).
 
    Whichever pass owns it, the verdict:
    + Inspects the **change set it was handed** — the one `files` list above —
@@ -95,7 +95,7 @@ per-criterion, mid-delivery, and evaluates the actual work product.
      without being respawned; a stale or absent stamp reports `spawn: true` and
      the command runs for real. The credited run itself is stated once, in
      [`deliver-digest.md`](deliver-digest.md) § 5.
-   + Emits **one** verdict file under `temp/` conforming to
+   + Emits **one** verdict file under `temp/scratch/story-<id>/` conforming to
      [`acceptance-eval-verdict.schema.json`](../../schemas/acceptance-eval-verdict.schema.json):
      one `{ index, criterion, verdict: met|partial|unmet, evidence,
      verifyEvidence[] }` record per `acceptance[]` item, in acceptance-array
@@ -137,4 +137,5 @@ per-criterion, mid-delivery, and evaluates the actual work product.
      (transition to `agent::blocked`) and post a `friction` comment naming the
      unmet criteria and their evidence. Never silently proceed to close.
 
-Write the verdict under `temp/` only — it is a scratch artifact.
+Write the verdict under `temp/scratch/story-<id>/` only — a scratch artifact
+the Story's landing reaps.