mandrel 1.94.0 → 2.1.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

@@ -53,25 +53,10 @@ export const MAINTAINABILITY_EXCLUSIONS = Object.freeze(
     // escomplex: same "pattern" parse failure as acceptance-spec-reconciler;
     // both files share the lifecycle-lint regex-driven scan helpers.
     '.agents/scripts/check-lifecycle-lint.js',
-    // escomplex: "traveler[node.type] is not a function" — AST node type the
-    // upstream traveler table is missing (top-level await / private fields).
-    '.agents/scripts/lib/orchestration/epic-cleanup.js',
-    // escomplex: same "traveler[node.type] is not a function" — emitted by
-    // the spec-reconciler's `async` operator-comment IIFE.
-    '.agents/scripts/lib/orchestration/epic-spec-reconciler-ops.js',
     // 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
-    // epic-plan-spec doesn't poison the global rollup.
-    '.agents/scripts/lib/orchestration/epic-plan-spec/phases/spec-freshness.js',
-    // escomplex: "Cannot read properties of undefined (reading 'pattern')" —
     // the audit-to-stories parser reuses the same regex-property scan
     // patterns as acceptance-spec-reconciler.
     '.agents/scripts/lib/audit-to-stories/parse-audit-md.js',

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/ci-workflow-template.js

@@ -13,14 +13,18 @@
  *      framework default at the next bump. The push-to-main job still passes
  *      `--full-scope` so a self-diff doesn't degrade to "no files in diff".
  *
- *   2. **Pass `--epic-ref` where the firing site is Epic-aware.** Inside
- *      `/deliver` the close-validation chain already threads
- *      `--epic-ref epic/<id>`; on CI the equivalent surface is the PR's
- *      base branch. The template wires `--epic-ref ${EPIC_REF}` through an
- *      env var the workflow computes from `github.head_ref` (story-N
- *      branches name their Epic in the PR title or via the dispatch
- *      manifest). When `EPIC_REF` is empty, both gates fall through to the
- *      `main`-tracked baseline — so the env-var expansion is always safe.
+ *   2. **Pin the baseline read to the PR's base branch via `BASELINE_REF`.**
+ *      Inside `/deliver` the close-validation chain sets the same env var
+ *      (`close-validation/gates.js` → `BASELINE_REF: origin/<baseBranch>`);
+ *      on CI the equivalent surface is the PR's base branch. This is an
+ *      ENV VAR, not a CLI flag: `check-baselines.js` resolves it through
+ *      `resolveDispatchScope`, and the `--epic-ref` flag this template used
+ *      to pass never existed on it — it was left over from the separate
+ *      `check-crap.js` / `check-maintainability.js` CLIs that were unified
+ *      away, and it named the ref `epic/<base>`, a branch the Story-only
+ *      model never creates. When `BASELINE_REF` is empty (push-to-base,
+ *      where there is no base to compare against) both gates fall through to
+ *      the working-tree baseline, so the expansion is always safe.
  *
  * The renderer is a pure string template so the integration test can assert
  * on its exact shape without instantiating a YAML parser.
@@ -61,19 +65,15 @@ export function renderCiWorkflow(opts = {}) {
         # Diff-scoped via the framework default (Story #1394 flipped
         # --changed-since to '${baseRef}'). On PRs we let the default win;
         # on push-to-main we pass --full-scope so a self-diff doesn't
-        # collapse to an empty file set. EPIC_REF is set when the head ref
-        # points at a story branch under an Epic — the gate then reads the
-        # per-Epic baseline snapshot via baseline-loader.readBaselineAtRef.
+        # collapse to an empty file set. BASELINE_REF makes the gate read
+        # the baseline at the base branch tip via
+        # baseline-loader.readBaselineAtRef.
         env:
-          EPIC_REF: \${{ env.EPIC_REF }}
+          BASELINE_REF: \${{ env.BASELINE_REF }}
         run: |
           mkdir -p temp
           if [[ "\${{ github.event_name }}" == "pull_request" ]]; then
-            if [[ -n "\${EPIC_REF}" ]]; then
-              npm run crap:check -- --epic-ref "\${EPIC_REF}" --json temp/crap-report.json
-            else
-              npm run crap:check -- --json temp/crap-report.json
-            fi
+            npm run crap:check -- --json temp/crap-report.json
           else
             npm run crap:check -- --full-scope --json temp/crap-report.json
           fi
@@ -112,15 +112,14 @@ jobs:
     permissions:
       contents: read
     env:
-      # Story #1120: when the PR head ref names an Epic story branch
-      # (story-N or story/epic-<id>/<n>), the gate CLIs read the canonical
-      # main baseline at the Epic branch HEAD via --epic-ref (git show).
-      # Empty when the head ref is not an Epic story branch — both gates
-      # fall through to the working-tree baseline, so the env-var
-      # expansion is always safe. Per-epic ratchet snapshots themselves
-      # live under temp/epic/<id>/baselines/ (Story #1467) — ephemeral
-      # scratch state, never read by this CI gate.
-      EPIC_REF: \${{ github.head_ref && contains(github.head_ref, 'story') && format('epic/{0}', github.event.pull_request.base.ref) || '' }}
+      # Story #1120: on a PR the gate CLIs read the canonical baseline at
+      # the BASE branch tip via --baseline-ref (git show), not from the
+      # PR head's working tree — a branch that edited its own baseline
+      # must not be allowed to grade itself against the edit.
+      # Empty on push-to-${baseRef} (there is no base to compare against),
+      # where both gates fall through to the working-tree baseline, so the
+      # env-var expansion is always safe.
+      BASELINE_REF: \${{ github.event_name == 'pull_request' && format('origin/{0}', github.event.pull_request.base.ref) || '' }}
       BASE_REF: ${baseRef}
     steps:
       - name: Checkout Code
@@ -147,16 +146,12 @@ jobs:
         # the project's BASE_REF, so PRs no longer pass --changed-since
         # explicitly. push-to-${baseRef} runs with --full-scope so the
         # diff-scoped default doesn't degrade to a self-diff (= empty file
-        # set). EPIC_REF carries the per-Epic snapshot when present.
+        # set). BASELINE_REF pins the baseline read to the base branch tip.
         env:
-          EPIC_REF: \${{ env.EPIC_REF }}
+          BASELINE_REF: \${{ env.BASELINE_REF }}
         run: |
           if [[ "\${{ github.event_name }}" == "pull_request" ]]; then
-            if [[ -n "\${EPIC_REF}" ]]; then
-              npm run maintainability:check -- --epic-ref "\${EPIC_REF}"
-            else
-              npm run maintainability:check
-            fi
+            npm run maintainability:check
           else
             npm run maintainability:check -- --full-scope
           fi

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/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'),