mandrel 1.94.0 → 2.1.0

package/.agents/scripts/lib/checks/story-init-not-backgrounded.js

@@ -1,17 +1,17 @@
 /**
  * story-init-not-backgrounded — refuse-and-print check.
  *
- * Detects orchestration call sites that invoke `story-init.js` via the
- * Bash tool's `run_in_background: true` mode (with subsequent `Monitor`
+ * Detects orchestration call sites that invoke `single-story-init.js` via
+ * the Bash tool's `run_in_background: true` mode (with subsequent `Monitor`
  * waiting on completion) instead of a synchronous Bash call with a
  * 10-minute timeout. This guards the failure mode where `Monitor`'s wait
  * is not equivalent to script exit — a sub-agent that exits during a
- * Monitor wait kills `story-init.js` mid-batch, leaving a half-initialized
- * worktree and a failed wave aggregator.
+ * Monitor wait kills `single-story-init.js` mid-run, leaving a
+ * half-initialized worktree.
  *
- * Scope: 'epic-deliver', 'story-close', 'retro'. The check runs at every
- * preflight surface that has the opportunity to invoke story-init —
- * primarily `epic-deliver`'s wave loop — and surfaces as a retro audit
+ * Scope: 'story-close', 'retro'. The check runs at every
+ * preflight surface that has the opportunity to invoke Story init —
+ * primarily `/deliver`'s init step — and surfaces as a retro audit
  * signal if the failure mode resurfaces during a sprint.
  *
  * The check is `refuse-and-print`. Auto-rewriting an orchestration call
@@ -20,7 +20,8 @@
  * synchronous-call replacement pattern so they can apply it deliberately.
  *
  * Implementation note: we scan `.agents/` (markdown + js) for the
- * juxtaposition of a `story-init.js` reference and a backgrounding token
+ * juxtaposition of a `story-init.js` reference (which also matches
+ * `single-story-init.js` as a suffix) and a backgrounding token
  * (`run_in_background: true`, the literal `Monitor` tool name as a
  * fan-out target, or `&` shell backgrounding) within a small line window.
  */
@@ -39,7 +40,8 @@ const WINDOW_LINES = 20;
  * - `run_in_background: true` — Bash tool's backgrounding flag.
  * - `detached: true` — child_process.spawn options that detach the
  *   subprocess from the parent's lifecycle, equivalent to backgrounding.
