mandrel 1.58.0 → 1.60.0

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

@@ -0,0 +1,325 @@
+/**
+ * close-validation/runner.js — The `runCloseValidation` orchestrator.
+ *
+ * Runs typecheck, lint, test, format check, and maintainability/coverage/
+ * CRAP regression checks before the story merge so drift is caught in the
+ * worktree rather than at pre-push time on the Epic branch. All gates
+ * inherit stdio so the operator sees the raw output; the returned summary
+ * surfaces actionable hints on failure.
+ */
+
+import {
+  recordPass as defaultRecordPass,
+  shouldSkip as defaultShouldSkip,
+  hashCommandConfig,
+} from '../validation-evidence.js';
+import {
+  isFormatterEligible,
+  listChangedFilesForFormatGate,
+} from './commands.js';
+import { DEFAULT_GATES, partitionGates } from './gates.js';
+import { defaultGateRunner } from './process.js';
+import { defaultGetHeadSha } from './projections/head-sha.js';
+
+/** @typedef {import('./gates.js').Gate} Gate */
+
+function applyChangedFileScope({ gate, spawnCwd, log }) {
+  if (!gate.changedFileScope) {
+    return { gate, cmd: gate.cmd, args: gate.args, skip: false };
+  }
+  const changedFiles = listChangedFilesForFormatGate({
+    cwd: spawnCwd,
+    baseRef: gate.changedFileScope.baseRef,
+  });
+  // Filter to the formatter-eligible subset before deciding to skip. A
+  // non-empty diff that contains zero formatter-eligible files (e.g. a
+  // docs-only Story) must take the skip path, not invoke biome with only
+  // ineligible paths — biome reports "No files were processed" and exits 1
+  // in that case (Story #3410).
+  const eligibleFiles = changedFiles.filter(isFormatterEligible);
+  if (eligibleFiles.length === 0) {
+    log(
+      `[close-validation] ⏭ ${gate.name} skipped (no formatter-eligible changed files)`,
+    );
+    return { gate, cmd: gate.cmd, args: gate.args, skip: true };
+  }
+  const args =
+    gate.args[gate.args.length - 1] === '.'
+      ? gate.args.slice(0, -1)
+      : gate.args;
+  log(
+    `[close-validation] ↳ ${gate.name} scoped to ${eligibleFiles.length} formatter-eligible changed file(s) from ${gate.changedFileScope.baseRef}...HEAD`,
+  );
+  return {
+    gate,
+    cmd: gate.cmd,
+    args: [...args, ...eligibleFiles],
+    skip: false,
+  };
+}
+
+/**
+ * Run every gate sequentially. Stops collecting after the first failure but
+ * still returns a summary so the caller decides how to surface the result.
+ *
+ * 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.
+ *
+ * Evidence-aware: when both `storyId` and `epicId` are provided 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.
+ *
+ * `onGateStart` is invoked immediately before each gate's runner spawn.
+ * story-close uses it to drive `phaseTimer.mark(...)` for per-gate
+ * wall-clock telemetry. Errors thrown from the hook propagate.
+ *
+ * @param {{
+ *   cwd: string,
+ *   worktreePath?: string,
+ *   gates?: Gate[],
+ *   runner?: (cmd: string, args: string[], opts: { cwd: string, signal?: AbortSignal, gateName?: string, log?: (m: string) => void }) => Promise<{ status: number }> | { status: number },
+ *   log?: (m: string) => void,
+ *   onGateStart?: (gate: Gate) => void,
+ *   storyId?: number|null,
+ *   epicId?: number|null,
+ *   useEvidence?: boolean,
+ *   evidenceClock?: () => number,
+ *   getHeadSha?: (cwd: string) => string|null,
+ *   recordPass?: typeof defaultRecordPass,
+ *   shouldSkip?: typeof defaultShouldSkip,
+ * }} opts
+ * @returns {{ ok: boolean, failed: Array<{ gate: Gate, status: number, cwd: string }>, skipped: Array<{ gate: Gate, reason: string }> }}
+ */
+export async function runCloseValidation({
+  cwd,
+  worktreePath,
+  gates = DEFAULT_GATES,
+  runner = defaultGateRunner,
+  log = () => {},
+  onGateStart,
+  storyId = null,
+  epicId = null,
+  useEvidence = true,
+  evidenceClock = () => Date.now(),
+  getHeadSha = (resolvedCwd) => defaultGetHeadSha(resolvedCwd),
+  recordPass = defaultRecordPass,
+  shouldSkip = defaultShouldSkip,
+} = {}) {
+  const failed = [];
+  const skipped = [];
+  const evidenceActive = useEvidence && storyId != null && epicId != null;
+  // Evidence keys against the main checkout's HEAD because the per-Epic
+  // 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;
+  const headSha = evidenceActive ? getHeadSha(spawnCwd) : null;
+
+  // Helper closures so the parallel and serial passes share evidence
+  // bookkeeping bit-for-bit.
+
+  /** Returns a `{ skip: true }` verdict when evidence makes the gate redundant. */
+  const evidenceVerdict = (gate, configHash) => {
+    if (!(evidenceActive && headSha)) return { skip: false };
+    const verdict = shouldSkip(
+      {
+        storyId,
+        gateName: gate.name,
+        currentSha: headSha,
+        configHash,
+        inputFingerprint: gate.inputFingerprint ?? null,
+      },
+      { cwd, epicId },
+    );
+    if (verdict.skip) {
+      const tsHint = verdict.record?.timestamp
+        ? ` recorded ${verdict.record.timestamp}`
+        : '';
+      log(
+        `[close-validation] ⏭ ${gate.name} skipped (${verdict.reason}: SHA=${headSha.slice(0, 7)}${tsHint})`,
+      );
+    }
+    return verdict;
+  };
+
+  const recordIfActive = (gate, configHash, durationMs) => {
+    if (!(evidenceActive && headSha)) return;
+    try {
+      recordPass(
+        {
+          storyId,
+          gateName: gate.name,
+          sha: headSha,
+          configHash,
+          exitCode: 0,
+          durationMs,
+          inputFingerprint: gate.inputFingerprint ?? null,
+        },
+        { cwd, epicId },
+      );
+    } catch (err) {
+      log(
+        `[close-validation]   ⚠ failed to record evidence for ${gate.name}: ${err?.message ?? err}`,
+      );
+    }
+  };
+
+  /**
+   * Run a single gate. When `gate.run` is a function the gate executes
+   * **in process** (Story #1973 / Task #1984 — per-kind baseline gates
+   * removed their `child_process.spawn(node check-<kind>.js)` arm and
+   * call `compare(head, base)` directly). The `run` callable receives
+   * the same `(cmd, args, opts)` argv shape as `runner` so it slots into
+   * the existing contract without churn at the runner boundary.
+   * Otherwise the supplied `runner` is used (default: spawn).
+   *
+   * @returns {Promise<{ status: number }>}
+   */
+  const dispatchGate = async (gate, signal) => {
+    log(
+      `[close-validation] ▶ ${gate.name}${worktreePath ? ` (cwd=${worktreePath})` : ''}`,
+    );
+    if (typeof onGateStart === 'function') onGateStart(gate);
+    const dispatcher = typeof gate.run === 'function' ? gate.run : runner;
+    const result = await dispatcher(gate.cmd, gate.args, {
+      cwd: spawnCwd,
+      gateName: gate.name,
+      log,
+      signal,
+      ...(gate.env ? { env: gate.env } : {}),
+    });
+    return { status: result?.status ?? 1 };
+  };
+
+  const { independent, serial } = partitionGates(gates);
+
+  // ── Phase 1: independent gates in parallel ──────────────────────────
+  // First non-zero exit pins `firstFailure` and aborts every in-flight
+  // sibling via SIGTERM. Other gates' results are still awaited (so we
+  // never leak children) but their non-zero status is intentionally
+  // dropped: only one error surfaces.
+  const ac = new AbortController();
+  let firstIndepFailure = null;
+
+  const indepTasks = independent.map(async (gate) => {
+    let execution;
+    try {
+      execution = applyChangedFileScope({ gate, spawnCwd, log });
+    } catch (err) {
+      if (!firstIndepFailure) {
+        firstIndepFailure = { gate, status: 1, cwd: spawnCwd };
+        log(
+          `[close-validation] ✖ ${gate.name} failed to resolve changed-file scope: ${err?.message ?? err}`,
+        );
+        ac.abort();
+      }
+      return;
+    }
+    if (execution.skip) {
+      skipped.push({ gate, reason: 'no-changed-files' });
+      return;
+    }
+    const configHash = hashCommandConfig({
+      cmd: execution.cmd,
+      args: execution.args,
+      cwd: spawnCwd,
+    });
+    const verdict = evidenceVerdict(gate, configHash);
+    if (verdict.skip) {
+      skipped.push({ gate, reason: verdict.reason });
+      return;
+    }
+    const startedAt = evidenceActive ? evidenceClock() : 0;
+    let result;
+    try {
+      result = await dispatchGate(
+        { ...gate, cmd: execution.cmd, args: execution.args },
+        ac.signal,
+      );
+    } catch (err) {
+      result = { status: 1, error: err };
+    }
+    if (result.status !== 0) {
+      if (!firstIndepFailure) {
+        firstIndepFailure = { gate, status: result.status, cwd: spawnCwd };
+        ac.abort();
+      }
+      return;
+    }
+    log(`[close-validation] ✓ ${gate.name}`);
+    recordIfActive(
+      gate,
+      configHash,
+      evidenceActive ? evidenceClock() - startedAt : 0,
+    );
+  });
+
+  await Promise.all(indepTasks);
+
+  if (firstIndepFailure) {
+    failed.push(firstIndepFailure);
+    log(
+      `[close-validation] ✖ ${firstIndepFailure.gate.name} failed (exit ${firstIndepFailure.status}) in ${spawnCwd}`,
+    );
+    if (firstIndepFailure.gate.hint) {
+      log(`[close-validation]   hint: ${firstIndepFailure.gate.hint}`);
+    }
+    return { ok: false, failed, skipped };
+  }
+
+  // ── Phase 2: serial gates in declared order ─────────────────────────
+  for (const gate of serial) {
+    let execution;
+    try {
+      execution = applyChangedFileScope({ gate, spawnCwd, log });
+    } catch (err) {
+      failed.push({ gate, status: 1, cwd: spawnCwd });
+      log(
+        `[close-validation] ✖ ${gate.name} failed to resolve changed-file scope: ${err?.message ?? err}`,
+      );
+      if (gate.hint) log(`[close-validation]   hint: ${gate.hint}`);
+      break;
+    }
+    if (execution.skip) {
+      skipped.push({ gate, reason: 'no-changed-files' });
+      continue;
+    }
+    const configHash = hashCommandConfig({
+      cmd: execution.cmd,
+      args: execution.args,
+      cwd: spawnCwd,
+    });
+    const verdict = evidenceVerdict(gate, configHash);
+    if (verdict.skip) {
+      skipped.push({ gate, reason: verdict.reason });
+      continue;
+    }
+    const startedAt = evidenceActive ? evidenceClock() : 0;
+    const result = await dispatchGate({
+      ...gate,
+      cmd: execution.cmd,
+      args: execution.args,
+    });
+    if (result.status !== 0) {
+      failed.push({ gate, status: result.status, cwd: spawnCwd });
+      log(
+        `[close-validation] ✖ ${gate.name} failed (exit ${result.status}) in ${spawnCwd}`,
+      );
+      if (gate.hint) log(`[close-validation]   hint: ${gate.hint}`);
+      break;
+    }
+    log(`[close-validation] ✓ ${gate.name}`);
+    recordIfActive(
+      gate,
+      configHash,
+      evidenceActive ? evidenceClock() - startedAt : 0,
+    );
+  }
+
+  return { ok: failed.length === 0, failed, skipped };
+}

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

