mandrel 1.94.0 → 2.0.0

package/.agents/scripts/check-prepush-recovery.js

@@ -3,7 +3,7 @@
  * check-prepush-recovery.js — gate decision for the pre-push coverage step.
  *
  * Story #3162. The pre-push hook normally runs `coverage-capture.js` +
- * `crap:check` on every push. During a `story-close.js` recovery (operator
+ * `crap:check` on every push. During a pre-v2 `story-close.js` recovery (operator
  * pushing `epic/<id>` to unblock a run after a merge-orchestrator failure),
  * a pre-existing coverage regression on `epic/<id>` — unrelated to the
  * Story under recovery — hard-blocks the push and forces a `--no-verify`

package/.agents/scripts/cleanup-repo-test-temp.js

@@ -20,7 +20,12 @@
 import { existsSync, readdirSync, rmSync } from 'node:fs';
 import path from 'node:path';
 import { runAsCli } from './lib/cli-utils.js';
-import { isReservedTestEpicTempDirName } from './lib/test-reserved-epic-temp-ids.js';
+
+const RESERVED_TEST_EPIC_TEMP_DIR = /^epic-999\d{3}$/;
+
+function isReservedTestEpicTempDirName(name) {
+  return RESERVED_TEST_EPIC_TEMP_DIR.test(name);
+}
 
 /**
  * @param {object} [opts]

package/.agents/scripts/lib/Logger.js

@@ -18,7 +18,6 @@
  *   - `silent`   → only `fatal` emits.
  *   - `info`     → default. Emits `info` and above; suppresses `debug`.
  *   - `verbose`  → emits everything (including `debug`).
- *   - `debug`    → alias for `verbose` (backward compatible).
  */
 /**
  * Recognized log levels, lowest-noise first. Anything outside this set
@@ -26,9 +25,7 @@
  *
  * @type {ReadonlySet<string>}
  */
-const VALID_LEVELS = Object.freeze(
-  new Set(['silent', 'info', 'verbose', 'debug']),
-);
+const VALID_LEVELS = Object.freeze(new Set(['silent', 'info', 'verbose']));
 
 /**
  * Process-wide level override. `null` means "no explicit override — read
@@ -50,7 +47,7 @@ let levelOverride = null;
  * the level branches react in-process, without a child process per level
  * (Story #3329).
  *
- * @returns {'silent'|'info'|'verbose'|'debug'}
+ * @returns {'silent'|'info'|'verbose'}
  */
 export function resolveLevel() {
   const raw = (
@@ -63,12 +60,12 @@ export function resolveLevel() {
 
 /**
  * Pin the process-wide log level, bypassing `AGENT_LOG_LEVEL`. Pass a
- * recognized level (`silent` / `info` / `verbose` / `debug`) to force it,
+ * recognized level (`silent` / `info` / `verbose`) to force it,
  * or `null` to clear the pin and restore env-driven resolution. An
  * unrecognized non-null value throws so callers cannot silently pin a
  * level that resolves to `info`.
  *
- * @param {('silent'|'info'|'verbose'|'debug')|null} level
+ * @param {('silent'|'info'|'verbose')|null} level
  * @returns {void}
  */
 export function setLevel(level) {
@@ -78,15 +75,14 @@ export function setLevel(level) {
   }
   if (typeof level !== 'string' || !VALID_LEVELS.has(level.toLowerCase())) {
     throw new RangeError(
-      `setLevel: level must be one of silent|info|verbose|debug or null (got ${level})`,
+      `setLevel: level must be one of silent|info|verbose or null (got ${level})`,
     );
   }
   levelOverride = level.toLowerCase();
 }
 
 function debugEnabled() {
-  const level = resolveLevel();
-  return level === 'verbose' || level === 'debug';
+  return resolveLevel() === 'verbose';
 }
 
 function infoEnabled() {

package/.agents/scripts/lib/audit-suite/runner.js

@@ -189,8 +189,8 @@ export async function runAuditSuite({
   injectedRules,
   injectedWriteArtifact,
 }) {
-  const { agentSettings } = resolveConfig();
-  const paths = getPaths({ agentSettings });
+  const config = resolveConfig();
+  const paths = getPaths(config);
   const callerSubstitutions = substitutions ?? {};
   const rules = injectedRules ?? (await loadRules(paths));
 

package/.agents/scripts/lib/audit-suite/selector.js

@@ -109,10 +109,10 @@ export const LENS_TIERS = Object.freeze(['local', 'cumulative', 'global']);
  * @throws {Error} When the manifest cannot be read or parsed.
  */
 function readAuditRulesSync() {
-  const { agentSettings } = resolveConfig();
+  const config = resolveConfig();
   const rulesPath = path.join(
     PROJECT_ROOT,
-    getPaths({ agentSettings }).schemasRoot,
+    getPaths(config).schemasRoot,
     'audit-rules.json',
   );
   try {
@@ -160,7 +160,7 @@ export function resolveLensTier(lens) {
  * every path) matches every change set here, so its concern is verified at
  * BOTH innermost tiers — the
  * write-time checklist threading and this Story-scope lens pass — and excluded
- * from Epic close (a local lens is dropped by {@link selectEpicCloseLenses}).
+ * from the retired Epic-close roster (local lenses stay Story-scope only).
  * A local lens with an empty `filePatterns` list matches nothing here, so a
  * diff matching no local lens's patterns yields an empty roster and adds no
  * lens work.
@@ -300,12 +300,12 @@ export async function selectAudits({
   gitTimeoutMsOverride,
   gateModeOpts,
 }) {
-  const { agentSettings } = resolveConfig();
+  const config = resolveConfig();
   const timeoutMs = gitTimeoutMsOverride ?? DEFAULT_GIT_TIMEOUT_MS;
 
   const rulesPath = path.join(
     PROJECT_ROOT,
-    getPaths({ agentSettings }).schemasRoot,
+    getPaths(config).schemasRoot,
     'audit-rules.json',
   );
   let rulesData;

package/.agents/scripts/lib/audit-to-stories/{seed-epic-from-findings.js → seed-from-findings.js}

@@ -1,17 +1,17 @@
 /**
- * lib/audit-to-stories/seed-epic-from-findings.js
+ * lib/audit-to-stories/seed-from-findings.js
  *
- * Build the `--idea`-shaped seed markdown that `/plan` Phase 1
- * consumes when the operator picks the Single-Epic grouping mode.
+ * Build the `/plan --seed`-shaped one-pager markdown that the audit-to-
+ * stories Single-plan grouping path emits for `/plan` to consume.
  *
- * The seed renders the canonical one-pager sections so the idea-refinement
- * skill can sharpen it without having to invent context:
+ * The seed renders the canonical one-pager sections so the authoring
+ * pass can sharpen it without having to invent context:
  *   - Problem Statement (aggregated severity profile)
  *   - Recommended Direction (rollup of recommendations by dimension)
  *   - Key Assumptions (carries the source-report links forward)
  *   - MVP Scope (the proposed Stories, one bullet per group)
- *   - Key Files (explicit file paths so /plan Phase 7 decompose
- *     has concrete anchors)
+ *   - Key Files (explicit file paths so `/plan` authoring has concrete
+ *     anchors)
  *   - Not Doing (out-of-scope items by convention)
  *
  * Pure: returns a string. The caller decides where to persist it.
@@ -112,14 +112,14 @@ function formatKeyAssumptions(sourceReports) {
  * @param {string[]} params.sourceReports — list of source report paths.
  * @returns {string}
  */
-export function buildEpicSeedMarkdown({ groups, findings, sourceReports }) {
+export function buildPlanSeedMarkdown({ groups, findings, sourceReports }) {
   if (
     !Array.isArray(groups) ||
     !Array.isArray(findings) ||
     !Array.isArray(sourceReports)
   ) {
     throw new Error(
-      'buildEpicSeedMarkdown: groups, findings, sourceReports must all be arrays',
+      'buildPlanSeedMarkdown: groups, findings, sourceReports must all be arrays',
     );
   }
   const problem = formatProblemStatement(findings);

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/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 }`.