mandrel 2.10.0 → 2.12.0

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

@@ -0,0 +1,186 @@
+/**
+ * single-story-close/gate-log.js — bounded gate output for the close path
+ * (Story #4736).
+ *
+ * ## Why
+ *
+ * `runCloseValidation` streams every child gate's stdout/stderr line through
+ * an injected `log`, and the close phase used to hand it `Logger.info` — whose
+ * default sink is `console.log`. A single successful close therefore wrote the
+ * whole of `npm test`, the linter, and the baseline checks onto the invoking
+ * agent's stdout: ~50KB, over the host's inline tool-result ceiling. The caller
+ * got a truncated preview, had to open the persisted file anyway, and re-ran
+ * close for a clean envelope — burning the run's most expensive stretch to
+ * re-derive output it already had.
+ *
+ * Story #4708 set the contract this restores compliance with (see
+ * `rules/orchestration-error-handling.md` § Output Contract): compact digest
+ * plus an on-disk artifact path, ≤ ~2KB on the **default success path**.
+ *
+ * ## The shape
+ *
+ * A sink captures every gate line to a log under the gitignored temp tree and
+ * emits nothing inline. What happens next depends on the outcome, because the
+ * two outcomes want opposite things:
+ *
+ *   - **success** — the caller wants the verdict, not the evidence.
+ *     {@link GateLogSink#digest} is one line: the pass count and the log path.
+ *   - **failure** — the evidence IS the point, and making the caller open a
+ *     file to see why a gate went red just moves the cost.
+ *     {@link GateLogSink#replay} puts the captured tail back inline.
+ *
+ * `AGENT_LOG_LEVEL=verbose` opts back into live inline streaming (the
+ * "existing log-level control"): the capture still happens, so the artifact is
+ * written either way.
+ *
+ * The sink never throws. A log directory that cannot be written degrades to
+ * inline streaming — losing the size bound is strictly better than losing the
+ * gate output that says why a close failed.
+ */
+
+import nodeFs from 'node:fs';
+import path from 'node:path';
+
+import { Logger, resolveLevel } from '../../Logger.js';
+
+/**
+ * How many trailing captured lines {@link GateLogSink#replay} puts back
+ * inline. A failed gate's actionable evidence — the assertion, the stack, the
+ * summary counts — sits at the end of its output; the head is startup noise.
+ * The full text is always in the artifact regardless.
+ */
+export const REPLAY_TAIL_LINES = 200;
+
+/** Basename of the per-Story gate log inside the temp directory. */
+function logNameFor(storyId) {
+  return `close-gates-${storyId ?? 'unknown'}.log`;
+}
+
+/**
+ * A capturing sink for close-validation gate output.
+ *
+ * Not exported as a constructor — {@link createGateLogSink} owns the
+ * degradation decision, so every instance in the wild has already resolved
+ * whether it has a writable artifact.
+ */
+class GateLogSink {
+  /**
+   * @param {{ logPath: string|null, streamInline: boolean, write: (line: string) => void, emit: (line: string) => void }} args
+   */
+  constructor({ logPath, streamInline, write, emit }) {
+    /** Absolute path of the artifact, or `null` when capture is unavailable. */
+    this.logPath = logPath;
+    /** Whether lines are ALSO echoed inline as they arrive. */
+    this.streamInline = streamInline;
+    /** Number of lines captured so far. */
+    this.lineCount = 0;
+    this._write = write;
+    this._emit = emit;
+    this._tail = [];
+  }
+
+  /**
+   * The `log` callable handed to `runCloseValidation` / `buildDefaultGates`.
+   * Bound, because it is passed by reference into the gate machinery.
+   *
+   * @type {(message: string) => void}
+   */
+  get log() {
+    return (message) => {
+      const line = String(message ?? '');
+      this.lineCount += 1;
+      this._tail.push(line);
+      if (this._tail.length > REPLAY_TAIL_LINES) this._tail.shift();
+      this._write(line);
+      if (this.streamInline) this._emit(line);
+    };
+  }
+
+  /**
+   * The success-path digest: one line, no gate output. Names the artifact so
+   * the caller can open it on demand rather than carrying it all session.
+   *
+   * @returns {string}
+   */
+  digest() {
+    const where = this.logPath
+      ? `full gate output → ${this.logPath}`
+      : 'full gate output was streamed inline (no artifact could be written)';
+    return `${this.lineCount} line(s) of gate output captured; ${where}`;
+  }
+
+  /**
+   * Put the captured tail back inline — the failure path, where the evidence
+   * is what the caller came for. A no-op when the lines were already streamed
+   * inline (verbose, or degraded capture), so nothing is ever printed twice.
+   *
+   * @returns {number} Lines replayed.
+   */
+  replay() {
+    if (this.streamInline || this._tail.length === 0) return 0;
+    const dropped = this.lineCount - this._tail.length;
+    if (dropped > 0) {
+      this._emit(
+        `[close-validation] … ${dropped} earlier line(s) omitted; full output → ${this.logPath}`,
+      );
+    }
+    for (const line of this._tail) this._emit(line);
+    return this._tail.length;
+  }
+}
+
+/**
+ * Build the gate-output sink for one close run.
+ *
+ * @param {{
+ *   storyId: number|null,
+ *   cwd?: string,
+ *   logDir?: string,
+ *   fs?: typeof nodeFs,
+ *   logger?: { info: (m: string) => void },
+ *   level?: string,
+ * }} [args] `logDir` defaults to `<cwd>/temp/orchestration`; `level` defaults
+ *   to the live Logger level so `AGENT_LOG_LEVEL=verbose` restores streaming.
+ * @returns {GateLogSink}
+ */
+export function createGateLogSink({
+  storyId = null,
+  cwd = process.cwd(),
+  logDir,
+  fs = nodeFs,
+  logger = Logger,
+  level,
+} = {}) {
+  const emit = (line) => logger.info?.(line);
+  const verbose = (level ?? resolveLevel()) === 'verbose';
+  const dir = logDir ?? path.join(cwd, 'temp', 'orchestration');
+
+  let handle = null;
+  let logPath = null;
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    logPath = path.join(dir, logNameFor(storyId));
+    // Truncate: each close run owns its artifact outright, so a re-run never
+    // hands the reader a file interleaving two runs' gates.
+    handle = fs.openSync(logPath, 'w');
+  } catch {
+    // No artifact — fall back to inline streaming rather than dropping the
+    // gate output on the floor.
+    return new GateLogSink({
+      logPath: null,
+      streamInline: true,
+      write: () => {},
+      emit,
+    });
+  }
+
+  const write = (line) => {
+    try {
+      fs.writeSync(handle, `${line}\n`);
+    } catch {
+      /* best-effort: a mid-run write failure must not abort the close */
+    }
+  };
+
+  return new GateLogSink({ logPath, streamInline: verbose, write, emit });
+}

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

