mandrel 2.0.0 → 2.1.0

package/.agents/scripts/lib/bootstrap/manifest.js

@@ -110,9 +110,14 @@ export function buildMutationManifest(ctx = {}) {
   const entries = [];
 
   // --- ide-wiring -------------------------------------------------------
-  // Claude Code / IDE integration: the system-prompt import, the
-  // UserPromptSubmit sync hook, the generated flat command surface, and the
-  // .gitignore entry that keeps the generated tree out of git.
+  // Claude Code / IDE integration: the system-prompt import, the generated
+  // flat command surface, and the .gitignore entry that keeps the
+  // generated tree out of git. (Story #4527/#4530: the UserPromptSubmit
+  // per-prompt re-sync hook entry was removed alongside the hook itself —
+  // it raced the harness's own read of the same directory and reported
+  // "0 file(s) synced" on effectively every invocation; the real sync
+  // points — `prepare`, `mandrel sync`/`update`, doctor's
+  // `commands-in-sync` — already cover every case.)
   entries.push(
     {
       phaseGroup: PHASE_GROUPS.IDE_WIRING,
@@ -122,14 +127,6 @@ export function buildMutationManifest(ctx = {}) {
         'Wire the @.agents/instructions.md system-prompt import so Claude Code hydrates the framework on cold start.',
       reversible: true,
     },
-    {
-      phaseGroup: PHASE_GROUPS.IDE_WIRING,
-      target: rel('.claude', 'settings.json'),
-      action: 'merge',
-      detail:
-        'Add the UserPromptSubmit re-sync hook so the /<command> tree stays current.',
-      reversible: true,
-    },
     {
       phaseGroup: PHASE_GROUPS.IDE_WIRING,
       target: rel('.claude', 'commands'),

package/.agents/scripts/lib/bootstrap/project-bootstrap.js

@@ -16,6 +16,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { isCommandExcluded } from '../command-header.js';
 import { detectPackageManager as detectPm } from '../detect-package-manager.js';
 import { LEDGER_RELATIVE_PATH } from './install-ledger.js';
 import { ensureIssueForms } from './issue-forms-template.js';
@@ -385,52 +386,17 @@ export async function validateAgentrc(ctx) {
   return { ok: !!ok, errors: ok ? [] : (validate.errors ?? []) };
 }
 
-/**
- * Step 3 — Merge the `UserPromptSubmit` sync hook into `.claude/settings.json`.
- * Returns `{ action }`.
- *
- * The sync hook keeps the generated flat `/<name>` command tree
- * (`.claude/commands/`) current. The flat projection needs no plugin
- * enablement keys — it loads in every Claude Code environment, including those
- * where the plugin system (`/plugin`) is unavailable (the #3576 plugin cutover
- * was reverted for exactly that reason).
- *
- * @param {object} ctx
- * @param {typeof fs} [ctx.fsImpl]
- */
-export function ensureClaudeSettings(ctx) {
-  const { fsImpl = fs } = ctx;
-  const target = path.join(ctx.projectRoot, '.claude', 'settings.json');
-  const hook = { type: 'command', command: SYNC_COMMAND };
-  if (!fsImpl.existsSync(target)) {
-    fsImpl.mkdirSync(path.dirname(target), { recursive: true });
-    const fresh = {
-      hooks: {
-        UserPromptSubmit: [{ hooks: [hook] }],
-      },
-    };
-    writeJson(target, fresh, fsImpl);
-    return { action: 'created', path: target };
-  }
-  const settings = readJsonIfExists(target, fsImpl);
-  settings.hooks = settings.hooks ?? {};
-  settings.hooks.UserPromptSubmit = settings.hooks.UserPromptSubmit ?? [];
-  const hookAlready = settings.hooks.UserPromptSubmit.some((group) =>
-    (group?.hooks ?? []).some(
-      (h) =>
-        typeof h?.command === 'string' &&
-        h.command.includes('sync-claude-commands.js'),
-    ),
-  );
-  let mutated = false;
-  if (!hookAlready) {
-    settings.hooks.UserPromptSubmit.push({ hooks: [hook] });
-    mutated = true;
-  }
-  if (!mutated) return { action: 'already-present', path: target };
-  writeJson(target, settings, fsImpl);
-  return { action: 'merged', path: target };
-}
+// Story #4527/#4530: the UserPromptSubmit sync-hook wiring
+// (ensureClaudeSettings, formerly Step 3) was removed. It spawned
+// `mandrel sync-commands` on every prompt to keep `.claude/commands/` in
+// sync with `.agents/workflows/` — a rewrite racing the harness's own read
+// of that same directory while expanding a slash command, and a directory
+// that cannot change mid-session in the first place, so the hook reported
+// `0 file(s) synced` on effectively every invocation. The real sync points
+// already cover every case: `prepare` on install, `mandrel sync` /
+// `mandrel update` on upgrade, and doctor's `commands-in-sync` check for
+// hand-edits. `lib/cli/uninstall.js#revertClaudeSettings` still removes the
+// hook from a consumer who already has it installed from a prior version.
 
 /**
  * Step 4 + Step 8 — Ensure `.gitignore` carries every {@link GITIGNORE_BLOCKS}
@@ -466,7 +432,7 @@ export function ensureGitignore(ctx) {
 
 /**
  * Materialize the generated GitHub Issue Forms
- * (`.github/ISSUE_TEMPLATE/story.yml` + `epic.yml`) into the consumer
+ * (`.github/ISSUE_TEMPLATE/story.yml`) into the consumer
  * project (Story #4227). Derived from the Story-body SSOT so a human-filed
  * ticket round-trips through `story-body.parse()`. Idempotent and additive,
  * mirroring `ensureGitignore`: byte-identical forms are `unchanged`,
@@ -547,6 +513,15 @@ export function runSyncCommands(ctx) {
  * this; this is a belt-and-braces verification that the command projection
  * covers every top-level workflow.
  *
+ * A workflow whose frontmatter carries `command: false` is deliberately NOT
+ * projected to a command — `sync-claude-commands.js` skips it via the same
+ * `isCommandExcluded` predicate used here. Such a workflow must therefore be
+ * excluded from the expected-command set, or this check would demand a
+ * command the sync is contracted never to emit (e.g. the `audit-lighthouse` /
+ * `audit-security` lenses, which are run by the audit suite, not as slash
+ * commands). Keeping the two surfaces on one predicate is what stops them
+ * drifting.
+ *
  * @param {object} ctx
  * @param {typeof fs} [ctx.fsImpl]
  */
@@ -565,7 +540,14 @@ export function checkParity(ctx) {
           .map((e) => e.name.replace(/\.md$/, ''))
           .sort()
       : [];
-  const workflows = new Set(list(workflowsDir));
+  // Expected commands = projectable workflows only. A `command: false`
+  // workflow is contracted out of the command tree, so it is not "missing" a
+  // command — it declined one.
+  const projectable = (name) =>
+    !isCommandExcluded(
+      fsImpl.readFileSync(path.join(workflowsDir, `${name}.md`), 'utf8'),
+    );
+  const workflows = new Set(list(workflowsDir).filter(projectable));
   const commands = new Set(list(commandsDir));
   const missingCommand = [...workflows].filter((n) => !commands.has(n));
   const orphanCommand = [...commands].filter((n) => !workflows.has(n));
@@ -744,11 +726,6 @@ export const BOOTSTRAP_PHASES = Object.freeze([
     isFatal: true,
     formatError: fatalValidation,
   },
-  {
-    name: 'claudeSettings',
-    phaseGroup: PHASE_GROUPS.IDE_WIRING,
-    run: (ctx) => ensureClaudeSettings(ctx),
-  },
   {
     name: 'systemPromptWiring',
     phaseGroup: PHASE_GROUPS.IDE_WIRING,

package/.agents/scripts/lib/bootstrap/quality-bootstrap.js

@@ -76,12 +76,10 @@ export const QUALITY_CONFIG_DEFAULTS = Object.freeze({
   codingGuardrails: Object.freeze({
     cyclomaticFlag: 8,
     cyclomaticMustFix: 12,
-    miDropMustRefactor: 1.5,
     requireSiblingTest: false,
   }),
   autoRefresh: Object.freeze({
     enabled: true,
-    miDropCap: 1.5,
     crapJumpCap: 5,
     scope: 'diff',
   }),

package/.agents/scripts/lib/checks/core-bare-clean.js

@@ -24,7 +24,10 @@
 export default {
   id: 'core-bare-clean',
   severity: 'blocker',
-  scope: ['story-close', 'retro'],
+  // 'npm-test' keeps the test-wrapper preflight's refusal claim true: a
+  // poisoned shared config is caught before a suite (or N concurrent
+  // /deliver workers) inherits it, not only at close/retro time (#4580).
+  scope: ['story-close', 'retro', 'npm-test'],
   autoCorrect: 'refuse-and-print',
   detect(state) {
     const coreBare = state?.git?.coreBare;

package/.agents/scripts/lib/checks/index.js

@@ -182,7 +182,7 @@ export async function getCheck(id, opts) {
  *
  * @param {object} opts
  * @param {string} [opts.scope]      Surface scope, e.g. 'story-close',
- *   'epic-deliver', 'retro', 'diagnose'. When omitted, every check runs.
+ *   'story-close', 'npm-test', 'retro', 'diagnose'. When omitted, every check runs.
  * @param {boolean} [opts.autoFix=false]  Invoke `fix()` for checks with
  *   `autoCorrect: 'auto'`. Forbidden when `scope === 'retro'`.
  * @param {object} opts.state        Probed state from `assembleState()`.

package/.agents/scripts/lib/checks/loop-health.js

@@ -10,15 +10,15 @@
  *
  *   1. **Schema-invalid signal lines.** It tails the most recent
  *      {@link MAX_SAMPLE_LINES} lines of every `signals.ndjson` stream under
- *      the Epic temp tree and validates each against the canonical
+ *      the run temp tree and validates each against the canonical
  *      `signal-event.schema.json` (via `validateSignal`, the same validator
  *      the writer uses — no hand-rolled drift).
- *   2. **Persisted write-time rejects.** It reads the per-Epic reject tally
- *      (`temp/epic-<id>/signal-rejects.json`, written by Story #4413's
+ *   2. **Persisted write-time rejects.** It reads the per-run reject tally
+ *      (`temp/run-<id>/signal-rejects.json`, written by Story #4413's
  *      signals-writer) so records that were dropped at write time — and thus
  *      never appear in the stream — are still counted.
  *   3. **Un-actioned retro proposals.** It reads the retro mirror
- *      (`temp/epic-<id>/retro.md`, Story #4418) and flags any actionable
+ *      (`temp/run-<id>/retro.md`, Story #4418) and flags any actionable
  *      "Proposed issues" item that carries neither a filed-issue reference
  *      (`Filed: [#N](url)`) nor lives under the explicit "One-off /
  *      discarded" record.
@@ -49,9 +49,10 @@ import { validateSignal } from '../observability/signal-validator.js';
 export const MAX_SAMPLE_LINES = 200;
 
 /**
- * Locate the most-recently-touched `epic-<id>` temp tree under
- * `<baseDir>/<tempRoot>`. Returns `{ epicId, epicDir }` or `null` when no
- * Epic temp tree exists (a fresh checkout, or a non-Epic context).
+ * Locate the most-recently-touched `run-<id>` temp tree under
+ * `<baseDir>/<tempRoot>` (the layout `lib/config/temp-paths.js` creates).
+ * Returns `{ epicId, epicDir }` or `null` when no run temp tree exists (a
+ * fresh checkout, or a context with no run in flight).
  *
  * @param {string} baseDir  The main checkout root.
  * @param {{ tempRoot?: string, fsImpl?: { readdirSync: typeof readdirSync, statSync: typeof statSync } }} [opts]
@@ -72,7 +73,7 @@ export function resolveEpicTempTree(
   }
   let best = null;
   for (const entry of entries) {
-    const match = /^epic-(\d+)$/.exec(entry);
+    const match = /^run-(\d+)$/.exec(entry);
     if (!match) continue;
     const full = path.join(tempDir, entry);
     let st;
@@ -168,7 +169,7 @@ export function sampleStreamInvalidCount(
 }
 
 /**
- * Read the per-Epic persisted reject count from `signal-rejects.json`.
+ * Read the per-run persisted reject count from `signal-rejects.json`.
  * Returns 0 when the tally is absent or unreadable.
  *
  * @param {string} epicDir
@@ -316,10 +317,10 @@ export function detectLoopHealth(
     id: 'loop-health',
     severity: 'warning',
     scope,
-    summary: `Loop-health (epic-${epicId}): ${summaryParts.join('; ')}.`,
+    summary: `Loop-health (run-${epicId}): ${summaryParts.join('; ')}.`,
     detail: detailLines.join('\n'),
     fixCommand:
-      'Inspect temp/epic-<id>/{signals.ndjson,signal-rejects.json,retro.md}; fix the signal producer or file/discard the surfaced proposals.',
+      'Inspect temp/run-<id>/{signals.ndjson,signal-rejects.json,retro.md}; fix the signal producer or file/discard the surfaced proposals.',
     autoCorrectable: false,
   };
 }

package/.agents/scripts/lib/checks/state.js

@@ -5,7 +5,7 @@
  * that checks declared for the given scope actually need. The runner in
  * `index.js` filters the registry by `scope` first, then asks this module
  * for state; the per-scope projection keeps probe cost proportional to the
- * call site (e.g. `story-close` does not pay for `epic-deliver` probes, and
+ * call site (e.g. `story-close` does not pay for `diagnose` probes, and
  * the `retro` consumer only probes inputs the retro-scoped checks need).
  *
  * Privacy contract:
@@ -32,7 +32,7 @@
  */
 
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 
 /**
@@ -45,23 +45,18 @@ import path from 'node:path';
  *
  * @type {Record<string, readonly string[]>}
  */
-// Shared key set: story-close and epic-close probe the same surface
-// (integration branch + worktree set). Story #1289 introduced the
-// `epic-close` and `npm-test` aliases.
+// Story-close probe surface: branch list + worktree set. Story #1289
+// introduced the `npm-test` alias.
 const STORY_CLOSE_KEYS = Object.freeze([
   'git.headRef',
-  'git.epicBranches',
-  'git.epicBranchSync',
   'git.localBranches',
   'git.coreBare',
   'fs.worktrees',
-  'fs.epicMergeLocks',
   'env.GITHUB_TOKEN',
 ]);
 
-const EPIC_DELIVER_KEYS = Object.freeze([
+const DIAGNOSE_KEYS = Object.freeze([
   'git.headRef',
-  'git.epicBranches',
   'git.coreBare',
   'fs.worktrees',
   'fs.dotEnv',
@@ -71,8 +66,6 @@ const EPIC_DELIVER_KEYS = Object.freeze([
 
 const SCOPE_KEYS = Object.freeze({
   'story-close': STORY_CLOSE_KEYS,
-  'epic-close': STORY_CLOSE_KEYS,
-  'epic-deliver': EPIC_DELIVER_KEYS,
   'npm-test': Object.freeze([
     'git.headRef',
     'git.coreBare',
@@ -80,8 +73,11 @@ const SCOPE_KEYS = Object.freeze({
     'fs.dotEnv',
     'fs.dotMcp',
   ]),
-  retro: Object.freeze(['git.headRef', 'git.epicBranches', 'fs.worktrees']),
-  diagnose: EPIC_DELIVER_KEYS,
+  // git.coreBare: core-bare-clean declares scope ['story-close', 'retro',
+  // 'npm-test']; without the probe key its detect() reads undefined and the
+  // retro leg is a silent no-op (#4580).
+  retro: Object.freeze(['git.headRef', 'git.coreBare', 'fs.worktrees']),
+  diagnose: DIAGNOSE_KEYS,
 });
 
 /**
@@ -138,78 +134,6 @@ function defaultEnvProbe(name) {
   return process.env[name] ? 'set' : 'missing';
 }
 
-/**
- * Default lock-file probe — reads an epic merge lock file at the given
- * absolute path. Returns `{ exists, pid, acquiredAt, mtimeMs }` or
- * `{ exists: false }`. PID + timestamp are NOT secrets — they are
- * operational data the orphan-lock check uses to decide if a lock is
- * stale. This probe is separate from the privacy-bounded `fs` probe so
- * the README's "fs records existence only" contract for bootstrap files
- * (.env, .mcp.json) remains intact.
- *
- * @param {string} absPath
- * @returns {{ exists: boolean, pid?: number|null, acquiredAt?: number|null, mtimeMs?: number|null }}
- */
-function defaultLockProbe(absPath) {
-  let st;
-  try {
-    st = statSync(absPath);
-  } catch {
-    return { exists: false };
-  }
-  let pid = null;
-  let acquiredAt = null;
-  try {
-    const raw = readFileSync(absPath, 'utf8');
-    const parsed = JSON.parse(raw);
-    pid = Number.isFinite(Number(parsed.pid)) ? Number(parsed.pid) : null;
-    acquiredAt = Number.isFinite(Number(parsed.acquiredAt))
-      ? Number(parsed.acquiredAt)
-      : null;
-  } catch {
-    // Corrupted or unreadable — still report existence with null fields so
-    // the consumer can surface "lock file exists but is unparseable".
-  }
-  return { exists: true, pid, acquiredAt, mtimeMs: st.mtimeMs };
-}
-
-/**
- * Predicate: is `pid` a shape we can hand to `process.kill(_, 0)`? Splits
- * the input-validity check out of `defaultPidLivenessProbe` so the
- * defensive guard cascade and the OS round-trip are independently
- * testable. Exported so sibling tests can exercise every branch without
- * monkey-patching `process.kill`.
- *
- * @param {*} pid
- * @returns {boolean}
- */
-export function validatePidProbeInputs(pid) {
-  if (pid === null || pid === undefined) return false;
-  if (typeof pid !== 'number') return false;
-  if (!Number.isFinite(pid)) return false;
-  if (pid <= 0) return false;
-  return true;
-}
-
-/**
- * Default process-liveness probe — `process.kill(pid, 0)` checks existence
- * without delivering a signal. Returns true for live, false for dead/missing.
- * Separated from the lock probe so tests can independently spy on each.
- *
- * @param {number|null|undefined} pid
- * @returns {boolean}
- */
-function defaultPidLivenessProbe(pid) {
-  if (!validatePidProbeInputs(pid)) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // EPERM = exists but unsignalable — still alive.
-    return err && err.code === 'EPERM';
-  }
-}
-
 /**
  * Probe the current HEAD ref (short / abbreviated form). Returns the branch
  * name, or `null` when git cannot resolve HEAD (detached / non-repo).
@@ -240,20 +164,6 @@ function parseBranchList(result) {
     : [];
 }
 
-/**
- * Probe the epic branches (`refs/heads/epic/`), short-name form.
- *
- * @param {object} args
- * @param {string} args.cwd
- * @param {(cwd: string, ...args: string[]) => { ok: boolean, stdout: string }} args.git
- * @returns {string[]}
- */
-function probeEpicBranches({ cwd, git }) {
-  return parseBranchList(
-    git(cwd, 'for-each-ref', '--format=%(refname:short)', 'refs/heads/epic/'),
-  );
-}
-
 /**
  * Probe all local branches (`refs/heads/`), short-name form. Used by checks
  * that grep over the branch list for legacy naming patterns.
@@ -282,107 +192,24 @@ function probeCoreBare({ cwd, git }) {
   return result.ok ? result.stdout : null;
 }
 
-/**
- * Build a map of epic branch → { local, remote, ahead } sync state.
- * Standalone (Story #3351): takes the already-assembled `epicBranches` as an
- * explicit argument rather than reading sibling probe output, so it is
- * independently testable and the ordering dependency on the epicBranches
- * probe is explicit at the call site.
- *
- * Story #2463 (preflight batching): the prior implementation issued
- * two `git rev-parse --verify` spawnSync calls per epic branch
- * (one for `epic/<id>`, one for `origin/epic/<id>`), giving an
- * O(branches × 2) probe cost. The collapsed implementation issues
- * exactly one `git for-each-ref` invocation that emits
- *   `<refname> <objectname> <upstream:short> <upstream:objectname>`
- * for every local branch, then filters to the epic branches the
- * scope already declared. Probe cost drops to O(1) for the spawn
- * surface while preserving the byte-identical return shape:
- *   { local: string|null, remote: string|null, ahead: boolean }.
- *
- * `ahead` stays true only when local AND remote SHAs both exist and
- * differ — branches with no upstream config (no `%(upstream:objectname)`)
- * report `remote: null, ahead: false`, matching the pre-batch behavior
- * where `rev-parse --verify origin/<branch>` failed for unpushed refs.
- *
- * @param {object} args
- * @param {string} args.cwd
- * @param {(cwd: string, ...args: string[]) => { ok: boolean, stdout: string }} args.git
- * @param {readonly string[]} args.epicBranches
- * @returns {Record<string, { local: string|null, remote: string|null, ahead: boolean }>}
- */
-function probeEpicBranchSync({ cwd, git, epicBranches }) {
-  const sync = {};
-  const branches = epicBranches ?? [];
-  const branchSet = new Set(branches);
-  const formatted = git(
-    cwd,
-    'for-each-ref',
-    '--format=%(refname:short) %(objectname) %(upstream:short) %(upstream:objectname)',
-    'refs/heads/',
-  );
-  const rows = new Map();
-  if (formatted.ok && formatted.stdout) {
-    for (const line of formatted.stdout.split('\n')) {
-      if (!line) continue;
-      // Split on whitespace; trailing fields may be empty strings.
-      // refname is mandatory (always present); objectname always populated
-      // for an existing ref; upstream fields may be missing.
-      const parts = line.split(' ');
-      const refname = parts[0];
-      if (!refname || !branchSet.has(refname)) continue;
-      const objectname = parts[1] || null;
-      const upstreamShort = parts[2] || null;
-      const upstreamObjectname = parts[3] || null;
-      rows.set(refname, {
-        local: objectname,
-        // Surface remote SHA only when an upstream is configured AND
-        // git resolved its objectname. An upstream short-name without
-        // an objectname (gone-upstream edge case) collapses to null.
-        remote: upstreamShort && upstreamObjectname ? upstreamObjectname : null,
-      });
-    }
-  }
-  for (const branch of branches) {
-    const row = rows.get(branch);
-    const localSha = row?.local ?? null;
-    const remoteSha = row?.remote ?? null;
-    sync[branch] = {
-      local: localSha,
-      remote: remoteSha,
-      ahead: Boolean(localSha && remoteSha && localSha !== remoteSha),
-    };
-  }
-  return sync;
-}
-
 /**
  * Handler map keyed by git probe field name (the part after `git.`). Each
- * handler receives `{ cwd, git, out }` and returns the field's value. `out`
- * exposes the already-assembled projection so dependent probes (e.g.
- * `epicBranchSync`, which needs `epicBranches`) can read upstream results.
+ * handler receives `{ cwd, git }` and returns the field's value.
  *
  * Story #3351: replaces the prior if/else ladder so each probe is
- * independently testable and the `epicBranchSync` → `epicBranches` ordering
- * dependency is explicit (it reads `out.epicBranches` and the SCOPE_KEYS
- * ordering guarantees that field is assembled first).
+ * independently testable.
  *
- * @type {Record<string, (ctx: { cwd: string, git: (cwd: string, ...args: string[]) => { ok: boolean, stdout: string }, out: Record<string, unknown> }) => unknown>}
+ * @type {Record<string, (ctx: { cwd: string, git: (cwd: string, ...args: string[]) => { ok: boolean, stdout: string } }) => unknown>}
  */
 const GIT_PROBES = Object.freeze({
   headRef: ({ cwd, git }) => probeHeadRef({ cwd, git }),
-  epicBranches: ({ cwd, git }) => probeEpicBranches({ cwd, git }),
   localBranches: ({ cwd, git }) => probeLocalBranches({ cwd, git }),
   coreBare: ({ cwd, git }) => probeCoreBare({ cwd, git }),
-  epicBranchSync: ({ cwd, git, out }) =>
-    probeEpicBranchSync({ cwd, git, epicBranches: out.epicBranches ?? [] }),
 });
 
 /**
  * Build the git projection for a key list by iterating the `GIT_PROBES`
- * handler map. Keys are processed in declaration order; a probe that depends
- * on a sibling field (e.g. `epicBranchSync` → `epicBranches`) relies on the
- * SCOPE_KEYS ordering placing its dependency first.
+ * handler map.
  *
  * @param {readonly string[]} keys
  * @param {string} cwd
@@ -396,7 +223,7 @@ function probeGit(keys, cwd, git) {
     const field = key.slice(4);
     const handler = GIT_PROBES[field];
     if (!handler) continue;
-    out[field] = handler({ cwd, git, out });
+    out[field] = handler({ cwd, git });
   }
   return out;
 }
@@ -407,12 +234,9 @@ function probeGit(keys, cwd, git) {
  * @param {readonly string[]} keys
  * @param {string} cwd
  * @param {(absPath: string) => boolean} fs
- * @param {{ epicBranches?: string[], gitCommonDir?: string }} ctx
- * @param {(absPath: string) => object} lockProbe
- * @param {(pid: number|null) => boolean} pidLivenessProbe
  * @returns {Record<string, unknown>}
  */
-function probeFs(keys, cwd, fs, ctx, lockProbe, pidLivenessProbe) {
+function probeFs(keys, cwd, fs) {
   const out = {};
   for (const key of keys) {
     if (!key.startsWith('fs.')) continue;
@@ -423,38 +247,6 @@ function probeFs(keys, cwd, fs, ctx, lockProbe, pidLivenessProbe) {
       out.dotEnv = fs(path.join(cwd, '.env'));
     } else if (field === 'dotMcp') {
       out.dotMcp = fs(path.join(cwd, '.mcp.json'));
-    } else if (field === 'epicMergeLocks') {
-      // For each epic branch, probe the matching lock file in the git
-      // common dir. The lock path mirrors epic-merge-lock.js's
-      // `lockPathFor()`: `<gitCommonDir>/epic-<id>.merge.lock`.
-      const commonDir = ctx.gitCommonDir ?? path.join(cwd, '.git');
-      const locks = {};
-      const branches = ctx.epicBranches ?? [];
-      for (const branch of branches) {
-        const id = branch.replace(/^epic\//, '');
-        const lockPath = path.join(commonDir, `epic-${id}.merge.lock`);
-        const meta = lockProbe(lockPath);
-        if (!meta.exists) {
-          locks[id] = {
-            exists: false,
-            path: lockPath,
-            pid: null,
-            holderAlive: false,
-            acquiredAt: null,
-            mtimeMs: null,
-          };
-          continue;
-        }
-        locks[id] = {
-          exists: true,
-          path: lockPath,
-          pid: meta.pid ?? null,
-          acquiredAt: meta.acquiredAt ?? null,
-          mtimeMs: meta.mtimeMs ?? null,
-          holderAlive: pidLivenessProbe(meta.pid ?? null),
-        };
-      }
-      out.epicMergeLocks = locks;
     }
   }
   return out;
@@ -506,31 +298,8 @@ export function assembleState({ scope, cwd = process.cwd(), probes } = {}) {
   const gitProbe = probes?.git ?? defaultGitProbe;
   const fsProbe = probes?.fs ?? defaultFsProbe;
   const envProbe = probes?.env ?? defaultEnvProbe;
-  const lockProbe = probes?.lock ?? defaultLockProbe;
-  const pidLivenessProbe = probes?.pidLiveness ?? defaultPidLivenessProbe;
   const gitProjection = probeGit(keys, cwd, gitProbe);
-  // Lock probes need the resolved git common dir; query it via the git
-  // probe so test injection still works. In a linked worktree this points
-  // at the parent repo's .git/, matching epic-merge-lock.js's lookup.
-  let gitCommonDir;
-  if (keys.includes('fs.epicMergeLocks')) {
-    const r = gitProbe(cwd, 'rev-parse', '--git-common-dir');
-    if (r.ok && r.stdout) {
-      gitCommonDir = path.isAbsolute(r.stdout)
-        ? r.stdout
-        : path.resolve(cwd, r.stdout);
-    } else {
-      gitCommonDir = path.join(cwd, '.git');
-    }
-  }
-  const fsProjection = probeFs(
-    keys,
-    cwd,
-    fsProbe,
-    { epicBranches: gitProjection.epicBranches, gitCommonDir },
-    lockProbe,
-    pidLivenessProbe,
-  );
+  const fsProjection = probeFs(keys, cwd, fsProbe);
   // Story #1289: `cwd` is surfaced so fs-scanning checks target the
   // worktree they were assembled for.
   const state = Object.freeze({

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

@@ -9,7 +9,7 @@
  * 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
+ * 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.
@@ -146,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) {
@@ -178,7 +178,7 @@ export default {
     return {
       id: 'story-init-not-backgrounded',
       severity: 'blocker',
-      scope: state?.scope ?? 'epic-deliver',
+      scope: state?.scope ?? 'story-close',
       summary: `${offences.length} orchestration call site(s) invoke single-story-init.js with Monitor backgrounding`,
       detail,
       fixCommand: FIX_COMMAND,