@@ -0,0 +1,70 @@
+/**
+ * close-validation/telemetry.js — gh-spawn telemetry emitter.
+ */
+
+import { writeFile as defaultWriteFile } from 'node:fs/promises';
+import { storyArtifactPath } from '../config/temp-paths.js';
+import { getSpawnCount as defaultGetSpawnCount } from '../gh-exec.js';
+
+/**
+ * Throw-away ghSpawnCount emitter (Story #1795 / Epic #1788).
+ *
+ * Writes the current `gh-exec` spawn counter to
+ * `temp/epic-<eid>/stories/story-<sid>/gh-spawn-count.json` so the
+ * `analyze-execution.js` child process can read it and emit a
+ * `ghSpawnCount` field on the `story-perf-summary` payload. The Story-
+ * close orchestrator calls this inside `runPostMergeClose` right before
+ * the perf-summary phase, capturing every `gh` invocation from preflight
+ * through the merge in one counter snapshot.
+ *
+ * @param {object} opts
+ * @param {number|string} opts.epicId
+ * @param {number|string} opts.storyId
+ * @param {object} [opts.config] - Resolved config bag so `tempRoot`
+ *   resolution honours the consumer's configured path.
+ * @param {() => number} [opts.getSpawnCountFn=defaultGetSpawnCount] - Test seam.
+ * @param {typeof defaultWriteFile} [opts.writeFileFn=defaultWriteFile] - Test seam.
+ * @param {{ warn?: (s: string) => void }} [opts.logger] - Best-effort
+ *   failure-path logger; never throws.
+ * @returns {Promise<{ status: 'ok'|'failed', path?: string, ghSpawnCount?: number, reason?: string }>}
+ */
+export async function emitGhSpawnCount({
+  epicId,
+  storyId,
+  config,
+  getSpawnCountFn = defaultGetSpawnCount,
+  writeFileFn = defaultWriteFile,
+  logger,
+} = {}) {
+  const eid = Number(epicId);
+  const sid = Number(storyId);
+  if (!Number.isInteger(eid) || eid < 1 || !Number.isInteger(sid) || sid < 1) {
+    return { status: 'failed', reason: 'invalid-ids' };
+  }
+  let ghSpawnCount;
+  try {
+    ghSpawnCount = getSpawnCountFn();
+  } catch (err) {
+    logger?.warn?.(
+      `[close-validation] gh-spawn-count read failed: ${err?.message ?? err}`,
+    );
+    return { status: 'failed', reason: 'counter-read-failed' };
+  }
+  const targetPath = storyArtifactPath(eid, sid, 'gh-spawn-count.json', config);
+  const payload = {
+    kind: 'gh-spawn-count',
+    epicId: eid,
+    storyId: sid,
+    ghSpawnCount,
+    capturedAt: new Date().toISOString(),
+  };
+  try {
+    await writeFileFn(targetPath, JSON.stringify(payload, null, 2));
+    return { status: 'ok', path: targetPath, ghSpawnCount };
+  } catch (err) {
+    logger?.warn?.(
+      `[close-validation] gh-spawn-count emit failed: ${err?.message ?? err}`,
+    );
+    return { status: 'failed', reason: 'write-failed' };
+  }
+}