- * - `story-init.js &` — POSIX shell ampersand backgrounding.
+ * - `single-story-init.js &` — POSIX shell ampersand backgrounding
+ *   (the pattern matches the `story-init.js` suffix of both names).
  */
 const BACKGROUND_TOKENS = [
   /run_in_background\s*:\s*true/,
@@ -85,12 +87,12 @@ function walkSources(dir) {
 
 /**
  * For one file, return an array of `{ line, kind }` offences: every line
- * referencing `story-init.js` that has a backgrounding token in the same
- * ±WINDOW_LINES window.
+ * referencing `story-init.js` (including `single-story-init.js`) that has
+ * a backgrounding token in the same ±WINDOW_LINES window.
  *
- * The check explicitly excludes the `story-init.js` file itself and any
- * dedicated check module (this file): the source-of-truth implementation
- * legitimately mentions itself.
+ * The check explicitly excludes the `single-story-init.js` file itself and
+ * any dedicated check module (this file): the source-of-truth
+ * implementation legitimately mentions itself.
  *
  * @param {string} file
  * @param {string} src
@@ -100,12 +102,12 @@ function scanFile(file, src) {
   const offences = [];
   // Don't flag the actual story-init script, self-references, or the
   // parallel-tooling helper — the helper documents both Rule 2
-  // (run_in_background) and the story-init.js anti-pattern in adjacent
-  // bullets, which collides with the scanner's ±20-line window even
-  // though there is no real invocation in the prose.
+  // (run_in_background) and the story-init backgrounding anti-pattern in
+  // adjacent bullets, which collides with the scanner's ±20-line window
+  // even though there is no real invocation in the prose.
   const basename = path.basename(file);
   if (
-    basename === 'story-init.js' ||
+    basename === 'single-story-init.js' ||
     basename === 'story-init-not-backgrounded.js' ||
     basename === 'story-init-not-backgrounded.test.js' ||
     basename === 'parallel-tooling.md'
@@ -129,13 +131,13 @@ function scanFile(file, src) {
 }
 
 const FIX_COMMAND = [
-  '# Invoke story-init.js synchronously with a 10-minute timeout. The',
-  '# script is idempotent on partial state, so re-running after a',
+  '# Invoke single-story-init.js synchronously with a 10-minute timeout.',
+  '# The script is idempotent on partial state, so re-running after a',
   '# half-initialized worktree is safe — but blocking on the Bash call',
   '# is what prevents the half-init state in the first place.',
   '#',
   '# Replacement pattern (Bash tool):',
-  '#   Bash(timeout: 600000, command: "node .agents/scripts/story-init.js --story <id>")',
+  '#   Bash(timeout: 600000, command: "node .agents/scripts/single-story-init.js --story <id>")',
   '#',
   '# Do NOT use:',
   '#   Bash(run_in_background: true, ...) + Monitor(...)',
@@ -144,7 +146,7 @@ const FIX_COMMAND = [
 export default {
   id: 'story-init-not-backgrounded',
   severity: 'blocker',
-  scope: ['epic-deliver', 'story-close', 'retro'],
+  scope: ['story-close', 'retro'],
   autoCorrect: 'refuse-and-print',
 
   detect(state) {
@@ -176,8 +178,8 @@ export default {
     return {
       id: 'story-init-not-backgrounded',
       severity: 'blocker',
-      scope: state?.scope ?? 'epic-deliver',
-      summary: `${offences.length} orchestration call site(s) invoke story-init.js with Monitor backgrounding`,
+      scope: state?.scope ?? 'story-close',
+      summary: `${offences.length} orchestration call site(s) invoke single-story-init.js with Monitor backgrounding`,
       detail,
       fixCommand: FIX_COMMAND,
       autoCorrectable: false,

package/.agents/scripts/lib/checks/subagent-agent-tool-required.js

@@ -22,8 +22,7 @@
  * catches an over-deep fan-out. The self-healing surface is preserved — it is
  * re-scoped, not removed.
  *
- * Scope: 'epic-deliver', 'retro'. Surfaces as a blocker at preflight for
- * `epic-deliver` (the fan-out site) and as audit signal at retro.
+ * Scope: 'retro'. Surfaces as audit signal at retro.
  *
  * The check is `refuse-and-print` — auto-rewriting a workflow's declared
  * depth or tool list would silently change runtime behavior in ways the
@@ -208,7 +207,7 @@ const FIX_COMMAND = [
 export default {
   id: 'subagent-agent-tool-required',
   severity: 'blocker',
-  scope: ['epic-deliver', 'retro'],
+  scope: ['retro'],
   autoCorrect: 'refuse-and-print',
 
   detect(state) {
@@ -249,7 +248,7 @@ export default {
     return {
       id: 'subagent-agent-tool-required',
       severity: 'blocker',
-      scope: state?.scope ?? 'epic-deliver',
+      scope: state?.scope ?? 'retro',
       summary: `${offences.length} sub-agent workflow(s) declare an Agent fan-out deeper than the supported nesting ceiling (${ceiling})`,
       detail,
       fixCommand: FIX_COMMAND,

package/.agents/scripts/lib/checks/worktree-bootstrap-env.js

@@ -8,7 +8,7 @@
  * tests that read environment variables silently take a different code
  * path.
  *
- * Surface: `epic-deliver` preflight and the `/diagnose` CLI. Surfaced as a
+ * Surface: the `/diagnose` CLI. Surfaced as a
  * warning rather than a blocker — the missing file may be a deliberate
  * choice (e.g. a worktree that doesn't need MCP), but the operator should
  * see the divergence from the main checkout.
@@ -28,7 +28,7 @@ const ID = 'worktree-bootstrap-env';
 export default {
   id: ID,
   severity: 'warning',
-  scope: ['epic-deliver', 'diagnose'],
+  scope: ['diagnose'],
   autoCorrect: 'refuse-and-print',
   detect(state) {
     const status = state?.fs?.worktreeBootstrapStatus ?? {};

package/.agents/scripts/lib/checks/worktree-residue-biome.js

@@ -6,8 +6,8 @@
  * root `npm run lint` walks into the orphan tree, hits the nested config,
  * and fails. The close-time biome block is the canonical symptom.
  *
- * Surface: `epic-deliver` preflight, `story-close` preflight, and the
- * `/diagnose` CLI. Surfaced as a blocker so the operator clears the residue
+ * Surface: `story-close` preflight, the `/diagnose` CLI, and retro.
+ * Surfaced as a blocker so the operator clears the residue
  * with `rm -rf` before close re-runs the validation chain.
  *
  * AutoCorrect is `refuse-and-print`. Recursive deletion under `.worktrees/`
@@ -21,7 +21,7 @@ const ID = 'worktree-residue-biome';
 export default {
   id: ID,
   severity: 'blocker',
-  scope: ['epic-deliver', 'story-close', 'diagnose', 'retro'],
+  scope: ['story-close', 'diagnose', 'retro'],
   autoCorrect: 'refuse-and-print',
   detect(state) {
     const orphans = state?.fs?.worktreeBiomeOrphans ?? [];

package/.agents/scripts/lib/cli/standard-args.js

@@ -13,7 +13,6 @@
  *
  * Contract
  * --------
- *   parseStandardCliArgs(argv, schema?) → { values, positionals }
  *   parseStandardCliArgs({ argv, schema?, extras? }) → { values, positionals }
  *
  *   - `argv`    — `process.argv.slice(2)` shape; the helper does NOT strip
@@ -99,24 +98,20 @@ function camelCase(name) {
 }
 
 /**
- * Normalize the call signature. Accepts either positional
- * `(argv, schema)` (backward compat) or the object form
- * `({ argv, schema, extras })`.
+ * Validate the call signature. Only the object form
+ * `({ argv, schema, extras })` is accepted.
  *
- * @param {unknown} argvOrOpts
- * @param {unknown} maybeSchema
+ * @param {unknown} opts
  * @returns {{ argv: string[], schema: object | undefined, extras: object | undefined }}
  */
-function normaliseCallSignature(argvOrOpts, maybeSchema) {
-  if (
-    argvOrOpts !== null &&
-    typeof argvOrOpts === 'object' &&
-    !Array.isArray(argvOrOpts)
-  ) {
-    const { argv, schema, extras } = argvOrOpts;
-    return { argv: argv ?? [], schema, extras };
+function normaliseCallSignature(opts) {
+  if (opts === null || typeof opts !== 'object' || Array.isArray(opts)) {
+    throw new Error(
+      'parseStandardCliArgs: options must be a plain object ({ argv, schema?, extras? })',
+    );
   }
-  return { argv: argvOrOpts ?? [], schema: maybeSchema, extras: undefined };
+  const { argv, schema, extras } = opts;
+  return { argv: argv ?? [], schema, extras };
 }
 
 /**
@@ -313,15 +308,11 @@ function normaliseValues(raw, extras) {
  * Parse the dispatcher's shared CLI flag surface. See module docstring
  * for the full contract.
  *
- * @param {string[]|{argv?: string[], schema?: object, extras?: object}} argvOrOpts
- * @param {Record<string, { required?: boolean }>} [maybeSchema]
+ * @param {{ argv?: string[], schema?: object, extras?: object }} [opts]
  * @returns {{ values: Record<string, unknown>, positionals: string[] }}
  */
-export function parseStandardCliArgs(argvOrOpts = [], maybeSchema) {
-  const { argv, schema, extras } = normaliseCallSignature(
-    argvOrOpts,
-    maybeSchema,
-  );
+export function parseStandardCliArgs(opts = {}) {
+  const { argv, schema, extras } = normaliseCallSignature(opts);
   if (!Array.isArray(argv)) {
     throw new Error('parseStandardCliArgs: argv must be an array');
   }

package/.agents/scripts/lib/cli-args.js

@@ -40,6 +40,28 @@ function coerceBooleanFlag(value) {
   return Boolean(value);
 }
 
+/** Like coerceBooleanFlag, but preserves `undefined` (flag absent). */
+function optionalBooleanFlag(value) {
+  if (value === undefined) return undefined;
+  return coerceBooleanFlag(value);
+}
+
+/**
+ * Parse a positive-integer flag, preserving `undefined` when the flag is
+ * absent so a caller can distinguish "not supplied" (fall back to config)
+ * from an explicit value. A non-numeric or non-positive value is treated as
+ * absent rather than coerced to 0 — a `--max-wait-seconds=abc` typo must not
+ * silently become a zero-second wait.
+ *
+ * @param {unknown} value
+ * @returns {number|undefined}
+ */
+function parsePositiveInt(value) {
+  if (value === undefined || value === null) return undefined;
+  const parsed = Number.parseInt(String(value), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+
 /**
  * Standardized CLI argument parser for sprint scripts.
  * Supports options like --epic, --story, --dry-run, --skip-dashboard.
@@ -57,9 +79,12 @@ export function parseSprintArgs(args = process.argv) {
       'skip-validation': { type: 'boolean', default: false },
       'skip-sync': { type: 'boolean', default: false },
       'no-auto-merge': { type: 'boolean', default: false },
-      'no-full-scope-crap': { type: 'boolean', default: false },
-      'wait-merge': { type: 'boolean', default: false },
+      // No default — absent means "use delivery.routing.closeAndLand".
+      'wait-merge': { type: 'boolean' },
       'no-wait-merge': { type: 'boolean', default: false },
+      // Story #4543 — per-run override of `delivery.mergeWatch.maxWaitSeconds`
+      // (the merge wait's per-invocation bound). Absent means "use the config".
+      'max-wait-seconds': { type: 'string' },
       executor: { type: 'string' },
       cwd: { type: 'string' },
       'recut-of': { type: 'string' },
@@ -80,13 +105,16 @@ export function parseSprintArgs(args = process.argv) {
     skipValidation: coerceBooleanFlag(values['skip-validation']),
     skipSync: coerceBooleanFlag(values['skip-sync']),
     noAutoMerge: coerceBooleanFlag(values['no-auto-merge']),
-    noFullScopeCrap: coerceBooleanFlag(values['no-full-scope-crap']),
-    // Story #4428 — headless must-land signal for `single-story-close.js`:
-    // `--wait-merge` opts a headless run into polling to merge confirmation
-    // instead of resting at `agent::closing`; `--no-wait-merge` is the
-    // explicit opt-out (see `single-story-close/phases/options.js`).
-    waitForMerge: coerceBooleanFlag(values['wait-merge']),
+    // Close-and-land: `--wait-merge` forces land-in-close; `--no-wait-merge`
+    // opts out. When neither flag is present (`undefined`),
+    // `parseCloseOptions` applies `delivery.routing.closeAndLand` (default
+    // true) so attended and headless delivers share the same happy path.
+    waitForMerge: optionalBooleanFlag(values['wait-merge']),
     noWaitForMerge: coerceBooleanFlag(values['no-wait-merge']),
+    // Story #4543 — raise the merge wait's per-invocation bound for a
+    // headless caller with no host tool-invocation ceiling, so it lands in
+    // one block instead of returning `pending` at the default 300s.
+    maxWaitSeconds: parsePositiveInt(values['max-wait-seconds']),
     executor: values.executor ?? null,
     // Resolve worktree cwd from flag or env. Empty string/whitespace → null.
     cwd:
@@ -95,7 +123,9 @@ export function parseSprintArgs(args = process.argv) {
       null,
     recutOf: parseTicketId(values['recut-of']),
     // Story #4253: pre-resolved Epic linkage threaded by the /deliver
-    // fan-out so `story-init.js` can skip the per-Story `getEpic` round-trip.
+    // fan-out so `single-story-init.js` can skip redundant Epic lookups when
+    // the parent already threaded Epic context (pre-v2; field retained for
+    // CLI compatibility).
     resume: values.resume ?? false,
     restart: values.restart ?? false,
     noEvidence: values['no-evidence'] ?? false,

package/.agents/scripts/lib/close-validation/gates.js

@@ -54,22 +54,22 @@ function buildChangedFileScope(baseRef) {
  *
  * The baselines gate resolves its compare ref through `resolveScope`,
  * whose environment layer reads `BASELINE_REF`. Threading
- * `origin/<epicBranch>` here makes the gate diff head against the epic
+ * `origin/<baseBranch>` here makes the gate diff head against the epic
  * integration branch instead of the framework-default `origin/main`, so
  * drift that already landed on `main` but is outside the Story's own diff
  * does not surface as a phantom regression. The same convention
- * (`origin/<epicBranch>`) is used by the baseline-attribution and
+ * (`origin/<baseBranch>`) is used by the baseline-attribution and
  * auto-refresh paths, keeping read/compare bases aligned.
  *
  * Returns `null` when no integration branch is supplied (the gate then
  * keeps its existing default-ref / consumer-config behaviour untouched).
  *
- * @param {string|undefined|null} epicBranch
+ * @param {string|undefined|null} baseBranch
  * @returns {{ BASELINE_REF: string } | null}
  */
-function buildBaselinesGateEnv(epicBranch) {
-  if (typeof epicBranch !== 'string' || epicBranch.length === 0) return null;
-  return { BASELINE_REF: `origin/${epicBranch}` };
+function buildBaselinesGateEnv(baseBranch) {
+  if (typeof baseBranch !== 'string' || baseBranch.length === 0) return null;
+  return { BASELINE_REF: `origin/${baseBranch}` };
 }
 
 /**
@@ -146,7 +146,7 @@ function enabledBaselineKinds(config) {
  * `delivery.quality.requireBaselines: true`. Default false — a consumer that
  * enables baseline gates but has not committed baseline artifacts gets a
  * clean skip (see `probeBaselinesGate`) rather than a deterministic first-try
- * close failure. Mirrors the `delivery.ci.requireChecks` escape hatch (#4472).
+ * close failure. Fail-closed baseline posture (#4495).
  *
  * @param {object|undefined|null} config
  * @returns {boolean}
@@ -240,11 +240,11 @@ function probeBaselinesGate({ config, cwd, presentBaselines } = {}) {
  * shared in-process runner. The unified `check-baselines` gate is now the
  * single source of truth for per-kind regression enforcement
  * (attribution-wired floor + tolerance + schema).
- * The `epicBranch` parameter threads the close run's integration branch
+ * The `baseBranch` parameter threads the close run's integration branch
  * into two gates: the `format` gate's `changedFileScope` (existing) and —
  * since Story #3890 — the `check-baselines` gate's `BASELINE_REF` env, so
  * the baselines regression compare diffs head against the epic integration
- * branch (`origin/<epicBranch>`) rather than the framework-default
+ * branch (`origin/<baseBranch>`) rather than the framework-default
  * `origin/main`. Without this, every child Story on an `epic/<id>` branch
  * re-discovered inherited main-vs-epic drift in untouched files as phantom
  * regressions and worked around it by hand-setting `BASELINE_REF`.
@@ -268,10 +268,10 @@ function probeBaselinesGate({ config, cwd, presentBaselines } = {}) {
  * none are required, the gate is skipped with a logged reason (via `log`)
  * instead of a blocking failure.
  *
- * @param {{ config?: object, epicBranch?: string, cwd?: string, packageScripts?: Record<string, string>, presentBaselines?: string[]|Set<string>, log?: (message: string) => void }} [opts]
+ * @param {{ config?: object, baseBranch?: string, cwd?: string, packageScripts?: Record<string, string>, presentBaselines?: string[]|Set<string>, log?: (message: string) => void }} [opts]
  *   `config` is the canonical resolved config (`{ project, delivery, ... }`);
  *   gate commands resolve from `project.commands` and the CRAP toggle from
- *   `delivery.quality.gates.crap.enabled`. `epicBranch` is the close run's
+ *   `delivery.quality.gates.crap.enabled`. `baseBranch` is the close run's
  *   integration branch (`epic/<id>` for Epic-attached Stories, the base
  *   branch for standalone Stories). `cwd` is where the `package.json`
  *   coverage-script probe and the `baselines/<kind>.json` presence probe
@@ -285,7 +285,7 @@ function probeBaselinesGate({ config, cwd, presentBaselines } = {}) {
  */
 export function buildDefaultGates({
   config,
-  epicBranch,
+  baseBranch,
   cwd,
   packageScripts,
   presentBaselines,
@@ -305,9 +305,9 @@ export function buildDefaultGates({
   const formatWriteString = resolveFormatWriteCommand(config);
   const formatChangedFileScope =
     formatCheckString === FORMAT_CHECK_FALLBACK
-      ? buildChangedFileScope(epicBranch)
+      ? buildChangedFileScope(baseBranch)
       : null;
-  const baselinesGateEnv = buildBaselinesGateEnv(epicBranch);
+  const baselinesGateEnv = buildBaselinesGateEnv(baseBranch);
   const baselinesDecision = probeBaselinesGate({
     config,
     cwd,
@@ -379,7 +379,7 @@ export function buildDefaultGates({
 /**
  * Default gate list resolved with no consumer config — uses the
  * `npm run typecheck` fallback for the typecheck gate. Call sites that have a
- * resolved config object in scope (e.g. `story-close.js`) should
+ * resolved config object in scope (e.g. `single-story-close.js`) should
  * prefer `buildDefaultGates({ config })` so a configured
  * `project.commands.typecheck` is honoured.
  *

package/.agents/scripts/lib/close-validation/projections/inputs.js

@@ -3,7 +3,7 @@
  * inputs.js — shared input validator for close-validation projection helpers.
  *
  * Used by `projections/maintainability.js` (and any future projection that
- * shares the same `{ cwd, epicBranch, storyBranch, baselinePath }` argument
+ * shares the same `{ cwd, baseBranch, storyBranch, baselinePath }` argument
  * shape) to collapse the inline guard cascade into a single predicate that
  * returns a typed `reason` on failure.
  *
@@ -16,7 +16,7 @@
 /**
  * @typedef {Object} ProjectionInputs
  * @property {string} [cwd]
- * @property {string} [epicBranch]
+ * @property {string} [baseBranch]
  * @property {string} [storyBranch]
  * @property {string} [baselinePath]
  */
@@ -32,7 +32,7 @@
 /**
  * @typedef {Object} ValidationFail
  * @property {false} ok
- * @property {'missing-cwd'|'missing-epic-branch'|'missing-story-branch'|'missing-baseline-path'|'no-baseline'} reason
+ * @property {'missing-cwd'|'missing-base-branch'|'missing-story-branch'|'missing-baseline-path'|'no-baseline'} reason
  */
 
 /**
@@ -40,7 +40,7 @@
  *
  * Reason branches (in order):
  *   - `missing-cwd`           — cwd is falsy
- *   - `missing-epic-branch`   — epicBranch is falsy
+ *   - `missing-base-branch`   — baseBranch is falsy
  *   - `missing-story-branch`  — storyBranch is falsy
  *   - `missing-baseline-path` — baselinePath is falsy
  *   - `no-baseline`           — loadBaseline returned null/undefined/empty
@@ -54,9 +54,9 @@
  * @returns {ValidationOk | ValidationFail}
  */
 export function validateProjectionInputs(inputs, opts = {}) {
-  const { cwd, epicBranch, storyBranch, baselinePath } = inputs ?? {};
+  const { cwd, baseBranch, storyBranch, baselinePath } = inputs ?? {};
   if (!cwd) return { ok: false, reason: 'missing-cwd' };
-  if (!epicBranch) return { ok: false, reason: 'missing-epic-branch' };
+  if (!baseBranch) return { ok: false, reason: 'missing-base-branch' };
   if (!storyBranch) return { ok: false, reason: 'missing-story-branch' };
   if (!baselinePath) return { ok: false, reason: 'missing-baseline-path' };
 
@@ -80,7 +80,7 @@ export function validateProjectionInputs(inputs, opts = {}) {
  */
 export const MISSING_ARG_REASONS = new Set([
   'missing-cwd',
-  'missing-epic-branch',
+  'missing-base-branch',
   'missing-story-branch',
   'missing-baseline-path',
 ]);

package/.agents/scripts/lib/close-validation/projections/maintainability.js

@@ -41,18 +41,18 @@ function normaliseSkipReason(reason) {
 }
 
 /**
- * Refresh `origin/<epicBranch>` so the diff range resolves even when the
+ * Refresh `origin/<baseBranch>` so the diff range resolves even when the
  * close script hasn't reached its own pull/rebase step yet. Routed through
  * the shared `(cwd, ref, windowMs)` cache so a story-init fetch in the same
  * wave satisfies the projection without re-hitting origin.
  *
  * @param {string} cwd
- * @param {string} epicBranch
+ * @param {string} baseBranch
  * @param {{ gitSpawn: typeof defaultGitSpawn }} git
  * @returns {{ ok: true } | { ok: false, detail: string }}
  */
-function refreshEpicRef(cwd, epicBranch, git) {
-  const fetchRes = cachedGitFetchSync(cwd, epicBranch, {
+function refreshEpicRef(cwd, baseBranch, git) {
+  const fetchRes = cachedGitFetchSync(cwd, baseBranch, {
     gitSpawn: git.gitSpawn,
   });
   if (fetchRes.status !== 0) {
@@ -69,13 +69,13 @@ function refreshEpicRef(cwd, epicBranch, git) {
  * the changed-files list. Normalises Windows-style backslash paths to
  * forward slashes so the baseline lookup is platform-agnostic.
  *
- * @param {{ cwd: string, epicBranch: string, storyBranch: string, git: { gitSpawn: typeof defaultGitSpawn } }} opts
+ * @param {{ cwd: string, baseBranch: string, storyBranch: string, git: { gitSpawn: typeof defaultGitSpawn } }} opts
  * @returns {{ ok: true, files: string[] } | { ok: false, detail: string }}
  */
-function diffChangedFiles({ cwd, epicBranch, storyBranch, git }) {
+function diffChangedFiles({ cwd, baseBranch, storyBranch, git }) {
   try {
     const files = diffNameOnly({
-      range: `origin/${epicBranch}...${storyBranch}`,
+      range: `origin/${baseBranch}...${storyBranch}`,
       cwd,
       gitSpawn: git.gitSpawn,
     });
@@ -190,7 +190,7 @@ function collectRegressions({
  *
  * @param {{
  *   cwd: string,
- *   epicBranch: string,
+ *   baseBranch: string,
  *   storyBranch: string,
  *   baselinePath: string,
  *   tolerance?: number,
@@ -207,7 +207,7 @@ function collectRegressions({
  */
 export function projectMaintainabilityRegressions({
   cwd,
-  epicBranch,
+  baseBranch,
   storyBranch,
   baselinePath,
   tolerance = DEFAULT_MI_TOLERANCE,
@@ -216,7 +216,7 @@ export function projectMaintainabilityRegressions({
   loadBaseline = getBaseline,
 } = {}) {
   const validation = validateProjectionInputs(
-    { cwd, epicBranch, storyBranch, baselinePath },
+    { cwd, baseBranch, storyBranch, baselinePath },
     { loadBaseline },
   );
   if (!validation.ok) {
@@ -227,7 +227,7 @@ export function projectMaintainabilityRegressions({
     };
   }
 
-  const fetchOutcome = refreshEpicRef(cwd, epicBranch, git);
+  const fetchOutcome = refreshEpicRef(cwd, baseBranch, git);
   if (!fetchOutcome.ok) {
     return {
       ok: true,
@@ -237,7 +237,7 @@ export function projectMaintainabilityRegressions({
     };
   }
 
-  const diffOutcome = diffChangedFiles({ cwd, epicBranch, storyBranch, git });
+  const diffOutcome = diffChangedFiles({ cwd, baseBranch, storyBranch, git });
   if (!diffOutcome.ok) {
     return {
       ok: true,

package/.agents/scripts/lib/close-validation/runner.js

@@ -72,21 +72,19 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
  * Worktree locality (Story #1120): when `worktreePath` is supplied, every
  * gate runner is spawned with `cwd: worktreePath` so the gate sees the
  * Story branch's post-rebase tree. Evidence reads/writes still key against
- * `cwd` (the main checkout) because the per-Epic temp tree lives under
- * the main `.git/`. Failure messages name the worktree path.
+ * `cwd` (the main checkout) because the temp tree lives under the main
+ * `.git/`. Failure messages name the worktree path.
  *
- * Evidence-aware: when `storyId` is provided alongside either `epicId` or
- * `standalone: true`, and `useEvidence !== false`, each gate consults
+ * Evidence-aware: when `storyId` is provided alongside `standalone: true`,
+ * and `useEvidence !== false`, each gate consults
  * `validation-evidence.shouldSkip()` against current HEAD + the gate's
  * command-config hash. A matching record skips the gate; a successful run
  * is recorded so the next caller in the local hot path can skip in turn.
  *
- * Standalone keyspace (Story #4250): the standalone path has no parent
- * Epic, so it passes `standalone: true` (and leaves `epicId` null) to route
- * the evidence file to the storyId-anchored
+ * Standalone keyspace (Story #4250): `standalone: true` routes the evidence
+ * file to the storyId-anchored
  * `<tempRoot>/standalone/stories/story-<id>/validation-evidence.json`
- * keyspace instead of feeding a null `epicId` into the Epic-keyed path
- * (which structurally disabled the cache before).
+ * keyspace. v2.0.0 removed the Epic tier and its Epic-keyed keyspace.
  *
  * `onGateStart` is invoked immediately before each gate's runner spawn.
  * story-close uses it to drive `phaseTimer.mark(...)` for per-gate
@@ -100,7 +98,6 @@ function applyChangedFileScope({ gate, spawnCwd, log }) {
  *   log?: (m: string) => void,
  *   onGateStart?: (gate: Gate) => void,
  *   storyId?: number|null,
- *   epicId?: number|null,
  *   standalone?: boolean,
  *   useEvidence?: boolean,
  *   evidenceClock?: () => number,
@@ -118,7 +115,6 @@ export async function runCloseValidation({
   log = () => {},
   onGateStart,
   storyId = null,
-  epicId = null,
   standalone = false,
   useEvidence = true,
   evidenceClock = () => Date.now(),
@@ -129,16 +125,12 @@ export async function runCloseValidation({
   const failed = [];
   const skipped = [];
   // Evidence is active when a Story id is present AND there is a keyspace to
-  // anchor on: either a real Epic id (Epic path) or `standalone: true`
-  // (Story #4250 — standalone storyId-anchored keyspace). A bare `epicId:
-  // null` without `standalone` keeps the cache off, as before.
-  const evidenceActive =
-    useEvidence && storyId != null && (epicId != null || standalone);
-  // The evidence-store opts: `standalone` routes to the storyId-anchored
-  // keyspace; otherwise the Epic-keyed path resolves under `epicId`.
-  const evidenceStoreOpts = { cwd, epicId, standalone };
-  // Evidence keys against the main checkout's HEAD because the per-Epic
-  // evidence file lives under the main `.git/`. Gate spawn, in contrast,
+  // anchor on (`standalone: true` — Story #4250's storyId-anchored
+  // keyspace, now the only one).
+  const evidenceActive = useEvidence && storyId != null && standalone;
+  const evidenceStoreOpts = { cwd, standalone };
+  // Evidence keys against the main checkout's HEAD because the evidence
+  // file lives under the main `.git/`. Gate spawn, in contrast,
   // runs in the worktree when one is supplied — that's the whole point of
   // Story #1120.
   const spawnCwd = worktreePath ?? cwd;