mandrel 1.94.0 → 2.1.0

package/.agents/scripts/lib/orchestration/single-story-close/phases/options.js

@@ -10,7 +10,9 @@
 
 import path from 'node:path';
 import { parseSprintArgs } from '../../../cli-args.js';
+import { getDeliveryRouting } from '../../../config/delivery-routing.js';
 import { PROJECT_ROOT } from '../../../project-root.js';
+import { isOperatorMergeReason } from './auto-merge.js';
 
 /**
  * Resolve a flag value from an explicit override, a parsed CLI arg, or a
@@ -27,34 +29,66 @@ function resolveFlag(paramValue, parsedValue, defaultValue) {
 }
 
 /**
- * Resolve the `waitForMerge` option: an explicit `--no-wait-merge` opt-out
- * always wins (preserves the pre-Story-#4428 exit shape even if a future
- * headless wrapper defaults to waiting); otherwise the explicit
- * `--wait-merge` / injected value governs, defaulting to `false` so
- * attended (non-headless) invocations are byte-identical to before.
+ * Resolve whether close lands the PR in-process (`waitForMerge`).
  *
- * @param {{ waitForMergeParam, noWaitForMergeParam, parsed }} raw
- * @returns {boolean}
+ * Called by `runSingleStoryClose` **after** config resolution and the
+ * auto-merge phase, because two of its four inputs are not knowable at
+ * parse time: the resolved config (whose `cwd` this parse produces) and the
+ * actual arm outcome. Resolving it here — once, where every input exists —
+ * is what makes `delivery.routing.closeAndLand` governable at all.
+ *
+ * Precedence, highest first:
+ *   1. `--no-wait-merge` / injected opt-out — always wins.
+ *   2. **Operator owns the merge** (`--no-auto-merge`, or
+ *      `delivery.ci.autoMerge: "strict"`): the PR was deliberately left
+ *      un-armed, so there is nothing for close to land. Resting at
+ *      `agent::closing` for the human IS the documented contract for both
+ *      surfaces; waiting would only burn the poll budget and then block a
+ *      perfectly healthy Story. An explicit `--wait-merge` cannot override
+ *      this — you cannot land-in-one-close a PR you refused to arm — so the
+ *      caller is told rather than silently ignored.
+ *   3. Explicit `--wait-merge` / injected boolean.
+ *   4. `delivery.routing.closeAndLand` (framework default `true`).
+ *
+ * @param {{
+ *   waitForMergeExplicit?: boolean,
+ *   noWaitForMerge?: boolean,
+ *   config?: object|null,
+ *   autoMergeReason?: string|null,
+ * }} args
+ * @returns {{ waitForMerge: boolean, reason: 'opt-out-flag'|'operator-merge'|'explicit-flag'|'config-close-and-land' }}
  */