package/.agents/scripts/lib/codebase-snapshot.js

@@ -1,7 +1,7 @@
 /**
  * codebase-snapshot.js — Bounded structural view of the consumer repo.
  *
- * Story #2634 (sibling to #2635 spec-freshness). `/epic-plan` Phase 7
+ * Story #2634 (sibling to #2635 spec-freshness). `/plan` Phase 7
  * authors PRD + Tech Spec from documentation alone — `architecture.md`,
  * `data-dictionary.md`, `decisions.md`, `patterns.md`. When those docs
  * drift from the real source tree, the Architect persona cites modules

package/.agents/scripts/lib/config/explain.js

@@ -113,7 +113,7 @@ const KEY_MEANINGS = Object.freeze({
 
   // planning.*
   'planning.maxTickets':
-    'Upper bound on tickets a single /epic-plan run may create.',
+    'Upper bound on tickets a single /plan run may create.',
   'planning.context.maxBytes':
     'Byte budget for the planning-context payload before summary mode kicks in.',
   'planning.context.summaryMode':

package/.agents/scripts/lib/config/quality.js

@@ -121,7 +121,7 @@ export const MAINTAINABILITY_GATE_DEFAULTS = Object.freeze({
  * --write` autofix spawn. The SIGKILL → exit 124 mapping mirrors
  * `gates.coverage.timeoutMs` (Story #2142).
  */