@@ -24,6 +24,15 @@
  * the same, with `baseBranch` as the diff anchor and the Story worktree as
  * the commit target.
  *
+ * Bounded gate output (Story #4736). Every gate line goes to the run's
+ * `gate-log.js` sink — an artifact under the gitignored temp tree — instead
+ * of straight to the agent's stdout, where a passing `npm test` alone once
+ * pushed a successful close past the host's inline tool-result ceiling. A
+ * clean run reports one digest line naming the artifact; a failing gate
+ * replays its captured tail inline, because that is exactly when the caller
+ * needs the evidence in front of them. `AGENT_LOG_LEVEL=verbose` restores
+ * live streaming.
+ *
  * `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.
@@ -33,6 +42,7 @@ import { buildDefaultGates as defaultBuildDefaultGates } from '../../../close-va
 import { runCloseValidation as defaultRunCloseValidation } from '../../../close-validation/runner.js';
 import { Logger } from '../../../Logger.js';
 import { runScopedFormatAutofix as defaultRunScopedFormatAutofix } from '../../story-close/format-autofix.js';
+import { createGateLogSink as defaultCreateGateLogSink } from '../gate-log.js';
 
 /**
  * Run the close-validation gate chain. Throws on first gate failure.
@@ -60,6 +70,7 @@ import { runScopedFormatAutofix as defaultRunScopedFormatAutofix } from '../../s
  *   runCloseValidation?: typeof defaultRunCloseValidation,
  *   buildDefaultGates?: typeof defaultBuildDefaultGates,
  *   runScopedFormatAutofix?: typeof defaultRunScopedFormatAutofix,
+ *   createGateLogSink?: typeof defaultCreateGateLogSink,
  * }} args
  */
 export async function runCloseValidationPhase({
@@ -73,6 +84,7 @@ export async function runCloseValidationPhase({
   runCloseValidation = defaultRunCloseValidation,
   buildDefaultGates = defaultBuildDefaultGates,
   runScopedFormatAutofix = defaultRunScopedFormatAutofix,
+  createGateLogSink = defaultCreateGateLogSink,
 }) {
   // Story #4250 — format-autofix self-heal before the check-only gates.
   // Mirrors the Epic path (story-close/phases/gates.js): the formatter is
@@ -122,6 +134,9 @@ export async function runCloseValidationPhase({
     'VALIDATE',
     `Running close-validation gates against baseline ${baseBranch}${worktreePath ? ` in ${worktreePath}` : ''}...`,
   );
+  // Story #4736 — one sink for both `log` seams (gate construction and gate
+  // execution), so nothing in the chain can route around the artifact.
+  const gateLog = createGateLogSink({ storyId, cwd });
   const validation = await runCloseValidation({
     cwd,
     worktreePath,
@@ -129,9 +144,9 @@ export async function runCloseValidationPhase({
       config,
       baseBranch,
       cwd: worktreePath || cwd,
-      log: (m) => Logger.info(m),
+      log: gateLog.log,
     }),
-    log: (m) => Logger.info(m),
+    log: gateLog.log,
     storyId,
     // Story #4250 — standalone storyId-anchored evidence keyspace. No
     // epicId; the standalone flag routes the cache to
@@ -141,10 +156,13 @@ export async function runCloseValidationPhase({
   if (!validation.ok) {
     const [first] = validation.failed;
     const { gate, status, cwd: gateCwd } = first;
+    // The evidence is the point on this path: replay the captured tail inline
+    // rather than making the caller open a file to learn why close stopped.
+    gateLog.replay();
     throw new Error(
       `[single-story-close] Gate failed: ${gate.name} (exit ${status})${gateCwd ? ` in ${gateCwd}` : ''}.` +
         (gate.hint ? ` ${gate.hint}` : ''),
     );
   }
-  progress('VALIDATE', '✅ All gates passed.');
+  progress('VALIDATE', `✅ All gates passed. ${gateLog.digest()}`);
 }

package/.agents/scripts/lib/orchestration/spec-budget.js

@@ -0,0 +1,78 @@
+/**
+ * lib/orchestration/spec-budget.js — the soft `## Spec` word-budget pass
+ * (Story #4723), extracted from `ticket-validator.js` so the advisory
+ * length nudge lives beside neither the hard validators nor their error
+ * channel: everything here is `'soft'` by construction and can never fail
+ * a persist.
+ */
+
+import { parse as parseStoryBody } from '../story-body/story-body.js';
+
+/**
+ * Soft advisory word budget for a Story's inline `## Spec` (Story #4723).
+ * ~250 words is the #4707 contract-level-prose target: interfaces,
+ * invariants, and load-bearing constraints — not route-by-route behavior
+ * narration. Distinct from the hard ~1500-token fail-closed ceiling in
+ * `spec-spill.js`: this budget only warns; it never fails the persist.
+ */
+export const SPEC_SOFT_WORD_BUDGET = 250;
+
+/**
+ * Resolve a Story's Spec prose across both authoring shapes: the canonical
+ * serialized string body (parsed; `## Spec` text block) and the
+ * pre-serialize structured object body (`body.spec`). Returns `''` when
+ * absent — or when a string body does not parse: this pass is advisory, so
+ * an unreadable body contributes no finding here and is left to the hard
+ * parse gate (`assertStoryBodiesParse`) to reject.
+ *
+ * @param {object} story
+ * @returns {string}
+ */
+function resolveSpecText(story) {
+  const body = story?.body;
+  if (typeof body === 'string' && body.trim().length > 0) {
+    let spec;
+    try {
+      spec = parseStoryBody(body).body.spec;
+    } catch {
+      return '';
+    }
+    return typeof spec === 'string' ? spec : '';
+  }
+  if (body !== null && typeof body === 'object') {
+    return typeof body?.spec === 'string' ? body.spec : '';
+  }
+  return '';
+}
+
+/**
+ * Advisory `## Spec` length pass (Story #4723). Emits one `'soft'` finding
+ * per Story whose Spec prose exceeds {@link SPEC_SOFT_WORD_BUDGET} words,
+ * nudging the author toward contract-level prose (#4707). Soft only — the
+ * findings never reach the validator's `errors[]` channel, so an
+ * over-budget Spec never fails the persist.
+ *
+ * @param {{ stories: object[] }} opts
+ * @returns {object[]} Zero or more `spec-word-budget` findings.
+ */
+export function computeSpecBudgetFindings({ stories }) {
+  const findings = [];
+  for (const story of stories ?? []) {
+    const words = resolveSpecText(story).split(/\s+/).filter(Boolean).length;
+    if (words <= SPEC_SOFT_WORD_BUDGET) continue;
+    findings.push({
+      kind: 'spec-word-budget',
+      severity: 'soft',
+      ticketSlug: story.slug ?? '<unknown>',
+      words,
+      budget: SPEC_SOFT_WORD_BUDGET,
+      message:
+        `Story "${story.slug ?? '<unknown>'}" ## Spec is ~${words} words ` +
+        `(soft budget ${SPEC_SOFT_WORD_BUDGET}). Prefer contract-level prose ` +
+        '(interfaces, invariants, load-bearing constraints with their why) ' +
+        'over per-file behavior narration — advisory only; the persist ' +
+        'proceeds.',
+    });
+  }
+  return findings;
+}

package/.agents/scripts/lib/orchestration/story-body-gate.js

@@ -0,0 +1,72 @@
+/**
+ * lib/orchestration/story-body-gate.js — the Story-body parse gate
+ * (Story #4541), extracted from `ticket-validator.js`: the one place a
+ * serialized Story body is parsed with parse failures translated into the
+ * validator's operator-legible `ValidationError` shape. Both the gate that
+ * refuses a plan up front (`assertStoryBodiesParse`) and the per-call
+ * translating parser (`parseStoryBodyOrThrow`) the downstream validators
+ * lean on live here.
+ */
+
+import { ValidationError } from '../errors/index.js';
+import {
+  parse as parseStoryBody,
+  StoryBodyParseError,
+} from '../story-body/story-body.js';
+
+/**
+ * Parse a Story's serialized markdown body, translating a
+ * `StoryBodyParseError` into a `ValidationError` that names the offending
+ * **section** and **entry** (Story #4541).
+ *
+ * `StoryBodyParseError` already carries `field` (the section the parser was
+ * reading) and `raw` (the entry text that failed); this lifts both into an
+ * operator-legible message and a structured `violation` payload so an
+ * authoring loop can point at the exact bullet instead of re-deriving it
+ * from a downstream freshness miss.
+ *
+ * @param {object} story Story whose `body` is a non-empty markdown string.
+ * @returns {object} The structured body.
+ * @throws {ValidationError} `code: 'story-body-unparseable'`.
+ */
+export function parseStoryBodyOrThrow(story) {
+  try {
+    return parseStoryBody(story.body).body;
+  } catch (err) {
+    if (!(err instanceof StoryBodyParseError)) throw err;
+    const slug = story.slug ?? '<unknown>';
+    const section = err.field ?? 'body';
+    const entry = err.raw ?? null;
+    const entryLine = entry === null ? '' : `\n      entry: ${entry}`;
+    const violation = { slug, section, entry, reason: err.message };
+    const error = new ValidationError(
+      `Cross-Validation Failed: Story "${slug}" has an unparseable body — ` +
+        `the ## ${section} section could not be read: ${err.message}` +
+        `${entryLine}\n\nFix the offending entry; this is a malformed body, ` +
+        'not a stale path reference.',
+      { violations: [violation] },
+    );
+    error.code = 'story-body-unparseable';
+    error.violations = [violation];
+    throw error;
+  }
+}
+
+/**
+ * Refuse the plan when any Story's serialized body cannot be parsed, before
+ * either git-probe gate runs (Story #4541). Ordering matters: the freshness
+ * gate consults `body.changes` for its net-new whitelist, so an unparseable
+ * body used to reach the operator as a freshness miss naming declared paths.
+ *
+ * @param {{ tickets: object[] }} opts
+ * @throws {ValidationError} `code: 'story-body-unparseable'` on the first
+ *   offending Story.
+ */
+export function assertStoryBodiesParse({ tickets }) {
+  for (const story of (tickets ?? []).filter((t) => t.type === 'story')) {
+    if (typeof story.body !== 'string' || story.body.trim().length === 0) {
+      continue;
+    }
+    parseStoryBodyOrThrow(story);
+  }
+}

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

@@ -829,6 +829,12 @@ export function renderHardConflictError(finding) {
   if (finding.kind === 'missing-bdd-scaffold') {
     return `Missing BDD scaffold: Story "${finding.consumer.storySlug}" verifies against "${finding.path}" (created by Story "${finding.producer.storySlug}") via body.${finding.consumer.sourceField}, but "${finding.consumer.storySlug}" has no depends_on path to "${finding.producer.storySlug}" — the .feature file is scaffolded in the same wave (or later), so verification runs before the file exists. Add depends_on: ["${finding.producer.storySlug}"] to the consumer Story so the scaffold lands in an earlier wave.`;
   }
+  // Findings from other passes (sizing, spec-word-budget) carry their own
+  // message — render it rather than a shape-blind generic line, so the soft
+  // surface (`surfaceSoftConflictFindings`) stays legible for every kind.
+  if (typeof finding.message === 'string' && finding.message.length > 0) {
+    return finding.message;
+  }
   return `Conflict finding ${finding.kind} on path "${finding.path ?? '<unknown>'}".`;
 }
 

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

@@ -3,11 +3,12 @@ import { detectCycle } from '../Graph.js';
 import { gitSpawn } from '../git-utils.js';
 
 import { Logger } from '../Logger.js';
-import {
-  parse as parseStoryBody,
-  StoryBodyParseError,
-} from '../story-body/story-body.js';
 import { validateStoryFileAssumptions } from './file-assumptions.js';
+import { computeSpecBudgetFindings } from './spec-budget.js';
+import {
+  assertStoryBodiesParse,
+  parseStoryBodyOrThrow,
+} from './story-body-gate.js';
 import {
   computeConflictFindings,
   renderHardConflictError,
@@ -46,63 +47,6 @@ function collectPathsFromText(text, paths) {
   }
 }
 
-/**
- * Parse a Story's serialized markdown body, translating a
- * `StoryBodyParseError` into a `ValidationError` that names the offending
- * **section** and **entry** (Story #4541).
- *
- * `StoryBodyParseError` already carries `field` (the section the parser was
- * reading) and `raw` (the entry text that failed); this lifts both into an
- * operator-legible message and a structured `violation` payload so an
- * authoring loop can point at the exact bullet instead of re-deriving it
- * from a downstream freshness miss.
- *
- * @param {object} story Story whose `body` is a non-empty markdown string.
- * @returns {object} The structured body.
- * @throws {ValidationError} `code: 'story-body-unparseable'`.
- */
-function parseStoryBodyOrThrow(story) {
-  try {
-    return parseStoryBody(story.body).body;
-  } catch (err) {
-    if (!(err instanceof StoryBodyParseError)) throw err;
-    const slug = story.slug ?? '<unknown>';
-    const section = err.field ?? 'body';
-    const entry = err.raw ?? null;
-    const entryLine = entry === null ? '' : `\n      entry: ${entry}`;
-    const violation = { slug, section, entry, reason: err.message };
-    const error = new ValidationError(
-      `Cross-Validation Failed: Story "${slug}" has an unparseable body — ` +
-        `the ## ${section} section could not be read: ${err.message}` +
-        `${entryLine}\n\nFix the offending entry; this is a malformed body, ` +
-        'not a stale path reference.',
-      { violations: [violation] },
-    );
-    error.code = 'story-body-unparseable';
-    error.violations = [violation];
-    throw error;
-  }
-}
-
-/**
- * Refuse the plan when any Story's serialized body cannot be parsed, before
- * either git-probe gate runs (Story #4541). Ordering matters: the freshness
- * gate consults `body.changes` for its net-new whitelist, so an unparseable
- * body used to reach the operator as a freshness miss naming declared paths.
- *
- * @param {{ tickets: object[] }} opts
- * @throws {ValidationError} `code: 'story-body-unparseable'` on the first
- *   offending Story.
- */
-function assertStoryBodiesParse({ tickets }) {
-  for (const story of (tickets ?? []).filter((t) => t.type === 'story')) {
-    if (typeof story.body !== 'string' || story.body.trim().length === 0) {
-      continue;
-    }
-    parseStoryBodyOrThrow(story);
-  }
-}
-
 /**
  * Resolve every acceptance line a Story declares, across both authoring
  * shapes (Story #4541).
@@ -721,7 +665,19 @@ export function validateAndNormalizeTickets(tickets, opts = {}) {
     stories,
     policy: opts.conflictPolicy,
   });
-  const findings = [...sizingFindings, ...conflictFindings];
+  // Advisory `## Spec` word-budget pass (Story #4723) — soft findings only,
+  // surfaced as warnings here and via the persist soft-finding channel;
+  // never promoted to `errors[]`, so an over-budget Spec cannot fail the
+  // persist. Runs after `assertStoryBodiesParse`, so string bodies parse.
+  const specBudgetFindings = computeSpecBudgetFindings({ stories });
+  for (const finding of specBudgetFindings) {
+    Logger.warn(`[ticket-validator] spec-word-budget: ${finding.message}`);
+  }
+  const findings = [
+    ...sizingFindings,
+    ...conflictFindings,
+    ...specBudgetFindings,
+  ];
   const CONFLICT_KINDS = new Set([
     'shared-editor',
     'implicit-cross-story-dep',

package/.agents/scripts/plan-context.js

@@ -124,7 +124,7 @@ export async function emitPlanContext({
     // later turn. When it is captured to disk anyway, stdout carries a
     // compact digest naming the artifact instead of the payload itself.
     await writeEnvelopeFile(outPath, json);
-    await writeStoriesTemplateFile(outPath);
+    await writeStoriesTemplateFile(outPath, envelope);
     const resolved = path.resolve(outPath);
     const digest = {
       digest: 'plan-context',
@@ -137,7 +137,16 @@ export async function emitPlanContext({
       bytes: Buffer.byteLength(json, 'utf8'),
       sourceTickets: (envelope.sourceTickets ?? []).map((t) => t.id),
       duplicates: (envelope.duplicates ?? []).length,
-      complexityRoute: envelope.complexityRoute?.route ?? null,
+      // Advisory only (Story #4722): signals, no route — the planner owns
+      // the trivial-vs-standard verdict and persist validates it by shape.
+      complexitySignals: envelope.complexitySignals
+        ? {
+            artifactCount: envelope.complexitySignals.artifactCount,
+            riskHeuristicHits: envelope.complexitySignals.riskHeuristicHits,
+            sensitivePathClasses:
+              envelope.complexitySignals.sensitivePathClasses,
+          }
+        : null,
     };
     stdout.write(`${JSON.stringify(digest)}\n`);
   } else {
@@ -177,18 +186,27 @@ async function writeEnvelopeFile(outPath, json) {
  * requires reading `story-body.js` source. Written whenever `--out` is
  * passed, and throwing on failure for the same reason the envelope write
  * does: a silently missing template re-opens the format-discovery loop it
- * exists to close.
+ * exists to close. The envelope's advisory `complexitySignals` are threaded
+ * through so the skeleton's `changes[]` arrive pre-resolved to
+ * creates-vs-refactors against the repo snapshot (Story #4723).
  *
  * @param {string} outPath The envelope `--out` path; the template lands in
  *   the same directory as {@link STORIES_TEMPLATE_FILENAME}.
+ * @param {object} [envelope] The emitted plan-context envelope.
  */
-async function writeStoriesTemplateFile(outPath) {
+async function writeStoriesTemplateFile(outPath, envelope = {}) {
   const resolved = path.resolve(
     path.dirname(path.resolve(outPath)),
     STORIES_TEMPLATE_FILENAME,
   );
   try {
-    await writeFile(resolved, renderStoriesTemplate(), 'utf8');
+    await writeFile(
+      resolved,
+      renderStoriesTemplate({
+        complexitySignals: envelope?.complexitySignals ?? null,
+      }),
+      'utf8',
+    );
   } catch (err) {
     throw new Error(
       `[plan-context] cannot write stories template to ${resolved}: ${err.message}`,

package/.agents/scripts/resolve-stories.js

@@ -209,6 +209,7 @@ async function main() {
     stories,
     nativeEdges,
     warn: (m) => Logger.warn(m),
+    config,
   });
   const foreignDone = await resolveForeignDone({
     provider,
@@ -220,6 +221,7 @@ async function main() {
     nativeEdges,
     foreignDone,
     warn: () => {},
+    config,
   });
 
   process.stdout.write(