mandrel 1.93.0 → 2.0.0

package/.agents/scripts/lib/baselines/kernel.js

@@ -26,28 +26,215 @@
  * @module lib/baselines/kernel
  */
 
-import * as bundleSize from './kinds/bundle-size.js';
-import * as coverage from './kinds/coverage.js';
-import * as crap from './kinds/crap.js';
-import * as duplication from './kinds/duplication.js';
-import * as lighthouse from './kinds/lighthouse.js';
-import * as lint from './kinds/lint.js';
-import * as maintainability from './kinds/maintainability.js';
-import * as mutation from './kinds/mutation.js';
+import {
+  applyEpsilon as bundleSizeApplyEpsilon,
+  compare as bundleSizeCompare,
+  kernelVersion as bundleSizeKernelVersion,
+  keyField as bundleSizeKeyField,
+  mergeRows as bundleSizeMergeRows,
+  name as bundleSizeName,
+  projectRow as bundleSizeProjectRow,
+  rollup as bundleSizeRollup,
+  sortRows as bundleSizeSortRows,
+} from './kinds/bundle-size.js';
+import {
+  applyEpsilon as coverageApplyEpsilon,
+  compare as coverageCompare,
+  kernelVersion as coverageKernelVersion,
+  keyField as coverageKeyField,
+  mergeRows as coverageMergeRows,
+  name as coverageName,
+  projectRow as coverageProjectRow,
+  rollup as coverageRollup,
+  sortRows as coverageSortRows,
+} from './kinds/coverage.js';
+import {
+  applyEpsilon as crapApplyEpsilon,
+  compare as crapCompare,
+  kernelVersion as crapKernelVersion,
+  keyField as crapKeyField,
+  mergeRows as crapMergeRows,
+  name as crapName,
+  projectRow as crapProjectRow,
+  rollup as crapRollup,
+  sortRows as crapSortRows,
+} from './kinds/crap.js';
+import {
+  applyEpsilon as duplicationApplyEpsilon,
+  compare as duplicationCompare,
+  kernelVersion as duplicationKernelVersion,
+  keyField as duplicationKeyField,
+  mergeRows as duplicationMergeRows,
+  name as duplicationName,
+  projectRow as duplicationProjectRow,
+  rollup as duplicationRollup,
+  sortRows as duplicationSortRows,
+} from './kinds/duplication.js';
+import {
+  applyEpsilon as lighthouseApplyEpsilon,
+  compare as lighthouseCompare,
+  kernelVersion as lighthouseKernelVersion,
+  keyField as lighthouseKeyField,
+  mergeRows as lighthouseMergeRows,
+  name as lighthouseName,
+  projectRow as lighthouseProjectRow,
+  rollup as lighthouseRollup,
+  sortRows as lighthouseSortRows,
+} from './kinds/lighthouse.js';
+import {
+  applyEpsilon as lintApplyEpsilon,
+  compare as lintCompare,
+  kernelVersion as lintKernelVersion,
+  keyField as lintKeyField,
+  mergeRows as lintMergeRows,
+  name as lintName,
+  projectRow as lintProjectRow,
+  rollup as lintRollup,
+  sortRows as lintSortRows,
+} from './kinds/lint.js';
+import {
+  applyEpsilon as maintainabilityApplyEpsilon,
+  compare as maintainabilityCompare,
+  kernelVersion as maintainabilityKernelVersion,
+  keyField as maintainabilityKeyField,
+  mergeRows as maintainabilityMergeRows,
+  name as maintainabilityName,
+  projectRow as maintainabilityProjectRow,
+  rollup as maintainabilityRollup,
+  sortRows as maintainabilitySortRows,
+} from './kinds/maintainability.js';
+import {
+  applyEpsilon as mutationApplyEpsilon,
+  compare as mutationCompare,
+  kernelVersion as mutationKernelVersion,
+  keyField as mutationKeyField,
+  mergeRows as mutationMergeRows,
+  name as mutationName,
+  projectRow as mutationProjectRow,
+  rollup as mutationRollup,
+  sortRows as mutationSortRows,
+} from './kinds/mutation.js';
+
+/**
+ * Assemble the kind-module protocol from named imports.
+ *
+ * Prefer named imports over `import * as kind` here: knip (and the
+ * dead-exports ratchet) cannot see members reached only through
+ * `getKindModule(kind).projectRow(...)` after a namespace import, so
+ * star-imports of `kinds/*.js` produced systematic false-positive dead
+ * exports for the protocol surface (`name`, `keyField`, `kernelVersion`,
+ * `projectRow`, `sortRows`, `rollup`, …).
+ *
+ * @param {object} members
+ * @returns {object}
+ */
+function bindKindModule(members) {
+  return Object.freeze({
+    name: members.name,
+    keyField: members.keyField,
+    kernelVersion: members.kernelVersion,
+    projectRow: members.projectRow,
+    sortRows: members.sortRows,
+    rollup: members.rollup,
+    compare: members.compare,
+    applyEpsilon: members.applyEpsilon,
+    mergeRows: members.mergeRows,
+  });
+}
 
 /**
  * Registry of every shipped kind module. Keys mirror the per-kind schema
  * filenames so a future "list all kinds" iterator can stay declarative.
  */
 const KIND_MODULES = Object.freeze({
-  lint,
-  coverage,
-  crap,
-  maintainability,
-  mutation,
-  lighthouse,
-  'bundle-size': bundleSize,
-  duplication,
+  lint: bindKindModule({
+    name: lintName,
+    keyField: lintKeyField,
+    kernelVersion: lintKernelVersion,
+    projectRow: lintProjectRow,
+    sortRows: lintSortRows,
+    rollup: lintRollup,
+    compare: lintCompare,
+    applyEpsilon: lintApplyEpsilon,
+    mergeRows: lintMergeRows,
+  }),
+  coverage: bindKindModule({
+    name: coverageName,
+    keyField: coverageKeyField,
+    kernelVersion: coverageKernelVersion,
+    projectRow: coverageProjectRow,
+    sortRows: coverageSortRows,
+    rollup: coverageRollup,
+    compare: coverageCompare,
+    applyEpsilon: coverageApplyEpsilon,
+    mergeRows: coverageMergeRows,
+  }),
+  crap: bindKindModule({
+    name: crapName,
+    keyField: crapKeyField,
+    kernelVersion: crapKernelVersion,
+    projectRow: crapProjectRow,
+    sortRows: crapSortRows,
+    rollup: crapRollup,
+    compare: crapCompare,
+    applyEpsilon: crapApplyEpsilon,
+    mergeRows: crapMergeRows,
+  }),
+  maintainability: bindKindModule({
+    name: maintainabilityName,
+    keyField: maintainabilityKeyField,
+    kernelVersion: maintainabilityKernelVersion,
+    projectRow: maintainabilityProjectRow,
+    sortRows: maintainabilitySortRows,
+    rollup: maintainabilityRollup,
+    compare: maintainabilityCompare,
+    applyEpsilon: maintainabilityApplyEpsilon,
+    mergeRows: maintainabilityMergeRows,
+  }),
+  mutation: bindKindModule({
+    name: mutationName,
+    keyField: mutationKeyField,
+    kernelVersion: mutationKernelVersion,
+    projectRow: mutationProjectRow,
+    sortRows: mutationSortRows,
+    rollup: mutationRollup,
+    compare: mutationCompare,
+    applyEpsilon: mutationApplyEpsilon,
+    mergeRows: mutationMergeRows,
+  }),
+  lighthouse: bindKindModule({
+    name: lighthouseName,
+    keyField: lighthouseKeyField,
+    kernelVersion: lighthouseKernelVersion,
+    projectRow: lighthouseProjectRow,
+    sortRows: lighthouseSortRows,
+    rollup: lighthouseRollup,
+    compare: lighthouseCompare,
+    applyEpsilon: lighthouseApplyEpsilon,
+    mergeRows: lighthouseMergeRows,
+  }),
+  'bundle-size': bindKindModule({
+    name: bundleSizeName,
+    keyField: bundleSizeKeyField,
+    kernelVersion: bundleSizeKernelVersion,
+    projectRow: bundleSizeProjectRow,
+    sortRows: bundleSizeSortRows,
+    rollup: bundleSizeRollup,
+    compare: bundleSizeCompare,
+    applyEpsilon: bundleSizeApplyEpsilon,
+    mergeRows: bundleSizeMergeRows,
+  }),
+  duplication: bindKindModule({
+    name: duplicationName,
+    keyField: duplicationKeyField,
+    kernelVersion: duplicationKernelVersion,
+    projectRow: duplicationProjectRow,
+    sortRows: duplicationSortRows,
+    rollup: duplicationRollup,
+    compare: duplicationCompare,
+    applyEpsilon: duplicationApplyEpsilon,
+    mergeRows: duplicationMergeRows,
+  }),
 });
 
 /**
@@ -55,10 +242,11 @@ const KIND_MODULES = Object.freeze({
  * callers can't silently fall through to undefined behaviour.
  *
  * @param {string} kind
- * @returns {{ name: string, kernelVersion: () => string, keyField: string,
+ * @returns {{ name: string, keyField: string, kernelVersion: () => string,
  *           projectRow: (row: object) => object,
  *           sortRows: (rows: object[]) => object[],
- *           rollup: (rows: object[], components?: object[]) => object }}
+ *           rollup: (rows: object[], components?: object[]) => object,
+ *           compare?: Function, applyEpsilon?: Function, mergeRows?: Function }}
  */
 export function getKindModule(kind) {
   const mod = KIND_MODULES[kind];

package/.agents/scripts/lib/baselines/kinds/maintainability.js

@@ -62,10 +62,6 @@ export const MAINTAINABILITY_EXCLUSIONS = Object.freeze(
     // escomplex: "this[node.callee.type] is not a function" — the cyclomatic
     // visitor lacks a handler for one of the quality-watch CLI's call shapes.
     '.agents/scripts/quality-watch.js',
-    // escomplex: "Cannot read properties of undefined (reading 'pattern')" —
-    // same family as acceptance-spec-reconciler. The audit recheck CLI uses
-    // the same regex-property scan helpers.
-    '.agents/scripts/epic-audit-recheck.js',
     // escomplex: parse-fails (MI=0) on the spec-freshness phase's optional-
     // chained destructuring fallthrough. Same upstream family as the other
     // "pattern" / destructuring failures; carve-out so the phase split of

package/.agents/scripts/lib/baselines/reader.js

@@ -86,15 +86,10 @@ function resolveBaselinePath(kind, opts = {}) {
       cwd,
       configPath: opts.configPath,
     });
-    const gateBlock =
-      resolved?.agentSettings?.delivery?.quality?.gates?.[kind] ??
-      resolved?.delivery?.quality?.gates?.[kind] ??
-      null;
+    const gateBlock = resolved?.delivery?.quality?.gates?.[kind] ?? null;
     if (gateBlock?.baselinePath) {
       configured = gateBlock.baselinePath;
     } else {
-      // Fall through to the legacy {lint, crap, maintainability} envelope
-      // exposed by getBaselines.
       const flat = getBaselines(resolved ?? {});
       if (kind === 'lint' || kind === 'crap' || kind === 'maintainability') {
         configured = flat[kind]?.path ?? null;

package/.agents/scripts/lib/bdd-runner-detect.js

@@ -62,9 +62,7 @@ export const BDD_RUNNER_TAG_TABLE = Object.freeze({
 /**
  * Shared set of tag tokens that mean "this scenario does not yet satisfy
  * its AC — treat coverage as pending, not satisfied." Sourced from every
- * `pendingTag` value in `BDD_RUNNER_TAG_TABLE` plus the historical
- * `@pending` literal for backward compatibility with feature files
- * authored before runner-aware detection.
+ * pending-tag value in `BDD_RUNNER_TAG_TABLE` (today `@skip` / `skip`).
  *
  * Both the prefixed (`@skip`) and the unprefixed (`skip`) form of each
  * tag are included so consumers can look up either the raw tag string
@@ -75,18 +73,16 @@ export const BDD_RUNNER_TAG_TABLE = Object.freeze({
  *   - `acceptance-spec-reconciler.classifyCoverage` — membership check
  *     against parsed scenario tag sets.
  *   - Contract tests that walk `BDD_RUNNER_TAG_TABLE` and assert each
- *     `pendingTag` is registered here, guarding against drift when a
+ *     pending tag is registered here, guarding against drift when a
  *     new runner is added.
  */
 export const PENDING_TAGS = Object.freeze(
-  new Set([
-    ...Object.values(BDD_RUNNER_TAG_TABLE).flatMap((tag) => [
+  new Set(
+    Object.values(BDD_RUNNER_TAG_TABLE).flatMap((tag) => [
       tag,
       tag.startsWith('@') ? tag.slice(1) : `@${tag}`,
     ]),
-    '@pending',
-    'pending',
-  ]),
+  ),
 );
 
 /**

package/.agents/scripts/lib/bootstrap/issue-forms-template.js

@@ -1,10 +1,10 @@
 /**
  * bootstrap/issue-forms-template — Story #4227 (framework-gap)
  *
- * Generates GitHub **Issue Forms** (`.github/ISSUE_TEMPLATE/story.yml` and
- * `epic.yml`) derived from the canonical Story-body SSOT
+ * Generates the GitHub **Story Issue Form**
+ * (`.github/ISSUE_TEMPLATE/story.yml`) derived from the canonical Story-body SSOT
  * (`lib/story-body/story-body.js`). The forms exist so a human filing a
- * Story/Epic in the GitHub web UI produces a body that round-trips through
+ * Story in the GitHub web UI produces a body that round-trips through
  * the same `story-body.parse()` agents rely on — closing the
  * human↔agent ticket-shape gap.
  *
@@ -57,12 +57,11 @@ import path from 'node:path';
 const ISSUE_TEMPLATE_RELATIVE_DIR = '.github/ISSUE_TEMPLATE';
 
 /**
- * Relative paths of the two generated forms, surfaced as constants so tests
- * and the bootstrap caller assert the canonical write targets without
- * re-deriving them.
+ * Relative path of the generated Story form, surfaced as a constant so tests
+ * and the bootstrap caller assert the canonical write target without
+ * re-deriving it.
  */
 export const STORY_FORM_RELATIVE_PATH = `${ISSUE_TEMPLATE_RELATIVE_DIR}/story.yml`;
-export const EPIC_FORM_RELATIVE_PATH = `${ISSUE_TEMPLATE_RELATIVE_DIR}/epic.yml`;
 
 /**
  * The human **intent subset** of the Story-body schema, in canonical
@@ -102,8 +101,12 @@ export const HUMAN_INTENT_FIELDS = [
     heading: 'Changes',
     label: 'Changes',
     description:
-      'Files or globs this work touches, one per line (e.g. `- src/foo.js: add handler`). Advisory — the binding contract is Acceptance/Verify.',
-    placeholder: '- src/foo.js: add the handler\n- tests/foo.test.js: cover it',
+      'Files this work touches, one per line as JSON objects: ' +
+      '`{ "path": "…", "assumption": "creates"|"refactors-existing"|"exists"|"deletes" }`. ' +
+      'Advisory — the binding contract is Acceptance/Verify.',
+    placeholder:
+      '- {"path":"src/foo.js","assumption":"creates"}\n' +
+      '- {"path":"tests/foo.test.js","assumption":"creates"}',
     required: false,
     kind: 'textarea',
   },
@@ -132,8 +135,10 @@ export const HUMAN_INTENT_FIELDS = [
     id: 'references',
     heading: 'References',
     label: 'References',
-    description: 'Read-only paths worth consulting, one per line. Optional.',
-    placeholder: '- docs/architecture.md',
+    description:
+      'Read-only paths worth consulting, one per line as JSON objects ' +
+      '`{ "path": "…", "assumption": "exists" }`. Optional.',
+    placeholder: '- {"path":"docs/architecture.md","assumption":"exists"}',
     required: false,
     kind: 'textarea',
   },
@@ -220,27 +225,26 @@ const GENERATED_BANNER =
   '# (lint-issue-body.js) is the drift guard between this form and the parser.';
 
 /**
- * Render the GitHub Issue Form YAML for a given ticket type (`story` or
- * `epic`). Both forms share the identical human-intent field set — the
- * difference is the `type::` label and the form name/description — because
- * `parse()` is type-agnostic over the body shape.
+ * Render the GitHub Issue Form YAML for Stories. Epics are no longer a
+ * ticket type in the label taxonomy, so the generated human-entry surface
+ * is story-only.
  *
  * The output is deterministic so the round-trip + idempotency tests assert
  * on its exact shape.
  *
- * @param {'story'|'epic'} ticketType
+ * @param {'story'} ticketType
  * @param {IssueFormOptions} [opts]
  * @returns {string}
  */
 export function renderIssueForm(ticketType, opts = {}) {
-  if (ticketType !== 'story' && ticketType !== 'epic') {
+  if (ticketType !== 'story') {
     throw new Error(
-      `renderIssueForm: ticketType must be 'story' or 'epic', got ${ticketType}`,
+      `renderIssueForm: ticketType must be 'story', got ${ticketType}`,
     );
   }
   const entryStateLabel = opts.entryStateLabel ?? 'agent::review-spec';
-  const typeLabel = `type::${ticketType}`;
-  const titleCase = ticketType === 'story' ? 'Story' : 'Epic';
+  const typeLabel = 'type::story';
+  const titleCase = 'Story';
   const projectSuffix = opts.projectName ? ` for ${opts.projectName}` : '';
 
   const fieldBlocks = HUMAN_INTENT_FIELDS.map(renderFieldBlock).join('\n');
@@ -309,8 +313,8 @@ export const CONFORMANCE_WORKFLOW_RELATIVE_PATH =
 
 /**
  * Render the CI workflow that runs the issue-body conformance lint
- * (`lint-issue-body.js`) on opened/edited `type::story` / `type::epic`
- * issues. This is the mechanism that prevents the generated forms and
+ * (`lint-issue-body.js`) on opened/edited `type::story` issues. This is
+ * the mechanism that prevents the generated form and
  * `story-body.parse()` from silently drifting (Story #4227 acceptance).
  * Deterministic so the bootstrap test asserts its exact shape. Internal —
  * exposed to consumers only through {@link ensureIssueForms}.
@@ -321,7 +325,7 @@ function renderConformanceWorkflow() {
   return `# Issue-body conformance lint (Story #4227).
 #
 # Generated by agents-bootstrap-github. Runs the canonical story-body parser
-# against human-opened type::story / type::epic issues and comments when the
+# against human-opened type::story issues and comments when the
 # body does not round-trip, instead of letting the supported human entry
 # points (e.g. /plan from an existing Epic ID) fail silently later. The lint
 # informs; it never fails the issue. Re-run /agents-bootstrap-github to refresh.
@@ -362,7 +366,7 @@ jobs:
 }
 
 /**
- * Write (or refresh) both issue forms into a project checkout. Idempotent at
+ * Write (or refresh) the Story issue form into a project checkout. Idempotent at
  * the byte level — mirrors {@link ensureCiWorkflow}'s contract:
  *
  * - file absent → `created`
@@ -378,7 +382,7 @@ jobs:
  * @param {IssueFormOptions} [args.options]
  * @param {boolean} [args.write=true] - When `false`, compute the would-be
  *   actions without touching disk (dry-run).
- * @returns {{ forms: Array<{ type: 'story'|'epic'|'conformance-workflow',
+ * @returns {{ forms: Array<{ type: 'story'|'conformance-workflow',
  *             action: 'created'|'unchanged'|'custom-skip',
  *             path: string, rendered: string }> }}
  */
@@ -387,20 +391,15 @@ export function ensureIssueForms(args) {
   const options = args.options ?? {};
   const write = args.write !== false;
 
-  // Each target pairs a ticket-type key with the rendered body. The
-  // conformance workflow is materialized alongside the forms because it is
-  // the forms' drift guard — they ship as one unit.
+  // Each target pairs a type key with the rendered body. The conformance
+  // workflow is materialized alongside the form because it is the form's
+  // drift guard — they ship as one unit.
   const targets = [
     {
       type: 'story',
       rel: STORY_FORM_RELATIVE_PATH,
       rendered: renderIssueForm('story', options),
     },
-    {
-      type: 'epic',
-      rel: EPIC_FORM_RELATIVE_PATH,
-      rendered: renderIssueForm('epic', options),
-    },
     {
       type: 'conformance-workflow',
       rel: CONFORMANCE_WORKFLOW_RELATIVE_PATH,

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

@@ -24,6 +24,12 @@ import { applyQualityBootstrap } from './quality-bootstrap.js';
 
 export const SYNC_COMMAND = 'node .agents/scripts/sync-claude-commands.js';
 
+// Epic #4478 (M7-B). The role-scoped agent projection runs in every place the
+// command projection does — `sync:agents` script, `prepare`, and the bootstrap
+// `sync` phase (`runSyncCommands`) — so `.claude/agents/*.md` materializes for
+// hosts that read it, exactly as `.claude/commands/*.md` does.
+export const SYNC_AGENTS_COMMAND = 'node .agents/scripts/sync-claude-agents.js';
+
 export const BOOTSTRAP_COMMAND = 'node .agents/scripts/bootstrap.js';
 
 /**
@@ -202,6 +208,7 @@ export function ensurePackageJson(ctx) {
   const outcomes = {
     created: false,
     scriptsSyncCommands: 'already-present',
+    scriptsSyncAgents: 'already-present',
     scriptsPrepare: 'already-present',
     scriptsBootstrap: 'already-present',
   };
@@ -220,13 +227,29 @@ export function ensurePackageJson(ctx) {
     pkg.scripts['sync:commands'] = SYNC_COMMAND;
     outcomes.scriptsSyncCommands = 'added';
   }
+  if (!pkg.scripts['sync:agents']) {
+    pkg.scripts['sync:agents'] = SYNC_AGENTS_COMMAND;
+    outcomes.scriptsSyncAgents = 'added';
+  }
   const prepare = pkg.scripts.prepare;
   if (!prepare) {
-    pkg.scripts.prepare = SYNC_COMMAND;
+    pkg.scripts.prepare = `${SYNC_COMMAND} && ${SYNC_AGENTS_COMMAND}`;
     outcomes.scriptsPrepare = 'added';
-  } else if (!prepare.includes('sync-claude-commands.js')) {
-    pkg.scripts.prepare = `${prepare} && ${SYNC_COMMAND}`;
-    outcomes.scriptsPrepare = 'appended';
+  } else {
+    // Append each projection independently so an existing prepare that already
+    // carries the command sync still gains the agent sync on the next bootstrap
+    // (and both are idempotent — a prepare carrying both is left untouched).
+    let next = prepare;
+    if (!next.includes('sync-claude-commands.js')) {
+      next = `${next} && ${SYNC_COMMAND}`;
+    }
+    if (!next.includes('sync-claude-agents.js')) {
+      next = `${next} && ${SYNC_AGENTS_COMMAND}`;
+    }
+    if (next !== prepare) {
+      pkg.scripts.prepare = next;
+      outcomes.scriptsPrepare = 'appended';
+    }
   }
   // Expose a discoverable `npm run bootstrap` alias for the framework
   // setup command. An operator-defined `bootstrap` script always wins —
@@ -238,6 +261,7 @@ export function ensurePackageJson(ctx) {
   const mutated =
     outcomes.created ||
     outcomes.scriptsSyncCommands === 'added' ||
+    outcomes.scriptsSyncAgents === 'added' ||
     outcomes.scriptsPrepare !== 'already-present' ||
     outcomes.scriptsBootstrap === 'added';
   if (mutated) writeJson(pkgPath, pkg, fsImpl);
@@ -482,25 +506,39 @@ function ensureIssueFormsPhase(ctx) {
  */
 export function runSyncCommands(ctx) {
   const { spawnImpl = defaultSpawnSync } = ctx;
-  const script = path.join(
+  const scriptsDir = path.join(
     ctx.agentRoot ?? path.join(ctx.projectRoot, '.agents'),
     'scripts',
-    'sync-claude-commands.js',
   );
-  const result = spawnImpl(process.execPath, [script], {
-    cwd: ctx.projectRoot,
-    encoding: 'utf8',
-  });
-  if (result.status !== 0) {
-    throw new Error(
-      `[Bootstrap] sync-claude-commands.js failed (exit ${result.status}): ${(
-        result.stderr ?? ''
-      )
-        .trim()
-        .slice(0, 400)}`,
+  // Both projections run here (Epic #4478, M7-B): the command tree AND the
+  // role-scoped agent tree, so `mandrel sync` / the postinstall path
+  // materializes `.claude/agents/*.md` alongside `.claude/commands/*.md`.
+  const projections = [
+    { label: 'sync-claude-commands.js', script: 'sync-claude-commands.js' },
+    { label: 'sync-claude-agents.js', script: 'sync-claude-agents.js' },
+  ];
+  const stdouts = [];
+  for (const { label, script } of projections) {
+    const result = spawnImpl(
+      process.execPath,
+      [path.join(scriptsDir, script)],
+      {
+        cwd: ctx.projectRoot,
+        encoding: 'utf8',
+      },
     );
+    if (result.status !== 0) {
+      throw new Error(
+        `[Bootstrap] ${label} failed (exit ${result.status}): ${(
+          result.stderr ?? ''
+        )
+          .trim()
+          .slice(0, 400)}`,
+      );
+    }
+    stdouts.push((result.stdout ?? '').trim());
   }
-  return { ok: true, stdout: (result.stdout ?? '').trim() };
+  return { ok: true, stdout: stdouts.filter(Boolean).join('\n') };
 }
 
 /**

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

@@ -4,11 +4,11 @@
  * Asserts that `git config core.bare` on the main checkout is NOT set
  * to `true`. This guards the old failure mode where an `npm test` path
  * mis-set `core.bare=true` on the main checkout, after which
- * `story-close.js`'s post-rebase `git checkout` aborted with
+ * `single-story-close.js`'s post-rebase `git checkout` aborted with
  * `fatal: this operation must be run in a work tree`. `cleanGitEnv`
  * already lands the live fix; this check is the regression guard.
  *
- * Severity is `blocker` because story-close cannot recover on its own
+ * Severity is `blocker` because single-story-close cannot recover on its own
  * — the operator must run `git config --unset core.bare` (or rely on
  * `cleanGitEnv` to do it before the rebase). The check is
  * refuse-and-print: the `fixCommand` is the literal unset, and the

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

@@ -2,7 +2,8 @@
  * checks/index.js — Discovery-based registry + runner for self-healing checks.
  *
  * This module is the single entry point for every consumer surface that
- * runs checks (preflight guards at `epic-deliver.js` / `story-close.js`, the
+ * runs checks (preflight guards at `single-story-close.js` and
+ * `mandrel-update-preflight.js`, the
  * `npm test` wrapper, the `diagnose.js` CLI viewer, and the retro hook in
  * `retro-runner.js`). Each surface calls `runChecks({ scope, autoFix, state })`
  * with its own scope and gets back `{ findings, fixed }`.