mandrel 1.76.0 → 1.78.0

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);

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

@@ -30,6 +30,62 @@
  *     decomposer prompt and authoring SKILL.
  */
 
+import { parse as parseStoryBody } from '../story-body/story-body.js';
+
+/**
+ * Normalize a Story's `body` to the structured object the sizing layers
+ * score, mirroring `validateAcFreshness` / `collectStoryAssumptionEntries`
+ * (Story #3302) and `resolveStructuredBody` in `task-body-validator.js`.
+ *
+ * The decomposer emits `body` as the canonical serialized **string**
+ * (`decomposer-prompts.js`), but the sizing layers historically read
+ * `story.body` only when it was already an object — so on the production
+ * string shape `changes` / `wide` fell through to empty and the `hardFiles`
+ * / unanchored-constant backstops emitted nothing. A defensive parse here
+ * restores parity:
+ *   - **string body** → parsed via `parseStoryBody`; an unparseable string
+ *     yields `null` (the gate degrades to "no structured signal", never
+ *     throws mid-validation).
+ *   - **object body** → returned verbatim (a caller may pass the
+ *     pre-serialize shape directly; `parse` round-trips it).
+ *   - **null / other** → `null`.
+ *
+ * @param {object} story
+ * @returns {object|null}
+ */
+function resolveStoryBody(story) {
+  const body = story?.body;
+  if (typeof body === 'string') {
+    if (body.trim().length === 0) return null;
+    try {
+      return parseStoryBody(body).body;
+    } catch {
+      return null;
+    }
+  }
+  if (body !== null && typeof body === 'object') return body;
+  return null;
+}
+
+/**
+ * Resolve the acceptance-criteria array for a Story, preferring the
+ * authoritative top-level `story.acceptance` (the binding contract the
+ * validator already requires every Story to carry inline) over the
+ * structured body's `acceptance`. Reading the top-level array makes the
+ * acceptance ceiling correct regardless of body shape — a string body whose
+ * structured `acceptance` is only reachable after a parse, or an object body
+ * (Story #4271). Falls back to `resolveStoryBody(story).acceptance` only when
+ * the top-level array is absent.
+ *
+ * @param {object} story
+ * @returns {unknown[]}
+ */
+function resolveAcceptance(story) {
+  if (Array.isArray(story?.acceptance)) return story.acceptance;
+  const body = resolveStoryBody(story);
+  return Array.isArray(body?.acceptance) ? body.acceptance : [];
+}
+
 export const DEFAULT_TASK_SIZING = Object.freeze({
   // Typical-Story warning thresholds (soft — emit advisory findings).
   // Story #4162 raised `softFiles` 8 → 15: a capability-sized Story routinely
@@ -71,6 +127,39 @@ export const DELIVERABLE_GRANULARITY_GUIDANCE = Object.freeze({
     '**Single-consumer merge rule.** A Story whose only consumer is one sibling Story should be **merged into that sibling** rather than emitted separately — a single-consumer downstream slice is not its own unit of work.',
 });
 
+/**
+ * `AUTHORING_ALTITUDE_GUIDANCE` is the **single source of truth** for the
+ * binding-vs-advisory authoring altitude (Epic #4131 F8) and the New-File
+ * Contract (Story #4272). It is stated ONCE here and consumed by BOTH the
+ * decomposer prompt template
+ * (`.agents/scripts/lib/templates/decomposer-prompts.js`, which interpolates
+ * the strings verbatim into the rendered system prompt) AND the authoring
+ * SKILL (`.agents/skills/core/epic-plan-decompose-author/SKILL.md`, whose
+ * prose mirrors these sentences). The SKILL cannot import JS, so the
+ * `ticket-decomposer` prompt test asserts the canonical phrasing on both
+ * surfaces — a divergent restatement fails that gate. This reuses the #3777
+ * single-source mechanism (one constant, two surfaces, drift-gated by tests).
+ *
+ * The altitude: `acceptance[]` / `verify[]` are the **binding contract** (the
+ * sole definition of "done"); `changes[]` / `references[]` are an **advisory
+ * implementation sketch** the executor MAY revise. Author acceptance to assert
+ * the **outcome** independent of file layout — never pin an incidental helper
+ * name or private path into an acceptance item. The advisory sketch is still
+ * validated (base-branch probes, New-File Contract) and never licenses
+ * skipping `acceptance[]` / `verify[]` or any `rules/security-baseline.md` MUST.
+ */
+export const AUTHORING_ALTITUDE_GUIDANCE = Object.freeze({
+  // The binding-vs-advisory altitude statement.
+  altitude:
+    '**Binding contract vs advisory sketch.** `acceptance[]` and `verify[]` are the Story\'s **binding contract** — the executor MUST satisfy them exactly, and they are the only definition of "done." `changes[]` and `references[]` are an **advisory implementation sketch**: your best prediction of the file footprint, which the executor MAY revise when the real codebase diverges from the sketch. Author `acceptance[]` / `verify[]` to assert the **outcome** independent of any one file layout — never pin an incidental implementation detail (an internal helper name, a private file path) into an acceptance item that the advisory `changes[]` is free to reshape; assert the observable behaviour instead.',
+  // The advisory-does-not-mean-unvalidated caveat.
+  advisoryCaveat:
+    "**Advisory does not mean unvalidated.** `changes[]` paths still pass the base-branch file-assumption probes (a `creates` against an existing path still fails), the New-File Contract still holds, and the executor's latitude to revise the approach never licenses skipping `acceptance[]` / `verify[]` or relaxing any `rules/security-baseline.md` MUST.",
+  // The New-File Contract.
+  newFileContract:
+    '**New-File Contract.** Any path named in a Story\'s `goal`, `acceptance`, or `verify` that does NOT already exist on `main` MUST also appear in that Story\'s `changes[]` with `assumption: "creates"`; otherwise the freshness validator rejects the decompose — even when the Story is the one authoring the file.',
+});
+
 /**
  * Configuration-constant phrase patterns the `unanchored-constant` heuristic
  * scans Story acceptance criteria for. Each entry matches the *kind* of
@@ -143,8 +232,11 @@ function makeUnanchoredConstant(slug, criterion) {
  */
 function computeUnanchoredConstantFindings(story) {
   const out = [];
-  const body = story.body && typeof story.body === 'object' ? story.body : null;
-  const acceptance = Array.isArray(body?.acceptance) ? body.acceptance : [];
+  // Read the authoritative top-level `story.acceptance` (the binding
+  // contract), falling back to the structured body's acceptance only when the
+  // top-level array is absent. This is correct regardless of body shape —
+  // string or object (Story #4271).
+  const acceptance = resolveAcceptance(story);
   for (const item of acceptance) {
     const criterion = String(item ?? '');
     if (CONCRETE_VALUE_RE.test(criterion)) continue;
@@ -158,6 +250,47 @@ function computeUnanchoredConstantFindings(story) {
   return out;
 }
 
+/**
+ * Soft, advisory `missing-reason-to-exist` finding (Story #4273). Surfaces a
+ * Story whose body carries no non-empty `reason_to_exist` — the
+ * machine-checkable form of the cohesion rule (**one Story = one coherent
+ * change with one reason to exist**). `reason_to_exist` is marked REQUIRED by
+ * the decomposer prompt and is the field the `epic-plan-consolidate` critic
+ * gates on, but that critic is an honor-system LLM check with no runtime
+ * backstop. This deterministic finding is the cheap backstop.
+ *
+ * Severity is `soft` (not a hard reject) so existing `reason_to_exist`-less
+ * standalone / audit Stories are surfaced as an advisory nudge rather than
+ * blocked — matching the `unanchored-constant` finding's advisory contract.
+ */
+function makeMissingReasonToExist(slug) {
+  return {
+    kind: 'missing-reason-to-exist',
+    severity: 'soft',
+    ticketSlug: slug,
+    message:
+      'Story body carries no non-empty `reason_to_exist`. State the single coherent reason this Story exists in one sentence (the machine-checkable form of "one Story = one coherent change with one reason to exist"), encoded as the `reason_to_exist` field of the body meta comment.',
+  };
+}
+
+/**
+ * Emit a soft `missing-reason-to-exist` finding when the Story body resolves
+ * to no non-empty `reason_to_exist`. The body parser
+ * (`story-body/story-body.js`) already normalizes `reason_to_exist` to a
+ * non-empty trimmed string or `null`, so reading `body.reason_to_exist` after
+ * `resolveStoryBody` is correct regardless of body shape — a serialized
+ * **string** body (the production decomposer shape) or an object body
+ * (Story #4271). A body that fails to parse resolves to `null` and trips the
+ * finding, which is the right advisory signal: the author should re-emit a
+ * parseable body carrying the field. One finding per Story.
+ */
+function computeMissingReasonToExistFinding(story) {
+  const body = resolveStoryBody(story);
+  const reason = body?.reason_to_exist;
+  const hasReason = typeof reason === 'string' && reason.trim().length > 0;
+  return hasReason ? [] : [makeMissingReasonToExist(story.slug)];
+}
+
 /**
  * Returns true when a `changes[]` entry is a glob pattern. Handles both the
  * canonical PathEntry object form `{ path, assumption }` and legacy strings.
@@ -253,8 +386,12 @@ function isDeclaredWide(wide) {
  */
 function computeStorySizingFindings(story, sizing) {
   const out = [];
-  const body = story.body && typeof story.body === 'object' ? story.body : null;
-  const acceptance = Array.isArray(body?.acceptance) ? body.acceptance : [];
+  // Story #4271: normalize the body so the canonical serialized **string**
+  // shape the decomposer emits is scored at parity with the pre-serialize
+  // object shape. The acceptance ceiling reads the authoritative top-level
+  // `story.acceptance` (the binding contract), not `body.acceptance`.
+  const body = resolveStoryBody(story);
+  const acceptance = resolveAcceptance(story);
   const changes = Array.isArray(body?.changes) ? body.changes : [];
   const declaredWide = isDeclaredWide(body?.wide ?? null);
 
@@ -263,6 +400,13 @@ function computeStorySizingFindings(story, sizing) {
   // the numeric sizing layers below — purely an authoring nudge.
   out.push(...computeUnanchoredConstantFindings(story));
 
+  // Soft, advisory: flag a Story body that carries no non-empty
+  // `reason_to_exist` (Story #4273). The decomposer prompt marks the field
+  // REQUIRED and the consolidate critic gates on it, but that critic has no
+  // runtime backstop — this deterministic finding is the cheap backstop.
+  // Independent of the numeric sizing layers below.
+  out.push(...computeMissingReasonToExistFinding(story));
+
   // Acceptance ceiling + soft warn.
   if (acceptance.length > sizing.maxAcceptance) {
     out.push(

package/.agents/scripts/lib/orchestration/ticketing/transition.js

@@ -179,6 +179,7 @@ async function syncProjectStatusColumn(
   ticketId,
   newState,
   _makeColumnSync,
+  config,
 ) {
   try {
     let sync;
@@ -191,10 +192,15 @@ async function syncProjectStatusColumn(
       // The instance's `_meta` cache survives across label transitions
       // so the invariant project metadata (projectId, fieldId, options)
       // is only fetched once per process run. Story #3661.
+      //
+      // Story #4252 — `config` is threaded so the on-disk board-metadata
+      // cache lands under the project's configured tempRoot. It is read at
+      // construction only; the registry caches the first instance per
+      // provider, so a later transition's config is intentionally ignored.
       if (!_columnSyncRegistry.has(provider)) {
         _columnSyncRegistry.set(
           provider,
-          new ColumnSync({ provider, logger: Logger }),
+          new ColumnSync({ provider, logger: Logger, config }),
         );
       }
       sync = _columnSyncRegistry.get(provider);
@@ -363,6 +369,7 @@ export async function transitionTicketState(
     ticketId,
     newState,
     opts._makeColumnSync,
+    opts.config,
   );
 
   // Automatically trigger upward cascade on every transition (Story