-function resolveWaitForMerge({
-  waitForMergeParam,
-  noWaitForMergeParam,
-  parsed,
-}) {
-  const optedOut = resolveFlag(
-    noWaitForMergeParam,
-    parsed.noWaitForMerge,
-    false,
-  );
-  if (optedOut) return false;
-  return resolveFlag(waitForMergeParam, parsed.waitForMerge, false);
+export function resolveWaitForMerge({
+  waitForMergeExplicit,
+  noWaitForMerge = false,
+  config = null,
+  autoMergeReason = null,
+} = {}) {
+  if (noWaitForMerge) {
+    return { waitForMerge: false, reason: 'opt-out-flag' };
+  }
+  if (isOperatorMergeReason(autoMergeReason)) {
+    return { waitForMerge: false, reason: 'operator-merge' };
+  }
+  if (typeof waitForMergeExplicit === 'boolean') {
+    return { waitForMerge: waitForMergeExplicit, reason: 'explicit-flag' };
+  }
+  return {
+    waitForMerge: getDeliveryRouting(config).closeAndLand,
+    reason: 'config-close-and-land',
+  };
 }
 
 /**
  * Parse and resolve all CLI / injection options for `runSingleStoryClose`.
  *
- * @param {{ storyIdParam, cwdParam, skipValidationParam, skipSyncParam, noAutoMergeParam, noFullScopeCrapParam, waitForMergeParam, noWaitForMergeParam }} raw
- * @returns {{ storyId, cwd, skipValidation, skipSync, noAutoMerge, noFullScopeCrap, waitForMerge }}
+ * `waitForMerge` is deliberately **not** resolved here — see
+ * {@link resolveWaitForMerge}. This returns the raw operator intent
+ * (`waitForMergeExplicit` / `noWaitForMerge`) for the runner to resolve once
+ * the config and the arm outcome exist.
+ *
+ * @param {{ storyIdParam, cwdParam, skipValidationParam, skipSyncParam, noAutoMergeParam, waitForMergeParam, noWaitForMergeParam, maxWaitSecondsParam }} raw
+ * @returns {{ storyId, cwd, skipValidation, skipSync, noAutoMerge, waitForMergeExplicit, noWaitForMerge, maxWaitSeconds }}
  */
 export function parseCloseOptions({
   storyIdParam,
@@ -62,9 +96,9 @@ export function parseCloseOptions({
   skipValidationParam,
   skipSyncParam,
   noAutoMergeParam,
-  noFullScopeCrapParam,
   waitForMergeParam,
   noWaitForMergeParam,
+  maxWaitSecondsParam,
 }) {
   const parsed =
     storyIdParam !== undefined
@@ -74,14 +108,26 @@ export function parseCloseOptions({
           skipValidation: !!skipValidationParam,
           skipSync: !!skipSyncParam,
           noAutoMerge: !!noAutoMergeParam,
-          noFullScopeCrap: !!noFullScopeCrapParam,
-          waitForMerge: !!waitForMergeParam,
+          // Preserve undefined so resolveWaitForMerge can apply the
+          // closeAndLand config default when neither flag was injected.
+          waitForMerge: waitForMergeParam,
           noWaitForMerge: !!noWaitForMergeParam,
+          maxWaitSeconds: maxWaitSecondsParam,
         }
       : parseSprintArgs();
+  const waitForMergeExplicit = waitForMergeParam ?? parsed.waitForMerge;
+  const maxWaitSeconds = maxWaitSecondsParam ?? parsed.maxWaitSeconds;
   return {
     storyId: parsed.storyId,
     cwd: path.resolve(cwdParam ?? parsed.cwd ?? PROJECT_ROOT),
+    // `undefined` when unsupplied — the merge wait then reads
+    // `delivery.mergeWatch.maxWaitSeconds`. A per-run override exists so a
+    // headless caller with no host tool-invocation ceiling can keep
+    // single-block semantics without editing the consumer's config.
+    maxWaitSeconds:
+      Number.isInteger(maxWaitSeconds) && maxWaitSeconds > 0
+        ? maxWaitSeconds
+        : undefined,
     skipValidation: resolveFlag(
       skipValidationParam,
       parsed.skipValidation,
@@ -89,15 +135,14 @@ export function parseCloseOptions({
     ),
     skipSync: resolveFlag(skipSyncParam, parsed.skipSync, false),
     noAutoMerge: resolveFlag(noAutoMergeParam, parsed.noAutoMerge, false),
-    noFullScopeCrap: resolveFlag(
-      noFullScopeCrapParam,
-      parsed.noFullScopeCrap,
+    waitForMergeExplicit:
+      typeof waitForMergeExplicit === 'boolean'
+        ? waitForMergeExplicit
+        : undefined,
+    noWaitForMerge: resolveFlag(
+      noWaitForMergeParam,
+      parsed.noWaitForMerge,
       false,
     ),
-    waitForMerge: resolveWaitForMerge({
-      waitForMergeParam,
-      noWaitForMergeParam,
-      parsed,
-    }),
   };
 }

package/.agents/scripts/lib/orchestration/single-story-close/phases/post-land.js

@@ -0,0 +1,305 @@
+/**
+ * phases/post-land.js — the script-owned land tail (Story #4543).
+ *
+ * Everything after "the PR merged and the Story is `agent::done`" used to be
+ * prose in `helpers/deliver-story.md`: Step 5.5 resync, Step 6 cleanup, and
+ * follow-up capture, each a separate CLI an agent may or may not have run.
+ * Follow-up capture was the sharpest edge — it lived only on the standalone
+ * `single-story-confirm-merge.js` path, which close-and-land (the DEFAULT)
+ * is explicitly told to skip, so per-Story follow-ups were captured *never*
+ * on the default path, and a belated manual confirm could not backfill (the
+ * Story is already `agent::done`, so confirm short-circuits `noop` and the
+ * capture's `action === 'done'` gate never opens).
+ *
+ * This module folds all four steps into one phase both landing surfaces
+ * reach — the in-close wait (`phases/confirm-merge.js`) and the standalone
+ * `single-story-confirm-merge.js` CLI — so the two paths cannot diverge and
+ * "landed" means the whole tail ran.
+ *
+ * **Per-step booleans, not an aggregate.** {@link runPostLandTail} reports
+ * each step's outcome individually. That is not bookkeeping fastidiousness:
+ * the worktree-reap defect this repo fixed existed because a phase reported
+ * an outcome it never checked, and a single `tailOk: true` bit invites that
+ * class of bug straight back. A degraded step is visible in the terminal
+ * envelope without failing an otherwise-healthy land.
+ *
+ * **Never throws.** The merge already landed — the code is on the base
+ * branch. Failing the land because a Projects v2 mutation flaked would
+ * report a false negative about work that is demonstrably done. Every step
+ * is best-effort and records its own reason.
+ */
+
+import { gitSpawn as defaultGitSpawn } from '../../../git-utils.js';
+import { Logger } from '../../../Logger.js';
+import {
+  executeFastForward as defaultExecuteFastForward,
+  planFastForward as defaultPlanFastForward,
+} from '../../git-cleanup/phases/fast-forward.js';
+import { reassertStatusColumn as defaultReassertStatusColumn } from '../../reassert-status-column.js';
+import { captureStoryFollowUps as defaultCaptureStoryFollowUps } from '../../story-follow-ups.js';
+
+/**
+ * Run one tail step, converting any throw into a `false` + reason. Keeps
+ * each step's own body free of defensive boilerplate while guaranteeing the
+ * module-level never-throws contract.
+ *
+ * @template T
+ * @param {() => Promise<{ ok: boolean, detail?: string|null }>} run
+ * @param {{ name: string, progress?: Function }} ctx
+ * @returns {Promise<{ ok: boolean, detail: string|null }>}
+ */
+async function step(run, { name, progress }) {
+  try {
+    const outcome = await run();
+    if (!outcome.ok) {
+      progress?.(
+        'POST-LAND',
+        `⚠️ ${name} degraded (land stands): ${outcome.detail ?? 'no detail'}`,
+      );
+    }
+    return { ok: Boolean(outcome.ok), detail: outcome.detail ?? null };
+  } catch (err) {
+    const detail = String(err?.message ?? err);
+    Logger.warn(`[post-land] ${name} threw (land stands): ${detail}`);
+    progress?.('POST-LAND', `⚠️ ${name} threw (land stands): ${detail}`);
+    return { ok: false, detail };
+  }
+}
+
+/**
+ * Capture the Story's follow-ups from its friction signal stream.
+ *
+ * Calls `captureStoryFollowUps` **directly** rather than through the
+ * `captureFollowUpsAfterConfirm` action-gate wrapper: by the time the tail
+ * runs, the merge is already confirmed, so re-deriving that fact from a
+ * confirmation envelope's `action` field is the exact coupling that made
+ * the default path skip capture entirely.
+ */
+async function stepFollowUps({
+  storyId,
+  provider,
+  config,
+  cwd,
+  progress,
+  captureStoryFollowUpsFn,
+}) {
+  const result = await captureStoryFollowUpsFn({
+    storyId,
+    provider,
+    config,
+    cwd,
+    progress,
+  });
+  return {
+    ok: result?.ok === true,
+    detail: result?.ok === true ? null : (result?.reason ?? 'capture-failed'),
+  };
+}
+
+/**
+ * Re-assert the Projects v2 Status column against the bot's late write.
+ *
+ * A `skipped` envelope (`no-project`, `not-on-project`, `no-meta`) is a
+ * **success**: the board the helper would defend does not exist, so there
+ * is nothing to get wrong. Only a genuine `drifted` outcome — the helper
+ * fired, polled, and still lost — degrades the step.
+ */
+async function stepStatusResync({
+  storyId,
+  provider,
+  config,
+  progress,
+  reassertStatusColumnFn,
+}) {
+  const outcome = await reassertStatusColumnFn({
+    provider,
+    ticketId: storyId,
+    config,
+    logger: {
+      info: (m) => progress?.('POST-LAND', m),
+      warn: (m) => progress?.('POST-LAND', `⚠️ ${m}`),
+    },
+  });
+  if (outcome?.status === 'synced' || outcome?.status === 'skipped') {
+    return { ok: true, detail: null };
+  }
+  return {
+    ok: false,
+    detail: `status column ${outcome?.status ?? 'unknown'} (target=${outcome?.column ?? 'n/a'}, attempts=${outcome?.attempts ?? 0})`,
+  };
+}
+
+/**
+ * Reap the local `story-<id>` ref. GitHub deletes the *remote* branch on
+ * squash-merge (`--delete-branch`), but the local ref lingers in the main
+ * checkout until something prunes it.
+ *
+ * An absent ref is a success, not a failure — the sweep is idempotent and
+ * a previous run (or the init-time merged-sweep) may have already reaped it.
+ */
+async function stepRefCleanup({ cwd, storyBranch, progress, gitSpawnFn }) {
+  const exists = gitSpawnFn(
+    cwd,
+    'show-ref',
+    '--verify',
+    '--quiet',
+    `refs/heads/${storyBranch}`,
+  );
+  if (exists.status !== 0) {
+    progress?.('POST-LAND', `⏭  local ${storyBranch} already absent.`);
+    return { ok: true, detail: null };
+  }
+  const del = gitSpawnFn(cwd, 'branch', '-D', storyBranch);
+  if (del.status !== 0) {
+    return { ok: false, detail: `git branch -D failed: ${del.stderr ?? ''}` };
+  }
+  progress?.('POST-LAND', `🧹 reaped local ${storyBranch}.`);
+  return { ok: true, detail: null };
+}
+
+/**
+ * Fast-forward local `baseBranch` so the next Story seeds from the tip that
+ * now contains this merge. Reuses the same planner/executor pair
+ * `single-story-init.js` imports (rather than shelling out to
+ * `/git-cleanup`), which is the established in-process composition pattern.
+ *
+ * `already-up-to-date` is a success. A dirty tree is a legitimate, expected
+ * skip on a shared checkout — another worker is mid-flight — so it degrades
+ * the step's report without pretending the base moved.
+ */
+async function stepBaseFastForward({
+  cwd,
+  baseBranch,
+  progress,
+  planFastForwardFn,
+  executeFastForwardFn,
+}) {
+  const plan = planFastForwardFn({ cwd, baseBranch });
+  if (!plan.runnable && plan.reason === 'already-up-to-date') {
+    progress?.('POST-LAND', `⏭  local ${baseBranch} already up to date.`);
+    return { ok: true, detail: null };
+  }
+  const ff = executeFastForwardFn({
+    cwd,
+    baseBranch,
+    plan,
+    logger: {
+      info: (m) => progress?.('POST-LAND', m),
+      warn: (m) => progress?.('POST-LAND', `⚠️ ${m}`),
+    },
+  });
+  if (ff.applied) {
+    progress?.(
+      'POST-LAND',
+      `⏩ fast-forwarded ${baseBranch} by ${ff.behind} commit(s).`,
+    );
+    return { ok: true, detail: null };
+  }
+  return {
+    ok: false,
+    detail: `fast-forward skipped: ${ff.reason ?? plan.reason ?? 'unknown'}`,
+  };
+}
+
+/**
+ * Run the whole post-land tail. Never throws.
+ *
+ * Steps run **sequentially** and in this order deliberately: follow-up
+ * capture and the status resync touch GitHub, while the ref reap and the
+ * fast-forward mutate the local checkout — and the fast-forward must run
+ * after the ref reap so `git branch -D` is not fighting a checkout that just
+ * moved HEAD.
+ *
+ * @param {object} args
+ * @param {number} args.storyId
+ * @param {string} args.storyBranch
+ * @param {string} args.baseBranch
+ * @param {string} args.cwd            The MAIN checkout (never the worktree).
+ * @param {object} args.provider
+ * @param {object} [args.config]
+ * @param {(tag: string, msg: string) => void} [args.progress]
+ * @param {Function} [args.captureStoryFollowUpsFn] Test seam.
+ * @param {Function} [args.reassertStatusColumnFn]  Test seam.
+ * @param {Function} [args.gitSpawnFn]              Test seam.
+ * @param {Function} [args.planFastForwardFn]       Test seam.
+ * @param {Function} [args.executeFastForwardFn]    Test seam.
+ * @returns {Promise<{ followUps: boolean, statusResync: boolean, refCleanup: boolean, baseFastForward: boolean, details: Record<string, string|null> }>}
+ */
+export async function runPostLandTail({
+  storyId,
+  storyBranch,
+  baseBranch,
+  cwd,
+  provider,
+  config,
+  progress,
+  captureStoryFollowUpsFn = defaultCaptureStoryFollowUps,
+  reassertStatusColumnFn = defaultReassertStatusColumn,
+  gitSpawnFn = defaultGitSpawn,
+  planFastForwardFn = defaultPlanFastForward,
+  executeFastForwardFn = defaultExecuteFastForward,
+}) {
+  progress?.('POST-LAND', `🧾 Running land tail for Story #${storyId}...`);
+
+  const followUps = await step(
+    () =>
+      stepFollowUps({
+        storyId,
+        provider,
+        config,
+        cwd,
+        progress,
+        captureStoryFollowUpsFn,
+      }),
+    { name: 'follow-up capture', progress },
+  );
+  const statusResync = await step(
+    () =>
+      stepStatusResync({
+        storyId,
+        provider,
+        config,
+        progress,
+        reassertStatusColumnFn,
+      }),
+    { name: 'status-column resync', progress },
+  );
+  const refCleanup = await step(
+    () => stepRefCleanup({ cwd, storyBranch, progress, gitSpawnFn }),
+    { name: 'local ref cleanup', progress },
+  );
+  const baseFastForward = await step(
+    () =>
+      stepBaseFastForward({
+        cwd,
+        baseBranch,
+        progress,
+        planFastForwardFn,
+        executeFastForwardFn,
+      }),
+    { name: 'base fast-forward', progress },
+  );
+
+  const tail = {
+    followUps: followUps.ok,
+    statusResync: statusResync.ok,
+    refCleanup: refCleanup.ok,
+    baseFastForward: baseFastForward.ok,
+    details: {
+      followUps: followUps.detail,
+      statusResync: statusResync.detail,
+      refCleanup: refCleanup.detail,
+      baseFastForward: baseFastForward.detail,
+    },
+  };
+  const degraded = Object.entries(tail)
+    .filter(([k, v]) => k !== 'details' && v === false)
+    .map(([k]) => k);
+  progress?.(
+    'POST-LAND',
+    degraded.length === 0
+      ? `✅ Land tail complete for Story #${storyId} (all steps ok).`
+      : `✅ Land tail complete for Story #${storyId} — degraded: ${degraded.join(', ')} (the merge stands).`,
+  );
+  return tail;
+}

package/.agents/scripts/lib/orchestration/single-story-close/phases/pull-request.js

@@ -95,7 +95,7 @@ export async function ensurePullRequestWith({
   const body = [
     `Closes #${storyId}`,
     '',
-    `_Auto-opened by \`/single-story-deliver\`._`,
+    `_Auto-opened by \`/deliver\`._`,
   ].join('\n');
   try {
     const createResult = await gh.pr.create([

package/.agents/scripts/lib/orchestration/single-story-close/phases/review-block.js

@@ -0,0 +1,44 @@
+import { Logger } from '../../../Logger.js';
+import {
+  STATE_LABELS,
+  transitionTicketState,
+  upsertStructuredComment,
+} from '../../ticketing.js';
+
+/**
+ * Record a critical code-review halt as authoritative blocked state before
+ * close releases the Story lease and returns non-zero.
+ */
+export async function handleCriticalReviewBlock({
+  provider,
+  storyId,
+  prUrl,
+  criticalCount,
+}) {
+  const body = [
+    '### Code review blocked delivery',
+    '',
+    `The Story-scope review reported **${criticalCount} critical blocker(s)** on ${prUrl}.`,
+    'Remediate the posted findings, then re-run `/deliver`.',
+  ].join('\n');
+  try {
+    await upsertStructuredComment(provider, storyId, 'friction', body);
+  } catch (err) {
+    Logger.warn(
+      `[single-story-close] failed to post review-block friction: ${err?.message ?? err}`,
+    );
+  }
+  // Story #4539 — route through the canonical mutator rather than writing
+  // labels directly. A bare `provider.updateTicket` skips the Projects v2
+  // column sync (Story #2548), leaving the board on the Story's prior
+  // status. That is benign today only because agent::blocked and
+  // agent::executing happen to map to the same column — a coincidence, not
+  // a design, and exactly how the next drift gets in.
+  try {
+    await transitionTicketState(provider, storyId, STATE_LABELS.BLOCKED, {});
+  } catch (err) {
+    Logger.warn(
+      `[single-story-close] failed to block Story after critical review: ${err?.message ?? err}`,
+    );
+  }
+}

package/.agents/scripts/lib/orchestration/single-story-close/phases/worktree-reap.js

@@ -7,6 +7,16 @@
  * reports success because the operator can clean stale worktrees out of
  * band.
  *
+ * **Report what happened, not what was attempted** (Story #4539). This
+ * phase used to set `worktreeReaped = true` and log "🧹 Reaped worktree"
+ * on any non-throwing call — without reading the returned envelope. Since
+ * `reap` signals refusal by *returning* `{ removed: false, reason }`
+ * rather than throwing, and a v2-era precondition refused every
+ * `story-<id>` worktree outright, the result was that no close ever
+ * actually reaped and every close said it did. Best-effort means the close
+ * still succeeds on refusal; it does not mean the close may claim an
+ * outcome it never checked.
+ *
  * Also clears the trace-hook env vars so subsequent tooling falls back to
  * the no-op branch instead of pointing at a (now-reaped) worktree.
  */
@@ -26,7 +36,8 @@ import { WorktreeManager as DefaultWorktreeManager } from '../../../worktree-man
  *   wtIsolation: object|undefined,
  *   progress: (tag: string, msg: string) => void,
  * }} args
- * @returns {Promise<boolean>} true when reap completed
+ * @returns {Promise<boolean>} `true` only when the worktree was actually
+ *   removed — never merely because the call did not throw.
  */
 export async function reapWorktreePhase({
   cwd,
@@ -49,9 +60,31 @@ export async function reapWorktreePhase({
           error: (m) => Logger.error(`[single-story-close] ${m}`),
         },
       });
-      await wm.reap(storyId);
-      worktreeReaped = true;
-      progress('WORKTREE', `🧹 Reaped worktree for story-${storyId}.`);
+      // Deliberately NO base ref. This phase runs BEFORE the merge (see
+      // `../runner.js` — reap precedes the confirm phase), so "is this work
+      // integrated into the base?" is the wrong question: the answer is
+      // always no, and supplying a ref would activate `isSafeToRemove`'s
+      // merge-reachability gate and refuse every reap with
+      // `unmerged-commits` — trading one always-refuse precondition for
+      // another.
+      //
+      // What actually makes the reap safe here is that close has already
+      // pushed `story-<id>` to origin and opened the PR, so the work is
+      // durable off-machine; and `isSafeToRemove` still refuses a dirty
+      // tree (`uncommitted-changes`), which is the check that protects
+      // unsaved work. Refusal is signalled by the returned envelope rather
+      // than by throwing — so read it.
+      const result = await wm.reap(storyId);
+      worktreeReaped = result?.removed === true;
+      if (worktreeReaped) {
+        progress('WORKTREE', `🧹 Reaped worktree for story-${storyId}.`);
+      } else {
+        progress(
+          'WORKTREE',
+          `⚠️ Worktree for story-${storyId} not reaped (${result?.reason ?? 'unknown reason'}) — ` +
+            `${worktreePath} left in place for the next sweep.`,
+        );
+      }
     } catch (err) {
       Logger.error(
         `[single-story-close] ⚠️ Failed to reap worktree: ${err?.message ?? err}`,

package/.agents/scripts/lib/orchestration/single-story-close/phases/wrong-tree-guard.js

@@ -232,7 +232,7 @@ export function formatWrongTreeFinding({ storyId, strayFiles, worktreePath }) {
     `**Recovery:** relocate these edits into the worktree (re-apply them under ` +
     `\`${worktreePath}\`), restore the main checkout ` +
     `(\`git -C <main-repo> checkout -- <files>\`), then re-run ` +
-    `\`/single-story-deliver\`.`
+    `\`/deliver ${storyId}\`.`
   );
 }
 
@@ -307,7 +307,7 @@ async function abortWrongTree({
       `diff-path set while the worktree (${worktreePath}) is the active work ` +
       `tree. Close aborted to avoid an empty-diff PR. Stray files: ` +
       `${strayFiles.join(', ')}. Relocate the edits into the worktree, ` +
-      `restore the main checkout, then re-run /single-story-deliver.`,
+      `restore the main checkout, then re-run /deliver ${storyId}.`,
   );
 }