-export const FORMAT_AUTOFIX_DEFAULTS = Object.freeze({
+const FORMAT_AUTOFIX_DEFAULTS = Object.freeze({
   timeoutMs: 60_000,
 });
 
@@ -259,7 +259,7 @@ export function resolveMaintainabilityCrap(
  * `targetDirs` + a scalar `tolerance` (when set) + scoping inherited
  * from `gateScoping`.
  */
-export function resolveMaintainabilityQuality(userBlock, gateScoping) {
+function resolveMaintainabilityQuality(userBlock, gateScoping) {
   const defaults = MAINTAINABILITY_GATE_DEFAULTS;
   const scoping = {
     defaultScope: gateScoping?.scope ?? DEFAULT_GATE_SCOPING.scope,
@@ -321,7 +321,7 @@ function resolvePositiveIntegerMs(value, defaultMs) {
  */
 const FORMAT_AUTOFIX_KEYS = new Set(['timeoutMs']);
 
-export function resolveFormatAutofix(userBlock) {
+function resolveFormatAutofix(userBlock) {
   const defaults = FORMAT_AUTOFIX_DEFAULTS;
   if (userBlock == null || typeof userBlock !== 'object') {
     return { timeoutMs: defaults.timeoutMs };
@@ -336,7 +336,7 @@ export function resolveFormatAutofix(userBlock) {
 }
 
 /** Resolve the coverage gate. Owns `coveragePath` and `timeoutMs`. */
-export function resolveCoverageGate(userBlock) {
+function resolveCoverageGate(userBlock) {
   const defaults = COVERAGE_GATE_DEFAULTS;
   if (userBlock == null || typeof userBlock !== 'object') {
     return {
@@ -402,7 +402,7 @@ export function resolveCodingGuardrails(userBlock) {
   };
 }
 
-export const AUTO_REFRESH_DEFAULTS = Object.freeze({
+const AUTO_REFRESH_DEFAULTS = Object.freeze({
   enabled: true,
   miDropCap: 1.5,
   crapJumpCap: 5,
@@ -411,7 +411,7 @@ export const AUTO_REFRESH_DEFAULTS = Object.freeze({
 
 const AUTO_REFRESH_KEYS = new Set(Object.keys(AUTO_REFRESH_DEFAULTS));
 
-export function resolveAutoRefresh(userBlock) {
+function resolveAutoRefresh(userBlock) {
   const defaults = AUTO_REFRESH_DEFAULTS;
   if (userBlock == null || typeof userBlock !== 'object') {
     return {

package/.agents/scripts/lib/config/runners.js

@@ -29,7 +29,7 @@ export const DEFAULT_DECOMPOSER = Object.freeze({
  * host has adequate parallel-agent quota, operators should raise
  * `delivery.deliverRunner.concurrencyCap` — wall-clock time falls
  * proportionally to the extra concurrency. The safe default is a tuning
- * knob, not a performance ceiling. See `epic-deliver.md` § Phase 2b and
+ * knob, not a performance ceiling. See `helpers/deliver-epic.md` § Phase 2b and
  * `agentrc-reference.json` `delivery.deliverRunner.concurrencyCap` for details.
  *
  * **`verifyConcurrencyCap`** (Epic #3019 Tech Spec §1.4 / Story #3024) is a
@@ -44,7 +44,7 @@ const DEFAULT_DELIVER_RUNNER = Object.freeze({
 });
 
 /**
- * Default auto-fix loop ceilings for /epic-deliver Phase 4 (epic-audit)
+ * Default auto-fix loop ceilings for /deliver Phase 4 (epic-audit)
  * and Phase 5 (code-review). Operators override via
  * `delivery.epicAudit.*` and `delivery.codeReview.*` in `.agentrc.json`
  * (Story #2611, Epic #2586).

package/.agents/scripts/lib/config/runtime.js

@@ -77,7 +77,7 @@ export function resolveWorkingPath({
 
 /**
  * One-shot environment-aware runtime resolution. Returns the trio of runtime
- * signals consumed across `/epic-deliver`: whether worktree isolation is on
+ * signals consumed across `/deliver`: whether worktree isolation is on
  * for this process, the session id for claim labels, and whether we're in a
  * Claude Code web session. Each signal also records its **source** so the
  * `story-init` startup log can name why the value is what it is.

package/.agents/scripts/lib/config/temp-paths.js

@@ -44,7 +44,7 @@
  * parent of `git rev-parse --git-common-dir`) rather than `process.cwd()`.
  * Without this, a story child that `cd`s into `.worktrees/story-<id>/` before
  * calling `story-phase.js` would append `story.heartbeat` records to
- * `<worktree>/temp/epic-N/lifecycle.ndjson`, while the `/epic-deliver` host
+ * `<worktree>/temp/epic-N/lifecycle.ndjson`, while the `/deliver` host
  * (running from the main checkout) reads the main-checkout copy — so the
  * idle-watchdog never sees heartbeats and the Epic-lease guard silently
  * reclaims live foreign claims (the audit-#3513 bug class). Anchoring the
@@ -335,7 +335,7 @@ export const epicPerfReportPath = (eid, config) =>
 
 /**
  * `temp/epic-<eid>/epic-perf-report.json` — canonical JSON snapshot of
- * the `epic-perf-report` payload persisted at /epic-deliver close
+ * the `epic-perf-report` payload persisted at /deliver close
  * (Epic #3019 / Story #3029 / Task #3040). When present alongside the
  * `epic-perf-report` structured comment, the report is discoverable
  * from the file system without round-tripping the ticketing provider,

package/.agents/scripts/lib/config-resolver.js

@@ -24,7 +24,6 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { getCiDelivery } from './config/ci.js';
 import { getCommands } from './config/commands.js';
 import { getGitHub } from './config/github.js';
@@ -34,6 +33,7 @@ import { validateOrchestrationConfig } from './config/validate-orchestration.js'
 import { getWorktreeIsolation } from './config/worktree-isolation.js';
 import { getAgentrcValidator } from './config-schema.js';
 import { loadEnv } from './env-loader.js';
+import { PROJECT_ROOT } from './project-root.js';
 
 export { getAcceptanceEval } from './config/acceptance-eval.js';
 export { BASELINES_DEFAULTS, getBaselines } from './config/baselines.js';
@@ -64,10 +64,7 @@ export {
 export { resolveListValue } from './config/shared.js';
 export { validateOrchestrationConfig } from './config/validate-orchestration.js';
 export { WORKTREE_ISOLATION_DEFAULTS } from './config/worktree-isolation.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// scripts/lib/ → scripts/ → .agents/ → project root
-export const PROJECT_ROOT = path.resolve(__dirname, '../../..');
+export { PROJECT_ROOT } from './project-root.js';
 
 // Cache keyed by absolute root path so callers passing different cwds
 // (e.g. per-worktree) each get their own resolved config.

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

@@ -203,7 +203,7 @@ const MERGE_WATCH_SCHEMA = {
 };
 
 /**
- * `delivery.epicAudit` — bounded-retry knobs for /epic-deliver Phase 4
+ * `delivery.epicAudit` — bounded-retry knobs for /deliver Phase 4
  * (epic-audit). `maxFixAttempts` caps how many times the auto-fix loop
  * retries a single finding (Story #2611, Epic #2586). `maxFixScopeFiles`
  * caps how many files a single auto-fix may touch before escalating to
@@ -237,7 +237,7 @@ const CI_DELIVERY_SCHEMA = {
 // Story #2899 (Epic #2880) — `delivery.preflight.*` thresholds consumed
 // by `epic-deliver-preflight.js`. When any value is exceeded the CLI
 // surfaces a breach in its envelope and the workflow flips the Epic to
-// `agent::blocked` (see /epic-deliver Phase 1 prelude).
+// `agent::blocked` (see /deliver Phase 1 prelude).
 const PREFLIGHT_SCHEMA = {
   type: 'object',
   properties: {

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

@@ -102,7 +102,7 @@ export const QUALITY_SCHEMA = {
 
 /**
  * `delivery.codeReview` — sibling to `delivery.epicAudit`. Same bounded
- * retry + scope cap, applied to /epic-deliver Phase 5 (code-review).
+ * retry + scope cap, applied to /deliver Phase 5 (code-review).
  */
 export const CODE_REVIEW_SCHEMA = {
   type: 'object',

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

@@ -205,7 +205,7 @@ const GITHUB_SCHEMA = {
 };
 
 // ---------------------------------------------------------------------------
-// planning.* — inputs to /epic-plan
+// planning.* — inputs to /plan
 // ---------------------------------------------------------------------------
 
 /**
@@ -224,7 +224,7 @@ const PLANNING_CONTEXT_SCHEMA = {
 
 /**
  * Story #2634 — `planning.codebaseSnapshot` controls the structural
- * view of the consumer repo threaded into `/epic-plan` Phase 7 spec
+ * view of the consumer repo threaded into `/plan` Phase 7 spec
  * authoring. Absent / partial entries resolve to defaults inside
  * `lib/codebase-snapshot.js#resolveSnapshotConfig` — the schema only
  * enforces shape (correct enum value, well-formed glob arrays).
@@ -287,7 +287,7 @@ const PLANNING_SCHEMA = {
 };
 
 // ---------------------------------------------------------------------------
-// delivery.* — /epic-deliver + story-deliver consume. The full block of
+// delivery.* — /deliver + story-deliver consume. The full block of
 // per-key sub-schemas lives in `config-settings-schema-delivery.js` (refs
 // #3457); DELIVERY_SCHEMA is imported above and referenced unchanged below.
 // ---------------------------------------------------------------------------