mandrel 1.76.0 → 1.77.0

package/.agents/scripts/lib/orchestration/project-meta-cache.js

@@ -0,0 +1,238 @@
+/**
+ * project-meta-cache — on-disk cache for repo-invariant GitHub Projects v2
+ * board metadata (Story #4252).
+ *
+ * Every `agent::*` label flip routes through `transitionTicketState` →
+ * `ColumnSync.sync`, which must resolve the board's `{ projectId, fieldId,
+ * options }` before issuing the Status mutation. Single-story delivery
+ * performs each flip in a *separate cold CLI process* (init → executing,
+ * close → closing, confirm-merge → done, plus `resync-status-column`), so
+ * the in-process `_meta` cache is always empty and every flip re-pays
+ * `resolveProjectMeta` + an item-id lookup + the mutation (~3 GraphQL
+ * round-trips).
+ *
+ * The board metadata is **repo-invariant** — it changes only when the
+ * Status single-select field is reconfigured — so it is a prime candidate
+ * for an on-disk cache that survives across the cold processes. This module
+ * persists the resolved metadata to a small JSON file under the resolved
+ * `tempRoot`, keyed by `owner/projectNumber`, carrying a TTL. Correctness
+ * is bounded by "the mutation still validates against the live board": a
+ * stale entry at worst causes one failed mutation, which the caller treats
+ * as a signal to invalidate the entry and re-resolve — never a wrong write.
+ *
+ * Layout: `<tempRoot>/cache/project-meta.json`, a single JSON object keyed
+ * by `<owner>/<projectNumber>`:
+ *
+ *   {
+ *     "dsj1984/1": {
+ *       "cachedAt": 1718000000000,
+ *       "projectId": "PVT_…",
+ *       "fieldId": "PVTSSF_…",
+ *       "options": { "Todo": "abc", "In Progress": "def", "Done": "ghi" }
+ *     }
+ *   }
+ *
+ * The `options` map is serialised as a plain object and re-hydrated into a
+ * `Map<name, id>` on read so the ColumnSync call site is identical whether
+ * the metadata came from the disk cache or a live resolve.
+ *
+ * The cache file lives under `tempRoot`, which is gitignored
+ * (`temp/` in `.gitignore`), so it introduces no new tracked artifact.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { anchorTempRoot, tempRootFrom } from '../config/temp-paths.js';
+
+/**
+ * Default time-to-live for a cached board-metadata entry, in milliseconds.
+ * Board metadata is repo-invariant (it only changes on a manual Status
+ * field reconfiguration), so a generous TTL is safe — and a stale entry is
+ * self-healing via invalidate-on-error regardless. One hour comfortably
+ * spans a single `/single-story-deliver` run's four cold flips while still
+ * forcing a periodic re-resolve.
+ */
+const DEFAULT_META_TTL_MS = 60 * 60 * 1000;
+
+/**
+ * Resolve the path to the on-disk project-meta cache file under the
+ * (anchored) resolved `tempRoot`. A relative `tempRoot` is anchored to the
+ * main checkout root so a worktree child and the main-checkout host
+ * converge on the same file (Story #3900 semantics, reused here).
+ *
+ * @param {object} [config] Optional resolved config bag. Omitted → framework
+ *   default (`temp`).
+ * @returns {string}
+ */
+function projectMetaCachePath(config) {
+  return path.join(
+    anchorTempRoot(tempRootFrom(config)),
+    'cache',
+    'project-meta.json',
+  );
+}
+
+/**
+ * Build the per-board cache key from `(owner, projectNumber)`.
+ *
+ * @param {string|null|undefined} owner
+ * @param {number|string|null|undefined} projectNumber
+ * @returns {string|null} `<owner>/<projectNumber>`, or null when either part
+ *   is missing (an un-keyable board — caller skips the cache).
+ */
+function projectMetaCacheKey(owner, projectNumber) {
+  if (!owner || projectNumber === null || projectNumber === undefined) {
+    return null;
+  }
+  return `${owner}/${projectNumber}`;
+}
+
+/**
+ * Read the entire cache file as a plain object. Returns an empty object on
+ * any read/parse failure (missing file, malformed JSON) so the caller treats
+ * a corrupt cache as a cold miss rather than throwing.
+ *
+ * @param {string} filePath
+ * @returns {Record<string, object>}
+ */
+function readCacheFile(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Read a cached metadata entry for `(owner, projectNumber)`.
+ *
+ * Returns the re-hydrated `{ projectId, fieldId, options: Map }` descriptor
+ * when a fresh (within TTL) entry exists, or `null` on a miss / expired /
+ * malformed entry. Never throws — a read failure is a cache miss.
+ *
+ * @param {{
+ *   owner?: string|null,
+ *   projectNumber?: number|string|null,
+ *   config?: object,
+ *   ttlMs?: number,
+ *   now?: number,
+ * }} opts
+ * @returns {{ projectId: string, fieldId: string, options: Map<string,string> } | null}
+ */
+export function readProjectMetaCache(opts = {}) {
+  const key = projectMetaCacheKey(opts.owner, opts.projectNumber);
+  if (!key) return null;
+  const ttlMs = opts.ttlMs ?? DEFAULT_META_TTL_MS;
+  const now = opts.now ?? Date.now();
+
+  const filePath = projectMetaCachePath(opts.config);
+  const store = readCacheFile(filePath);
+  const entry = store[key];
+  if (!entry || typeof entry !== 'object') return null;
+
+  const { cachedAt, projectId, fieldId, options } = entry;
+  if (
+    typeof cachedAt !== 'number' ||
+    typeof projectId !== 'string' ||
+    typeof fieldId !== 'string' ||
+    !options ||
+    typeof options !== 'object'
+  ) {
+    return null;
+  }
+  // TTL check — an expired entry is a miss so the caller re-resolves.
+  if (now - cachedAt > ttlMs) return null;
+
+  return {
+    projectId,
+    fieldId,
+    options: new Map(Object.entries(options)),
+  };
+}
+
+/**
+ * Persist a resolved metadata descriptor for `(owner, projectNumber)`.
+ *
+ * The `options` value may be a `Map<name,id>` or a plain object; it is
+ * normalised to a plain object on disk. Best-effort: any write failure is
+ * swallowed (the cache is a pure optimisation — a failed write just means
+ * the next process re-resolves). Writes the rest of the store back intact so
+ * sibling board entries are preserved.
+ *
+ * @param {{
+ *   owner?: string|null,
+ *   projectNumber?: number|string|null,
+ *   meta: { projectId: string, fieldId: string, options: Map<string,string>|Record<string,string> },
+ *   config?: object,
+ *   now?: number,
+ * }} opts
+ * @returns {boolean} true when the entry was written, false on a skip/failure.
+ */
+export function writeProjectMetaCache(opts = {}) {
+  const key = projectMetaCacheKey(opts.owner, opts.projectNumber);
+  if (!key) return false;
+  const meta = opts.meta;
+  if (
+    !meta ||
+    typeof meta.projectId !== 'string' ||
+    typeof meta.fieldId !== 'string'
+  ) {
+    return false;
+  }
+  const now = opts.now ?? Date.now();
+
+  const options =
+    meta.options instanceof Map
+      ? Object.fromEntries(meta.options)
+      : { ...(meta.options ?? {}) };
+
+  const filePath = projectMetaCachePath(opts.config);
+  try {
+    const store = readCacheFile(filePath);
+    store[key] = {
+      cachedAt: now,
+      projectId: meta.projectId,
+      fieldId: meta.fieldId,
+      options,
+    };
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Invalidate (delete) the cached entry for `(owner, projectNumber)`.
+ *
+ * Called when a GraphQL error fires against a board whose metadata came from
+ * the cache, so a mid-run board reconfiguration self-heals on the next flip
+ * (which re-resolves and re-writes). Best-effort and idempotent: a missing
+ * entry or unreadable file is a no-op. Returns true when an entry was
+ * actually removed.
+ *
+ * @param {{
+ *   owner?: string|null,
+ *   projectNumber?: number|string|null,
+ *   config?: object,
+ * }} opts
+ * @returns {boolean}
+ */
+export function invalidateProjectMetaCache(opts = {}) {
+  const key = projectMetaCacheKey(opts.owner, opts.projectNumber);
+  if (!key) return false;
+  const filePath = projectMetaCachePath(opts.config);
+  try {
+    const store = readCacheFile(filePath);
+    if (!(key in store)) return false;
+    delete store[key];
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/.agents/scripts/lib/orchestration/reassert-status-column.js

@@ -89,6 +89,7 @@ function defaultSleep(ms) {
  *   pollAttempts?: number,
  *   pollDelayMs?: number,
  *   sleepFn?: (ms: number) => Promise<void>,
+ *   config?: object,
  * }} args
  * @returns {Promise<{ status: string, column?: string, reason?: string, attempts?: number }>}
  */
@@ -100,6 +101,7 @@ export async function reassertStatusColumn(args) {
     pollAttempts = DEFAULT_POLL_ATTEMPTS,
     pollDelayMs = DEFAULT_POLL_DELAY_MS,
     sleepFn = defaultSleep,
+    config,
   } = args ?? {};
   if (!provider || typeof provider.getTicket !== 'function') {
     throw new TypeError(
@@ -128,7 +130,7 @@ export async function reassertStatusColumn(args) {
   if (!targetColumn) {
     return { status: 'skipped', reason: 'no-matching-label' };
   }
-  const sync = new ColumnSync({ provider, logger: logger ?? console });
+  const sync = new ColumnSync({ provider, logger: logger ?? console, config });
 
   // First attempt — always fires through ColumnSync.sync so the skip
   // paths (no-project / no-meta / no-option-<col> / not-on-project)

package/.agents/scripts/lib/orchestration/single-story-close/phases/auto-merge.js

@@ -12,9 +12,21 @@
  * inject a synchronous fake; the default runner delegates to
  * `gh.pr.merge`, which spawns through the classified, typed-error
  * surface instead of a raw `execFileSync('gh', …)` call.
+ *
+ * Story #4282 made arming robust when the base branch is checked out by a
+ * git worktree. The `--delete-branch` flag makes `gh` shell out to local
+ * `git` (including a `git checkout <base>`); from a per-Story worktree cwd
+ * that collides with the base branch already checked out by the primary
+ * worktree (`fatal: '<base>' is already used by worktree`). We now resolve
+ * the arm cwd to the **primary worktree root** (which holds the base
+ * branch) via `resolveAutoMergeArmCwd`, so `gh`'s local checkout is a
+ * no-op. `--delete-branch` is preserved verbatim, so the PR head branch is
+ * still deleted on merge without depending on the repo's auto-delete
+ * setting. Resolution is non-fatal — it degrades to the original cwd.
  */
 
 import { gh as defaultGh } from '../../../gh-exec.js';
+import { resolveAutoMergeArmCwd } from '../../auto-merge-cwd.js';
 
 /**
  * Enable GitHub native auto-merge on the PR. Non-fatal.
@@ -24,11 +36,22 @@ import { gh as defaultGh } from '../../../gh-exec.js';
  *   prNumber: number,
  *   gh?: ReturnType<typeof import('../../../gh-exec.js').createGh>,
  *   runner?: (args: string[], opts: object) => ({ status: number, stdout?: string, stderr?: string } | Promise<{ status: number, stdout?: string, stderr?: string }>),
+ *   resolveArmCwd?: (cwd: string) => string,
  * }} opts
  * @returns {Promise<{ enabled: boolean, reason?: string }>}
  */
-export async function enableAutoMergeWith({ cwd, prNumber, gh, runner }) {
+export async function enableAutoMergeWith({
+  cwd,
+  prNumber,
+  gh,
+  runner,
+  resolveArmCwd = resolveAutoMergeArmCwd,
+}) {
   const exec = runner ?? makeDefaultGhAutoMergeRunner(gh ?? defaultGh);
+  // Re-point the arm at the base-branch (primary) worktree so gh's
+  // `--delete-branch` local `git checkout <base>` cannot collide with the
+  // base branch already checked out by the primary worktree (Story #4282).
+  const armCwd = resolveArmCwd(cwd);
   try {
     const result = await exec(
       [
@@ -39,7 +62,7 @@ export async function enableAutoMergeWith({ cwd, prNumber, gh, runner }) {
         '--squash',
         '--delete-branch',
       ],
-      { cwd },
+      { cwd: armCwd },
     );
     if (result.status === 0) return { enabled: true };
     return {

package/.agents/scripts/lib/orchestration/single-story-close/phases/close-validation.js

@@ -6,43 +6,60 @@
  * Epic-attached Stories so the experience matches — only the baseline
  * ref changes (`main`, not `epic/<id>`).
  *
- * Standalone Stories have no parent Epic, so there's no per-Epic path to
- * scope a `validation-evidence.json` under. Pass `epicId: null` (not `0`)
- * so the `evidenceActive` predicate in `runCloseValidation` short-circuits
- * cleanly. `0` is rejected downstream by `validation-evidence.evidencePath`
- * (which requires a positive integer epicId) and aborts the whole gate
- * chain.
+ * Standalone evidence keyspace (Story #4250). Standalone Stories have no
+ * parent Epic, so they cannot scope a `validation-evidence.json` under a
+ * `temp/epic-<id>/` tree. Rather than feed a null `epicId` into the
+ * Epic-keyed path (which structurally disabled the evidence cache and
+ * forced every re-run — base-sync conflict, review remediation, baseline
+ * absorb — to re-execute ALL gates including the coverage suite), the
+ * standalone close now passes `standalone: true`. `runCloseValidation`
+ * then anchors the cache on the Story id alone at
+ * `temp/standalone/stories/story-<id>/validation-evidence.json`, so a
+ * second close at unchanged HEAD short-circuits the already-passed gates.
  *
- * The trade-off is that re-runs of close on the same SHA don't hit the
- * evidence cache for standalone Stories; that's acceptable until/unless
- * the standalone path warrants its own evidence keyspace.
+ * Format-autofix self-heal (Story #4250). The Epic path runs
+ * `runScopedFormatAutofix` before the check-only gates so benign JSON/YAML
+ * drift the formatter can fix is folded into a `fix(story-close):` commit
+ * rather than hard-failing the format gate. The standalone path now does
+ * the same, with `baseBranch` as the diff anchor and the Story worktree as
+ * the commit target.
  *
- * `runCloseValidation` and `buildDefaultGates` are accepted as injected
- * dependencies so the parent CLI's cache-busted bindings win in tests
- * that mock the upstream module URLs.
+ * `runCloseValidation`, `buildDefaultGates`, and `runScopedFormatAutofix`
+ * are accepted as injected dependencies so the parent CLI's cache-busted
+ * bindings win in tests that mock the upstream module URLs.
  */
 
 import { buildDefaultGates as defaultBuildDefaultGates } from '../../../close-validation/gates.js';
 import { runCloseValidation as defaultRunCloseValidation } from '../../../close-validation/runner.js';
 import { Logger } from '../../../Logger.js';
+import { runScopedFormatAutofix as defaultRunScopedFormatAutofix } from '../../story-close/format-autofix.js';
 
 /**
  * Run the close-validation gate chain. Throws on first gate failure.
  *
+ * Order (Story #4250): format-autofix self-heal → close-validation gates.
+ * The autofix step scopes the formatter to the `baseBranch...storyBranch`
+ * diff, commits any fix on the Story branch inside the Story worktree, and
+ * is best-effort — a missing `storyBranch` (resume/legacy callers) skips it
+ * with a log line rather than failing.
+ *
  * Gates are built from the canonical resolved config (`buildDefaultGates`
  * reads `project.commands` and `delivery.quality.gates.crap.enabled`); the
  * `baseBranch` is forwarded as the gate `epicBranch` so the format gate's
- * changed-file scope anchors on it.
+ * changed-file scope anchors on it. `standalone: true` routes the evidence
+ * cache to the storyId-anchored keyspace.
  *
  * @param {{
  *   cwd: string,
  *   worktreePath: string|null,
  *   config: object,
  *   baseBranch: string,
+ *   storyBranch?: string,
  *   storyId: number,
  *   progress: (tag: string, msg: string) => void,
  *   runCloseValidation?: typeof defaultRunCloseValidation,
  *   buildDefaultGates?: typeof defaultBuildDefaultGates,
+ *   runScopedFormatAutofix?: typeof defaultRunScopedFormatAutofix,
  * }} args
  */
 export async function runCloseValidationPhase({
@@ -50,11 +67,57 @@ export async function runCloseValidationPhase({
   worktreePath,
   config,
   baseBranch,
+  storyBranch,
   storyId,
   progress,
   runCloseValidation = defaultRunCloseValidation,
   buildDefaultGates = defaultBuildDefaultGates,
+  runScopedFormatAutofix = defaultRunScopedFormatAutofix,
 }) {
+  // Story #4250 — format-autofix self-heal before the check-only gates.
+  // Mirrors the Epic path (story-close/phases/gates.js): the formatter is
+  // scoped to the baseBranch...storyBranch diff, and any fix is committed on
+  // the Story branch in the Story worktree. Skipped (with a log) when no
+  // storyBranch is available so resume/legacy callers don't trip a throw.
+  if (storyBranch) {
+    progress(
+      'FORMAT',
+      `Running scoped format-autofix on ${baseBranch}...${storyBranch}${worktreePath ? ` in ${worktreePath}` : ''}...`,
+    );
+    // Best-effort self-heal: a failure to even compute the diff (e.g. a
+    // missing ref) must never abort close — the format check gate downstream
+    // is the source of truth for "is the tree formatted". We log and proceed.
+    try {
+      const autofix = runScopedFormatAutofix({
+        cwd,
+        worktreePath,
+        storyId,
+        epicBranch: baseBranch,
+        storyBranch,
+        config,
+        logger: Logger,
+      });
+      if (autofix?.committed) {
+        progress(
+          'FORMAT',
+          `✅ Auto-applied format fix committed as ${autofix.sha} on ${storyBranch}.`,
+        );
+      } else {
+        progress(
+          'FORMAT',
+          `⏭ No format-autofix commit (${autofix?.reason ?? 'clean'}).`,
+        );
+      }
+    } catch (err) {
+      progress(
+        'FORMAT',
+        `⚠️ scoped format-autofix failed (close continues; format gate is authoritative): ${err?.message ?? err}`,
+      );
+    }
+  } else {
+    progress('FORMAT', '⏭ Skipped scoped format-autofix (no story branch).');
+  }
+
   progress(
     'VALIDATE',
     `Running close-validation gates against baseline ${baseBranch}${worktreePath ? ` in ${worktreePath}` : ''}...`,
@@ -65,7 +128,10 @@ export async function runCloseValidationPhase({
     gates: buildDefaultGates({ config, epicBranch: baseBranch }),
     log: (m) => Logger.info(m),
     storyId,
-    epicId: null,
+    // Story #4250 — standalone storyId-anchored evidence keyspace. No
+    // epicId; the standalone flag routes the cache to
+    // temp/standalone/stories/story-<id>/validation-evidence.json.
+    standalone: true,
   });
   if (!validation.ok) {
     const [first] = validation.failed;

package/.agents/scripts/lib/orchestration/single-story-close/runner.js

@@ -67,6 +67,7 @@ async function runPrePushPhases({
       worktreePath,
       config,
       baseBranch,
+      storyBranch,
       storyId,
       progress,
       runCloseValidation,
@@ -157,6 +158,41 @@ async function releaseLease({
   }
 }
 
+/**
+ * Story #4257 — run a blocked-prone phase and, if it throws, release the
+ * assignee-lease best-effort BEFORE re-throwing the original error.
+ *
+ * The two recoverable-blocked close exits (base-sync conflict in
+ * `runBaseSyncPhase`, and a critical-blocker review halt in
+ * `openAndReviewPr`) throw before the clean-close lease release at the
+ * tail of `runSingleStoryClose`, stranding the operator's lease until its
+ * TTL expires. That fail-closed-refuses a different operator who picks up
+ * the blocked Story — exactly the hand-off case. Releasing here closes
+ * that gap.
+ *
+ * The original throw is preserved verbatim (per
+ * `rules/orchestration-error-handling.md` — throw, never `Logger.fatal`),
+ * so the CLI boundary still maps it to a non-zero exit; the lease release
+ * must not swallow it. `releaseLease` is itself best-effort and never
+ * throws, so it cannot mask the real failure. Fail-closed re-acquire
+ * semantics are preserved: `releaseStoryLease` no-ops when the operator no
+ * longer holds the claim, and a self-held re-acquire on a re-run still
+ * succeeds against the now-unclaimed ticket.
+ *
+ * @template T
+ * @param {() => Promise<T>} run The blocked-prone phase to execute.
+ * @param {{ provider: object, storyId: number, config: object, injectedReleaseLease?: Function }} leaseArgs
+ * @returns {Promise<T>}
+ */
+async function releaseLeaseOnBlock(run, leaseArgs) {
+  try {
+    return await run();
+  } catch (err) {
+    await releaseLease(leaseArgs);
+    throw err;
+  }
+}
+
 function closeResult({
   storyId,
   storyBranch,
@@ -236,27 +272,45 @@ export async function runSingleStoryClose({
     config,
     storyId: options.storyId,
   });
-  await runPrePushPhases({
-    ...options,
-    config,
-    baseBranch,
-    storyBranch,
+  // Story #4257 — the base-sync conflict and review-critical exits throw
+  // before the clean-close lease release at the tail of this function.
+  // Wrap both blocked-prone phases so the lease is released best-effort
+  // before the throw propagates; the original error is preserved.
+  const leaseArgs = {
     provider,
-    worktreePath,
-    injectedSync,
-    injectedGitSpawn,
-  });
-
-  const { prUrl, prNumber } = await openAndReviewPr({
-    cwd: options.cwd,
-    story,
     storyId: options.storyId,
-    storyBranch,
-    baseBranch,
-    provider,
-    injectedGh,
-    injectedRunCodeReview,
-  });
+    config,
+    injectedReleaseLease,
+  };
+  await releaseLeaseOnBlock(
+    () =>
+      runPrePushPhases({
+        ...options,
+        config,
+        baseBranch,
+        storyBranch,
+        provider,
+        worktreePath,
+        injectedSync,
+        injectedGitSpawn,
+      }),
+    leaseArgs,
+  );
+
+  const { prUrl, prNumber } = await releaseLeaseOnBlock(
+    () =>
+      openAndReviewPr({
+        cwd: options.cwd,
+        story,
+        storyId: options.storyId,
+        storyBranch,
+        baseBranch,
+        provider,
+        injectedGh,
+        injectedRunCodeReview,
+      }),
+    leaseArgs,
+  );
   const { autoMergeEnabled, autoMergeReason } = await runAutoMergePhase({
     cwd: options.cwd,
     prNumber,
@@ -284,12 +338,7 @@ export async function runSingleStoryClose({
     progress,
     WorktreeManager,
   });
-  const leaseReleased = await releaseLease({
-    provider,
-    storyId: options.storyId,
-    config,
-    injectedReleaseLease,
-  });
+  const leaseReleased = await releaseLease(leaseArgs);
   const result = closeResult({
     storyId: options.storyId,
     storyBranch,

package/.agents/scripts/lib/orchestration/story-close/phases/locked-pipeline.js

@@ -19,6 +19,7 @@
  */
 
 import { Logger } from '../../../Logger.js';
+import { hasInlineAcceptance } from '../../../story-init/task-graph-builder.js';
 import { fetchChildTickets } from '../../../story-lifecycle.js';
 import { createPhaseTimer } from '../../../util/phase-timer.js';
 import {
@@ -197,7 +198,15 @@ export async function runStoryCloseLocked(args) {
       logger: Logger,
     });
 
-  const tasks = await fetchChildTickets(provider, storyId);
+  // Story #4251 — mirror the init-side short-circuit: a 2-tier Story (inline
+  // acceptance on its body) has no children, so skip the `fetchChildTickets`
+  // probe (empty sub-issues GraphQL query + never-matching `/search/issues`
+  // scan) entirely. The cascade target is just the Story itself. A body
+  // lacking inline acceptance still enumerates children for legacy / Epic
+  // callers.
+  const tasks = hasInlineAcceptance(story?.body)
+    ? []
+    : await fetchChildTickets(provider, storyId);
   provider.primeTicketCache([story, ...tasks]);
   progress('TICKETS', `Found ${tasks.length} child ticket(s)`);
 

package/.agents/scripts/lib/orchestration/ticket-validator-conflicts.js

@@ -1,6 +1,49 @@
+import { parse as parseStoryBody } from '../story-body/story-body.js';
 import { collectStoryAssumptionEntries } from './file-assumptions.js';
 import { computeStoryReachability } from './story-reachability.js';
 
+/**
+ * Normalize a Story so its `body` is the structured object the conflict
+ * passes scan, mirroring `validateAcFreshness` /
+ * `collectStoryAssumptionEntries` (Story #3302) and the sizing gate's
+ * `resolveStoryBody` (Story #4271).
+ *
+ * The decomposer emits `body` as the canonical serialized **string**, but
+ * the conflict passes (`indexConsumers`, `indexAssumptionEntries`,
+ * `computeMissingBddScaffoldFindings`, the sibling-create scan in
+ * `computeRegistryFindings`, and the legacy-bullet branch of
+ * `collectStoryProducerPaths`) historically read `story.body` only when it
+ * was already an object — so on the production string shape the
+ * `implicit-cross-story-dep`, `fan-out`, registry, and `missing-bdd-scaffold`
+ * findings emitted nothing. Parsing the body once at the entry point and
+ * threading the normalized Story through every pass restores parity.
+ *
+ * `collectStoryAssumptionEntries` already parses string bodies itself, so a
+ * normalized object body round-trips through it unchanged. The returned Story
+ * keeps every other field (notably `slug` and `depends_on`) intact.
+ *
+ *   - **string body** → parsed via `parseStoryBody`; an unparseable string
+ *     yields `body: null` (the passes degrade to "no structured signal",
+ *     never throw mid-validation).
+ *   - **object body** → returned verbatim.
+ *   - **null / other** → `body: null`.
+ *
+ * @param {object} story
+ * @returns {object} A shallow clone of `story` with a structured `body`.
+ */
+function normalizeStoryBody(story) {
+  const body = story?.body;
+  if (typeof body === 'string') {
+    if (body.trim().length === 0) return { ...story, body: null };
+    try {
+      return { ...story, body: parseStoryBody(body).body };
+    } catch {
+      return { ...story, body: null };
+    }
+  }
+  return story;
+}
+
 /**
  * Cross-Story path-conflict & implicit-dependency findings.
  *
@@ -661,7 +704,11 @@ function computeFanOutFindings({
  */
 export function computeConflictFindings({ stories, policy } = {}) {
   const merged = { ...DEFAULT_POLICY, ...(policy ?? {}) };
-  const storyList = stories ?? [];
+  // Story #4271: normalize every Story's body to its structured object form
+  // once, up front, so the canonical serialized **string** shape the
+  // decomposer emits is scanned at parity with the pre-serialize object
+  // shape across every conflict pass.
+  const storyList = (stories ?? []).map(normalizeStoryBody);
   const producers = indexProducers(storyList);
   const consumers = indexConsumers(storyList, producers);
   const reach = computeStoryReachability(storyList);