mandrel 1.88.0 → 1.90.0

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

@@ -15,6 +15,7 @@ import { runAutoMergePhase } from './phases/auto-merge.js';
 import { runBaseSyncPhase } from './phases/base-sync.js';
 import { runCloseValidationPhase } from './phases/close-validation.js';
 import { parsePrNumber, runStoryScopeReview } from './phases/code-review.js';
+import { runConfirmMergePhase } from './phases/confirm-merge.js';
 import { parseCloseOptions } from './phases/options.js';
 import { ensurePullRequestWith } from './phases/pull-request.js';
 import { pushStoryBranch } from './phases/push.js';
@@ -57,6 +58,7 @@ async function runPrePushPhases({
   await runWrongTreeGuardPhase({
     cwd,
     worktreePath,
+    baseBranch,
     storyId,
     provider,
     progress,
@@ -204,6 +206,8 @@ function closeResult({
   autoMergeReason,
   worktreeReaped,
   leaseReleased,
+  waitedForMerge = false,
+  merged = false,
 }) {
   return {
     storyId,
@@ -217,9 +221,13 @@ function closeResult({
     autoMergeReason,
     worktreeReaped,
     leaseReleased,
-    note: autoMergeEnabled
-      ? 'PR open against baseBranch with auto-merge enabled. Story rests at agent::closing (issue stays OPEN). GitHub will squash-merge when required checks pass; run single-story-confirm-merge.js after the merge confirms to flip agent::done and close the issue (the Closes #<id> footer also auto-closes it).'
-      : 'PR open against baseBranch. Story rests at agent::closing (issue stays OPEN). Operator merges via GitHub UI; run single-story-confirm-merge.js after the merge confirms to flip agent::done (the Closes #<id> footer also auto-closes the issue).',
+    waitedForMerge,
+    merged,
+    note: waitedForMerge
+      ? 'Headless must-land: PR merge confirmed. Story flipped agent::closing → agent::done and the issue closed (confirmStoryMerged).'
+      : autoMergeEnabled
+        ? 'PR open against baseBranch with auto-merge enabled. Story rests at agent::closing (issue stays OPEN). GitHub will squash-merge when required checks pass; run single-story-confirm-merge.js after the merge confirms to flip agent::done and close the issue (the Closes #<id> footer also auto-closes it).'
+        : 'PR open against baseBranch. Story rests at agent::closing (issue stays OPEN). Operator merges via GitHub UI; run single-story-confirm-merge.js after the merge confirms to flip agent::done (the Closes #<id> footer also auto-closes the issue).',
   };
 }
 
@@ -230,6 +238,8 @@ export async function runSingleStoryClose({
   skipSync: skipSyncParam,
   noAutoMerge: noAutoMergeParam,
   noFullScopeCrap: noFullScopeCrapParam,
+  waitForMerge: waitForMergeParam,
+  noWaitForMerge: noWaitForMergeParam,
   injectedProvider,
   injectedConfig,
   injectedNotify,
@@ -246,10 +256,12 @@ export async function runSingleStoryClose({
     skipSyncParam,
     noAutoMergeParam,
     noFullScopeCrapParam,
+    waitForMergeParam,
+    noWaitForMergeParam,
   });
   if (!options.storyId) {
     throw new Error(
-      'Usage: node single-story-close.js --story <STORY_ID> [--cwd <main-repo>] [--skip-validation] [--skip-sync] [--no-auto-merge] [--no-full-scope-crap]',
+      'Usage: node single-story-close.js --story <STORY_ID> [--cwd <main-repo>] [--skip-validation] [--skip-sync] [--no-auto-merge] [--no-full-scope-crap] [--wait-merge|--no-wait-merge]',
     );
   }
 
@@ -341,6 +353,56 @@ export async function runSingleStoryClose({
     WorktreeManager,
   });
   const leaseReleased = await releaseLease(leaseArgs);
+
+  // Story #4428 — headless must-land: `--wait-merge` polls the just-armed
+  // PR to merge confirmation (or an explicit `agent::blocked` +
+  // `merge.unlanded`) instead of resting at `agent::closing`. Attended
+  // (non-headless) runs never set this flag, so the exit shape below is
+  // unreachable and the pre-existing early-return is byte-identical.
+  if (options.waitForMerge) {
+    const waitOutcome = await runConfirmMergePhase({
+      cwd: options.cwd,
+      storyId: options.storyId,
+      prNumber,
+      prUrl,
+      autoMergeEnabled,
+      autoMergeReason,
+      provider,
+      config,
+      progress,
+      injectedGh,
+      injectedNotify,
+    });
+    if (!waitOutcome.confirmed) {
+      throw new Error(
+        `[single-story-close] Headless must-land: PR ${prUrl} did not reach a confirmed merge ` +
+          `(blockClass=${waitOutcome.blockClass}). Story #${options.storyId} was transitioned to ` +
+          `agent::blocked with a merge.unlanded lifecycle event. Reason: ${waitOutcome.reason}`,
+      );
+    }
+    const result = closeResult({
+      storyId: options.storyId,
+      storyBranch,
+      baseBranch,
+      prUrl,
+      prNumber,
+      autoMergeEnabled,
+      autoMergeReason,
+      worktreeReaped,
+      leaseReleased,
+      waitedForMerge: true,
+      merged: true,
+    });
+    Logger.info(
+      `\n--- STORY CLOSE RESULT ---\n${JSON.stringify(result, null, 2)}\n--- END RESULT ---\n`,
+    );
+    progress(
+      'DONE',
+      `✅ Standalone Story #${options.storyId}: PR merged → ${prUrl}`,
+    );
+    return { success: true, result };
+  }
+
   const result = closeResult({
     storyId: options.storyId,
     storyBranch,

package/.agents/scripts/lib/orchestration/spec-section-validator.js

@@ -1,5 +1,5 @@
 /**
- * spec-section-validator.js — Phase 7.5 Tech Spec post-authoring section gate.
+ * spec-section-validator.js — Tech Spec post-authoring section gate.
  *
  * `/plan` Phase 7 authors a Tech Spec from documentation and the Epic body.
  * Phase 8.3 (Holistic Consolidation) then reconciles the draft ticket array
@@ -12,19 +12,29 @@
  *
  * `validateSpecSections` parses a Tech Spec body for the required
  * `## Delivery Slicing` heading (accepting the casing/wording variants
- * below) and returns a deterministic `{ ok, missing[] }` envelope. The
- * caller (`epic-plan-spec-validate.js`) maps a non-empty `missing[]` to a
- * non-zero exit so Phase 8 decomposition cannot proceed against an
- * un-anchored spec.
+ * below) and returns a deterministic `{ ok, missing[] }` envelope.
  *
- * This is the Phase 8-side counterpart to the Phase 6 Epic Clarity Gate
+ * Story #4403 (Finding 3): this gate used to be run by a standalone
+ * `epic-plan-spec-validate.js` CLI as a separate Phase 7.5 workflow step —
+ * but by the time the documented ordering ran it, the Phase 7 persist path's
+ * `cleanupPhaseTempFiles` had already deleted the temp `techspec.md` file the
+ * gate read, so the "blocking gate" could never actually block. The CLI is
+ * retired; `runSpecPhase` (`phases/run-spec-phase.js`) now calls
+ * `validateSpecSections` directly against the in-memory authored content as
+ * part of its input validation, before any GitHub mutation. This is the
+ * Phase 8-side counterpart to the Phase 6 Epic Clarity Gate
  * ({@link ../epic-plan-clarity.js#scoreEpicBody}) — same detect-then-prompt
- * pattern, one phase later, but a hard gate (exit non-zero) rather than an
+ * pattern, one phase later, but a hard gate (fail closed) rather than an
  * advisory rubric.
  *
- * Pure ESM, no I/O.
+ * `validateSpecSections` and `formatMissingSectionMessage` are pure, I/O-free
+ * helpers. `validateSpecFile` is a thin disk-reading convenience for callers
+ * (tests, ad-hoc tooling) that hold a path rather than in-memory content.
  */
 
+import { readFile } from 'node:fs/promises';
+import { DELIVERY_SLICING_RE } from '../epic-body-sections.js';
+
 /**
  * The single required Tech Spec section, with the heading variants the
  * Architect persona may emit. Matched case-insensitively against any
@@ -39,7 +49,7 @@ const REQUIRED_SECTIONS = Object.freeze([
   {
     name: 'Delivery Slicing',
     /** Level-2 heading, allowing the `Delivery ` qualifier to be optional. */
-    re: /^##\s+(?:Delivery\s+)?Slicing\s*$/im,
+    re: DELIVERY_SLICING_RE,
   },
 ]);
 
@@ -78,3 +88,44 @@ export function validateSpecSections({ body } = {}) {
 
   return { ok: missing.length === 0, missing, present };
 }
+
+/**
+ * Validate an authored Tech Spec file for the required post-authoring
+ * sections. Thin wrapper around `validateSpecSections` that owns the file
+ * read so callers holding a path (rather than in-memory content) do not each
+ * re-implement the read-then-validate sequence.
+ *
+ * @param {{ techspecPath: string }} args
+ * @returns {Promise<{ ok: boolean, missing: string[], present: string[] }>}
+ */
+export async function validateSpecFile({ techspecPath }) {
+  const body = await readFile(techspecPath, 'utf8');
+  return validateSpecSections({ body });
+}
+
+/**
+ * Build the operator-facing failure message for a missing-section result.
+ * Names each missing section and tells the operator whether to re-author the
+ * spec or add the section by hand before continuing.
+ *
+ * @param {{ techspecPath: string, missing: string[] }} args
+ * @returns {string}
+ */
+export function formatMissingSectionMessage({ techspecPath, missing }) {
+  const list = missing.map((name) => `## ${name}`).join(', ');
+  return [
+    `[spec-section-validator] Tech Spec is missing required section(s): ${list}`,
+    `  Spec source: ${techspecPath}`,
+    '',
+    `  Phase 8 (decomposition) reconciles the draft ticket array against the`,
+    `  Tech Spec's "## Delivery Slicing" section — without it, the Phase 8.3`,
+    `  consolidation pass has no capability-boundary anchor and groups by`,
+    `  technical shape instead.`,
+    '',
+    '  To continue, do ONE of the following and re-run the Phase 7 persist step:',
+    `    1. Re-author the Tech Spec (re-run the Phase 7 spec-author step) so it`,
+    `       emits a "## Delivery Slicing" section, OR`,
+    `    2. Add a "## Delivery Slicing" section to the Tech Spec by hand,`,
+    `       describing the capability boundaries the work should be sliced along.`,
+  ].join('\n');
+}

package/.agents/scripts/lib/orchestration/story-close/auto-refresh-runner.js

@@ -376,7 +376,7 @@ function filterToStoryDiff({ miRows, crapRows, storyDiffPaths }) {
 
 /**
  * Check whether a `baseline-refresh-regression` signal tagged with the
- * runner's `source.tool === 'auto-refresh-runner'` already exists in the
+ * runner's `emitter.tool === 'auto-refresh-runner'` already exists in the
  * Story's signals stream. Backs the AC3 idempotent-re-run contract.
  */
 async function priorRefusalSignalExists({
@@ -391,7 +391,7 @@ async function priorRefusalSignalExists({
       typeof record === 'object' &&
       record.kind === 'friction' &&
       record.category === FRICTION_CATEGORY &&
-      record?.source?.tool === RUNNER_SOURCE_TOOL
+      record?.emitter?.tool === RUNNER_SOURCE_TOOL
     ) {
       found = true;
     }
@@ -413,12 +413,14 @@ function buildRefusalSignal({
 }) {
   return {
     kind: 'friction',
-    timestamp: new Date().toISOString(),
+    ts: new Date().toISOString(),
     epicId,
     storyId,
     category: FRICTION_CATEGORY,
-    source: { tool: RUNNER_SOURCE_TOOL },
-    details: `Auto-refresh refused: ${refusalReasons.length} row(s) breach configured caps (miDropCap=${caps.miDropCap}, crapJumpCap=${caps.crapJumpCap}).`,
+    emitter: { tool: RUNNER_SOURCE_TOOL },
+    details: {
+      message: `Auto-refresh refused: ${refusalReasons.length} row(s) breach configured caps (miDropCap=${caps.miDropCap}, crapJumpCap=${caps.crapJumpCap}).`,
+    },
     refusalReasons,
     miOverCap,
     crapOverCap,

package/.agents/scripts/lib/orchestration/story-close/merge-runner.js

@@ -55,6 +55,10 @@ import {
   buildMergeMessageWithCap,
   loadHeaderMaxLength,
 } from './merge-subject.js';
+import {
+  assertNoForeignEpicLock as defaultAssertNoForeignEpicLock,
+  assertSharedCheckoutAvailable as defaultAssertSharedCheckoutAvailable,
+} from './shared-checkout-guard.js';
 
 /**
  * Render the lock-file path for a given main-repo `cwd` + `epicId`. Pure;
@@ -424,7 +428,7 @@ export async function runFinalizeMerge({
   storyBranch,
   storyTitle,
   storyId,
-  epicId: _epicId,
+  epicId,
   cwd,
   config,
   bus = null,
@@ -432,6 +436,7 @@ export async function runFinalizeMerge({
   logger = DefaultLogger,
   gitSync = defaultGitSync,
   gitSpawn = defaultGitSpawn,
+  assertSharedCheckoutAvailable = defaultAssertSharedCheckoutAvailable,
 }) {
   rebaseStoryOnEpic({
     config,
@@ -443,6 +448,15 @@ export async function runFinalizeMerge({
     gitSpawn,
   });
 
+  // Story #4460 — cross-epic shared-checkout guard. Runs AFTER the
+  // per-Epic merge lock is already held (acquired around the whole close
+  // flow in story-close.js) so it composes with, rather than replaces,
+  // that same-epic serialization. Fails fast with an actionable
+  // diagnostic instead of letting a raw `git checkout` error surface
+  // when another epic's merge phase (or unrelated dirt) holds the
+  // shared checkout.
+  assertSharedCheckoutAvailable({ cwd, epicId, gitSpawn });
+
   log('GIT', `Checking out ${epicBranch}...`);
   gitSync(cwd, 'checkout', epicBranch);
   gitSpawn(cwd, 'pull', '--rebase', 'origin', epicBranch);
@@ -582,13 +596,21 @@ export async function runResumeMerge({
   storyBranch,
   storyTitle,
   storyId,
-  epicId: _epicId,
+  epicId,
   config,
   bus = null,
   logger = DefaultLogger,
   log = () => {},
   gitSpawn = defaultGitSpawn,
+  assertNoForeignEpicLockFn = defaultAssertNoForeignEpicLock,
 }) {
+  // Story #4460 follow-up: the resume path re-enters the shared checkout
+  // just like the finalize path, so another epic's live merge phase is
+  // the same hazard here. Only the foreign-lock half of the guard runs —
+  // a resume's own partial merge legitimately leaves the tree dirty, so
+  // the dirty-tree probe would false-positive against our own state.
+  assertNoForeignEpicLockFn({ cwd, epicId });
+
   const resumeMergeMessage = await buildMergeMessage(storyTitle, storyId, {
     cwd,
     logger,

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

@@ -5,9 +5,9 @@
  * Sits between the close-validation gate chain and the merge into
  * `epic/<id>` inside `runStoryCloseLocked` (locked-pipeline.js). The
  * configured ReviewProvider runs against the
- * `epic/<id>`…`story-<id>` diff. The structured `code-review` comment
- * is posted to the Story issue (default `commentTargetId === ticketId`
- * inside `runCodeReview`). Outcomes:
+ * `epic/<id>`…`story-<id>` diff. The unified `verification-results`
+ * structured comment is posted to the Story issue (default
+ * `commentTargetId === ticketId` inside `runCodeReview`). Outcomes:
  *
  *   - clean / non-critical findings → `{ blocked: null }`; the pipeline
  *     proceeds to merge.
@@ -32,10 +32,141 @@
  * invocation pattern (Story #3653).
  */
 
+import {
+  runAuditSuite,
+  selectLocalLenses,
+} from '../../../audit-suite/index.js';
+import { gitSpawn } from '../../../git-utils.js';
 import { Logger } from '../../../Logger.js';
 import { runCodeReview } from '../../code-review.js';
 import { emitBlockedCloseResult } from '../merge-runner.js';
 
+/**
+ * The review depth the Story-scope local-lens pass runs at. Shift-left
+ * (Epic #4405): local concerns are cheap to decide on a single Story's diff, so
+ * the maker-blind Story-scope review runs its matched local lenses at `light`
+ * depth here rather than paying a deeper pass at Epic close. Fixed for this
+ * tier — it is not risk-scaled like the code-review pillar depth.
+ */
+export const STORY_SCOPE_LENS_DEPTH = 'light';
+
+/**
+ * Enumerate the files changed in the `baseRef...headRef` diff via
+ * `git diff --name-only`. Best-effort: returns `[]` when the diff cannot be
+ * enumerated (git failure, missing ref) and never throws, mirroring the
+ * advisory posture of the surrounding review phase. Synchronous `gitSpawn`
+ * (returns `{ status, stdout }`) is the same seam `code-review.js#countChangedFiles`
+ * uses.
+ *
+ * @param {{ baseRef: string, headRef: string, gitSpawnFn?: typeof gitSpawn }} args
+ * @returns {string[]} Changed file paths, or `[]` on any failure.
+ */
+export function enumerateChangedFiles({
+  baseRef,
+  headRef,
+  gitSpawnFn = gitSpawn,
+}) {
+  try {
+    const result = gitSpawnFn(
+      process.cwd(),
+      'diff',
+      '--name-only',
+      `${baseRef}...${headRef}`,
+    );
+    if (!result || result.status !== 0 || typeof result.stdout !== 'string') {
+      return [];
+    }
+    return result.stdout
+      .split('\n')
+      .map((f) => f.trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Run the Story-scope local-lens pass: select the LOCAL-tier lenses whose
+ * `filePatterns` match the actual Story diff (`baseRef...headRef`) and
+ * materialize their lens-prompt bodies at `light` depth. This is the
+ * shift-left tier from Epic #4405 — it runs **inside** the story-close
+ * subprocess spine (called only from {@link runStoryReviewCore}), never in the
+ * delivering child's (maker's) context, so a maker never grades its own work.
+ *
+ * A diff that matches no local lens adds **no** lens work: the roster is empty
+ * and `runAuditSuite` is never invoked. Best-effort and total — a git or
+ * materialization failure degrades to `{ skipped: true, lenses: [] }` and is
+ * logged via `progress`, matching the advisory posture the review phase already
+ * takes for provider/transport failures.
+ *
+ * @param {{
+ *   baseRef: string,
+ *   headRef: string,
+ *   progress: (tag: string, msg: string) => void,
+ *   progressTag?: string,
+ *   gitSpawnFn?: typeof gitSpawn,
+ *   selectLocalLensesFn?: typeof selectLocalLenses,
+ *   runAuditSuiteFn?: typeof runAuditSuite,
+ * }} args
+ * @returns {Promise<{
+ *   depth: 'light',
+ *   lenses: string[],
+ *   skipped: boolean,
+ *   materialized: object|null,
+ * }>}
+ */
+export async function runLocalLensReview({
+  baseRef,
+  headRef,
+  progress,
+  progressTag = 'CODE-REVIEW',
+  gitSpawnFn = gitSpawn,
+  selectLocalLensesFn = selectLocalLenses,
+  runAuditSuiteFn = runAuditSuite,
+}) {
+  const empty = {
+    depth: STORY_SCOPE_LENS_DEPTH,
+    lenses: [],
+    skipped: true,
+    materialized: null,
+  };
+  let lenses;
+  try {
+    const changedFiles = enumerateChangedFiles({
+      baseRef,
+      headRef,
+      gitSpawnFn,
+    });
+    lenses = selectLocalLensesFn({ changedFiles });
+    if (lenses.length === 0) {
+      progress(
+        progressTag,
+        'No local lens matched the Story diff — skipping the lens pass.',
+      );
+      return empty;
+    }
+    const materialized = await runAuditSuiteFn({ auditWorkflows: lenses });
+    progress(
+      progressTag,
+      `Ran ${lenses.length} local lens(es) at ${STORY_SCOPE_LENS_DEPTH} depth: ${lenses.join(', ')}.`,
+    );
+    return {
+      depth: STORY_SCOPE_LENS_DEPTH,
+      lenses,
+      skipped: false,
+      materialized,
+    };
+  } catch (err) {
+    // The lens pass is advisory: a git or materialization failure must not
+    // fail the close. Log and degrade to a skipped envelope.
+    progress(
+      progressTag,
+      `⚠️ local lens pass failed (continuing without it): ${err?.message ?? err}`,
+    );
+    return empty;
+  }
+}
+
 /**
  * Collect the extra fields for the code-review-critical blocked envelope.
  * Pure; used by `runStoryCodeReview` to populate the `extra` argument of
@@ -92,8 +223,13 @@ function buildCodeReviewBlockedExtra({ storyId, reviewResult }) {
  *   progressTag?: string,
  *   planningRisk?: { overallLevel?: ('low'|'medium'|'high'), axes?: Array<{ axis?: string, level?: string }> }|null,
  *   runCodeReviewFn?: typeof runCodeReview,
+ *   runLocalLensReviewFn?: typeof runLocalLensReview,
  * }} args
- * @returns {Promise<object>} Raw result envelope from `runCodeReview`.
+ * @returns {Promise<object>} Raw result envelope from `runCodeReview`, augmented
+ *   with a `localLensReview` field carrying the Story-scope local-lens pass
+ *   outcome (Epic #4405, Story #4409). Both close entry points reach the lens
+ *   pass through this single spine, so it runs on the Epic-attached and
+ *   standalone paths alike and always inside the close subprocess.
  */
 export async function runStoryReviewCore({
   storyId,
@@ -105,6 +241,7 @@ export async function runStoryReviewCore({
   progressTag = 'CODE-REVIEW',
   planningRisk = null,
   runCodeReviewFn = runCodeReview,
+  runLocalLensReviewFn = runLocalLensReview,
 }) {
   const storyIdNum = Number(storyId);
   const opts = {
@@ -127,7 +264,21 @@ export async function runStoryReviewCore({
   if (planningRisk != null) {
     opts.planningRisk = planningRisk;
   }
-  return runCodeReviewFn(opts);
+
+  // Shift-left local-lens pass (Epic #4405). Runs matched local lenses at
+  // `light` depth against the actual Story diff, inside this close-subprocess
+  // spine so the maker never grades its own work. Advisory — it never blocks
+  // the close and its outcome rides on the returned envelope for downstream
+  // consumers.
+  const localLensReview = await runLocalLensReviewFn({
+    baseRef,
+    headRef,
+    progress,
+    progressTag,
+  });
+
+  const result = await runCodeReviewFn(opts);
+  return { ...result, localLensReview };
 }
 
 /**
@@ -155,8 +306,12 @@ export async function runStoryReviewCore({
  *   progress: (tag: string, msg: string) => void,
  *   planningRisk?: { overallLevel?: ('low'|'medium'|'high'), axes?: Array<{ axis?: string, level?: string }> }|null,
  *   runCodeReviewFn?: typeof runCodeReview,
+ *   runLocalLensReviewFn?: typeof runLocalLensReview,
  * }} args
- * @returns {Promise<{ blocked: object|null }>}
+ * @returns {Promise<{ blocked: object|null, localLensReview?: object }>}
+ *   `localLensReview` carries the Story-scope local-lens pass outcome
+ *   (Epic #4405, Story #4409) when the review completed; it is absent only when
+ *   the whole review phase threw (advisory failure).
  */
 export async function runStoryCodeReview(args) {
   const {
@@ -168,6 +323,7 @@ export async function runStoryCodeReview(args) {
     progress,
     planningRisk = null,
     runCodeReviewFn = runCodeReview,
+    runLocalLensReviewFn = runLocalLensReview,
   } = args;
 
   const storyIdNum = Number(storyId);
@@ -186,6 +342,7 @@ export async function runStoryCodeReview(args) {
       progress,
       planningRisk,
       runCodeReviewFn,
+      runLocalLensReviewFn,
     });
   } catch (err) {
     // Adapter / wiring failure — log and proceed. The review is advisory
@@ -197,6 +354,8 @@ export async function runStoryCodeReview(args) {
     return { blocked: null };
   }
 
+  const localLensReview = reviewResult?.localLensReview;
+
   if (reviewResult?.halted) {
     const blocked = await emitBlockedCloseResult({
       storyId: storyIdNum,
@@ -208,7 +367,7 @@ export async function runStoryCodeReview(args) {
       blockedMessage: `Story #${storyIdNum} blocked: code-review reported ${reviewResult.severity.critical} critical blocker(s).`,
       logger: Logger,
     });
-    return { blocked };
+    return { blocked, localLensReview };
   }
 
   const counts = reviewResult?.severity ?? {};
@@ -216,5 +375,5 @@ export async function runStoryCodeReview(args) {
     'CODE-REVIEW',
     `Review complete — high=${counts.high ?? 0} medium=${counts.medium ?? 0} suggestion=${counts.suggestion ?? 0} (posted=${reviewResult?.posted ?? false}).`,
   );
-  return { blocked: null };
+  return { blocked: null, localLensReview };
 }

package/.agents/scripts/lib/orchestration/story-close/pre-merge-validation.js

@@ -133,7 +133,14 @@ export async function runPreMergeGates({
   // `buildDefaultGates` reads the canonical resolved config directly:
   // gate commands resolve from `project.commands` and the CRAP toggle
   // from `delivery.quality.gates.crap.enabled`.
-  const gates = buildDefaultGates({ config, epicBranch });
+  // Probe the coverage script from the gate execution directory (the Story
+  // worktree when present) so coverage-capture is only registered when the
+  // consumer ships `test:coverage` (#4473).
+  const gates = buildDefaultGates({
+    config,
+    epicBranch,
+    cwd: worktreePath || cwd,
+  });
   const gateCount = Array.isArray(gates) ? gates.length : 0;
   // Story #2250 — emit `close-validate.start` only when both an epicId
   // and a storyId are present; the schema requires both, and unit