mandrel 2.21.0 → 2.22.0

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

@@ -203,66 +203,95 @@ const WIDE_MARKER_LINE_RE = /^>\s*\*\*Wide:\*\*/;
 function parsePathEntry(raw, warnings) {
   // Already a structured object (from a parsed JSON body, not markdown).
   if (raw !== null && typeof raw === 'object') {
-    if (
-      typeof raw.path === 'string' &&
-      raw.path.trim().length > 0 &&
-      FILE_ASSUMPTION_VALUES.includes(raw.assumption)
-    ) {
-      return { path: raw.path.trim(), assumption: raw.assumption };
-    }
-    // Malformed object: fail closed.
-    throw new StoryBodyParseError(
-      `changes/references entry is an object but not a valid PathEntry: ${JSON.stringify(raw)}`,
-      { field: 'changes', raw: JSON.stringify(raw) },
-    );
+    return pathEntryFromObject(raw);
   }
 
   const str = typeof raw === 'string' ? raw.trim() : String(raw).trim();
   if (str.length === 0) return null;
 
-  // Humanized bullet shape (the canonical serialize() output since
-  // Story #4600): `path` — assumption.
-  const humanized = str.match(HUMANIZED_PATH_ENTRY_RE);
-  if (humanized) {
-    const path = humanized[1].trim();
-    if (path.length > 0 && FILE_ASSUMPTION_VALUES.includes(humanized[2])) {
-      return { path, assumption: humanized[2] };
-    }
-    // Recognized the humanized shape but the fields are invalid: fail closed.
-    throw new StoryBodyParseError(
-      `changes/references entry is a humanized bullet but not a valid PathEntry: ${str.slice(0, 120)}${pathEntryFixIt(str)}`,
-      { field: 'changes', raw: str },
-    );
+  const entry = pathEntryFromHumanized(str) ?? pathEntryFromInlineJson(str);
+  if (entry) return entry;
+
+  throw new StoryBodyParseError(
+    `changes/references entry must be a { path, assumption } object; plain string bullets are no longer accepted: ${str.slice(0, 120)}${pathEntryFixIt(str)}`,
+    { field: 'changes', raw: str },
+  );
+}
+
+/**
+ * Validate an already-structured `{ path, assumption }` object. Fails closed
+ * on a malformed object.
+ *
+ * @param {object} raw
+ * @returns {PathEntry}
+ */
+function pathEntryFromObject(raw) {
+  if (
+    typeof raw.path === 'string' &&
+    raw.path.trim().length > 0 &&
+    FILE_ASSUMPTION_VALUES.includes(raw.assumption)
+  ) {
+    return { path: raw.path.trim(), assumption: raw.assumption };
   }
+  // Malformed object: fail closed.
+  throw new StoryBodyParseError(
+    `changes/references entry is an object but not a valid PathEntry: ${JSON.stringify(raw)}`,
+    { field: 'changes', raw: JSON.stringify(raw) },
+  );
+}
 
-  // Try to detect inline JSON object shape: `{ "path": "...", "assumption": "..." }`
-  if (str.startsWith('{')) {
-    try {
-      const parsed = JSON.parse(str);
-      // It's a JSON object — treat it as a path entry.
-      // If the path is missing or assumption is invalid, fail closed.
-      if (typeof parsed === 'object' && parsed !== null) {
-        if (
-          typeof parsed.path === 'string' &&
-          FILE_ASSUMPTION_VALUES.includes(parsed.assumption)
-        ) {
-          return { path: parsed.path.trim(), assumption: parsed.assumption };
-        }
-        // Parsed successfully as JSON object but has invalid fields — fail closed.
-        throw new StoryBodyParseError(
-          `changes/references entry is a JSON object but not a valid PathEntry: ${str}`,
-          { field: 'changes', raw: str },
-        );
-      }
-    } catch (err) {
-      // Re-throw StoryBodyParseError so it propagates.
-      if (err instanceof StoryBodyParseError) throw err;
-      // JSON parse failed — fall through to reject plain-string form.
-    }
+/**
+ * Parse the humanized bullet shape (the canonical serialize() output since
+ * Story #4600): `` `path` — assumption ``. Returns `null` when the line is
+ * not that shape at all; fails closed when the shape is recognized but the
+ * fields are invalid.
+ *
+ * @param {string} str
+ * @returns {PathEntry|null}
+ */
+function pathEntryFromHumanized(str) {
+  const humanized = str.match(HUMANIZED_PATH_ENTRY_RE);
+  if (!humanized) return null;
+  const path = humanized[1].trim();
+  if (path.length > 0 && FILE_ASSUMPTION_VALUES.includes(humanized[2])) {
+    return { path, assumption: humanized[2] };
   }
+  // Recognized the humanized shape but the fields are invalid: fail closed.
+  throw new StoryBodyParseError(
+    `changes/references entry is a humanized bullet but not a valid PathEntry: ${str.slice(0, 120)}${pathEntryFixIt(str)}`,
+    { field: 'changes', raw: str },
+  );
+}
 
+/**
+ * Parse the legacy inline-JSON object bullet:
+ * `{ "path": "...", "assumption": "..." }`. Returns `null` when the line is
+ * not a JSON object at all (including a JSON parse failure — the caller then
+ * rejects the plain-string form); fails closed when it parses to an object
+ * without valid PathEntry fields.
+ *
+ * @param {string} str
+ * @returns {PathEntry|null}
+ */
+function pathEntryFromInlineJson(str) {
+  if (!str.startsWith('{')) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(str);
+  } catch {
+    // JSON parse failed — the caller rejects the plain-string form.
+    return null;
+  }
+  if (typeof parsed !== 'object' || parsed === null) return null;
+  if (
+    typeof parsed.path === 'string' &&
+    FILE_ASSUMPTION_VALUES.includes(parsed.assumption)
+  ) {
+    return { path: parsed.path.trim(), assumption: parsed.assumption };
+  }
+  // Parsed successfully as JSON object but has invalid fields — fail closed.
   throw new StoryBodyParseError(
-    `changes/references entry must be a { path, assumption } object; plain string bullets are no longer accepted: ${str.slice(0, 120)}${pathEntryFixIt(str)}`,
+    `changes/references entry is a JSON object but not a valid PathEntry: ${str}`,
     { field: 'changes', raw: str },
   );
 }
@@ -420,13 +449,9 @@ function splitSections(markdown) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
 
-    // Detect footer separator: `---` on its own line
-    if (/^---\s*$/.test(line)) {
-      const remaining = lines.slice(i + 1).join('\n');
-      if (/^(parent:|Epic:|blocked by)/im.test(remaining)) {
-        footerStart = i;
-        break;
-      }
+    if (isFooterSeparator(line, lines, i)) {
+      footerStart = i;
+      break;
     }
 
     // Detect `## Heading` (canonical) or `### Heading` lines. GitHub Issue
@@ -440,7 +465,7 @@ function splitSections(markdown) {
     // `-` folded to `_`) before the HEADING_TO_FIELD lookup, so `Non-Goals`
     // resolves to the `non_goals` field. Multi-word headings that contain a
     // space (`## Out of Scope`, `## Agent Prompts`) still do NOT match this
-    // single-token shape — they fall through to the catch-all heading branch
+    // single-token shape — they fall through to the section-terminator branch
     // below, which closes the open section. The chosen canonical spelling is
     // therefore the hyphenated single token `## Non-Goals`.
     const fieldHeadingMatch = line.match(/^#{2,3}\s+([\w-]+)\s*$/i);
@@ -452,47 +477,12 @@ function splitSections(markdown) {
       continue;
     }
 
-    // Any other markdown heading (`## …` / `### …`, single- or multi-word)
-    // that is NOT a canonical field heading TERMINATES the current structured
-    // section. Trailing extended content a producer appends after the
-    // canonical block — `audit-to-stories`'s `## Agent Prompts` / `## Context`
-    // / `## Sequencing` blocks, for instance — must not bleed into the last
-    // structured section's bullet list (Story #4270). Without this, those
-    // lines were silently absorbed into `verify[]` / `acceptance[]`. The
-    // heading and everything under it is dropped from structured parsing
-    // (it is extended, non-canonical markdown).
-    if (
-      !inPreamble &&
-      /^#{1,6}\s+\S/.test(line) &&
-      !TEXT_BLOCK_FIELDS.has(currentSection)
-    ) {
+    if (isSectionTerminatorHeading(line, inPreamble, currentSection)) {
       currentSection = null;
       continue;
     }
 
-    // The trailing `<!-- meta: {...} -->` block is machine metadata, not
-    // section content. Skip it so a `## References` section immediately
-    // followed by the meta block does not swallow the comment as a
-    // references entry. `extractMeta` reads it separately from the raw body.
-    if (META_BLOCK_RE.test(line)) {
-      continue;
-    }
-
-    // The visible `> 🏷️ Authored with Mandrel …` provenance marker is
-    // machine-managed metadata too (emitted alongside the meta block by the
-    // authoring path). Skip it so it never bleeds into the trailing structured
-    // section (e.g. `## Verify`); the value round-trips via the meta block.
-    if (AUTHORED_MARKER_LINE_RE.test(line)) {
-      continue;
-    }
-
-    // The visible `> **Wide:** <reason>` rationale line is presentation only
-    // (Story #4600): the meta block remains the canonical carrier for
-    // `wide.reason`, so this line must not bleed into the goal (or any other)
-    // section. Skip it wherever it appears.
-    if (WIDE_MARKER_LINE_RE.test(line)) {
-      continue;
-    }
+    if (isMachineMarkerLine(line)) continue;
 
     if (inPreamble) {
       preambleLines.push(line);
@@ -507,6 +497,70 @@ function splitSections(markdown) {
   return { sections, footer, preamble };
 }
 
+/**
+ * True when line `index` opens the footer block: a `---` on its own line
+ * whose remaining lines start with a recognised footer key (`parent:`,
+ * `Epic:`, `blocked by`).
+ *
+ * @param {string} line
+ * @param {string[]} lines
+ * @param {number} index
+ * @returns {boolean}
+ */
+function isFooterSeparator(line, lines, index) {
+  if (!/^---\s*$/.test(line)) return false;
+  const remaining = lines.slice(index + 1).join('\n');
+  return /^(parent:|Epic:|blocked by)/im.test(remaining);
+}
+
+/**
+ * True for a non-canonical markdown heading that TERMINATES the current
+ * structured section. Trailing extended content a producer appends after the
+ * canonical block — `audit-to-stories`'s `## Agent Prompts` / `## Context`
+ * / `## Sequencing` blocks, for instance — must not bleed into the last
+ * structured section's bullet list (Story #4270). Without this, those
+ * lines were silently absorbed into `verify[]` / `acceptance[]`. The
+ * heading and everything under it is dropped from structured parsing
+ * (it is extended, non-canonical markdown).
+ *
+ * @param {string} line
+ * @param {boolean} inPreamble
+ * @param {string|null} currentSection
+ * @returns {boolean}
+ */
+function isSectionTerminatorHeading(line, inPreamble, currentSection) {
+  return (
+    !inPreamble &&
+    /^#{1,6}\s+\S/.test(line) &&
+    !TEXT_BLOCK_FIELDS.has(currentSection)
+  );
+}
+
+/**
+ * True for machine-managed marker lines section parsing skips wherever they
+ * appear:
+ *   - the trailing `<!-- meta: {...} -->` block — machine metadata, not
+ *     section content, read separately by `extractMeta`, and skipped so a
+ *     `## References` section immediately followed by it does not swallow
+ *     the comment as a references entry;
+ *   - the visible `> 🏷️ Authored with Mandrel …` provenance marker (emitted
+ *     alongside the meta block by the authoring path; the value round-trips
+ *     via the meta block);
+ *   - the visible `> **Wide:** <reason>` rationale line (Story #4600):
+ *     presentation only — the meta block remains the canonical carrier for
+ *     `wide.reason`.
+ *
+ * @param {string} line
+ * @returns {boolean}
+ */
+function isMachineMarkerLine(line) {
+  return (
+    META_BLOCK_RE.test(line) ||
+    AUTHORED_MARKER_LINE_RE.test(line) ||
+    WIDE_MARKER_LINE_RE.test(line)
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Parser — per-section sub-parsers
 // ---------------------------------------------------------------------------
@@ -771,90 +825,25 @@ export function parse(input) {
 function parseStructuredObject(obj) {
   const warnings = [];
 
-  const goal = typeof obj.goal === 'string' ? obj.goal.trim() : '';
-
-  // slicing — optional v2 intra-Story delivery slice plan (verbatim text).
-  const slicing = typeof obj.slicing === 'string' ? obj.slicing.trim() : '';
-
-  // spec — optional folded Tech Spec (verbatim text).
-  const spec = typeof obj.spec === 'string' ? obj.spec.trim() : '';
-
-  // changes
-  const rawChanges = Array.isArray(obj.changes) ? obj.changes : [];
-  const changes = [];
-  for (const raw of rawChanges) {
-    const entry = parsePathEntry(raw, warnings);
-    if (entry !== null) changes.push(entry);
-  }
-
-  // acceptance
-  const acceptance = Array.isArray(obj.acceptance)
-    ? obj.acceptance.filter((a) => typeof a === 'string' && a.trim().length > 0)
-    : [];
-
-  // verify
-  const verify = Array.isArray(obj.verify)
-    ? obj.verify.filter((v) => typeof v === 'string' && v.trim().length > 0)
-    : [];
-
-  // references
-  const rawRefs = Array.isArray(obj.references) ? obj.references : [];
-  const references = [];
-  for (const raw of rawRefs) {
-    const entry = parsePathEntry(raw, warnings);
-    if (entry !== null) references.push(entry);
+  // The declarative half of the normalization: every field whose value is a
+  // pure function of its raw input (plus the shared warnings sink) is one
+  // table row, walked in canonical body-key order. Adding a field of an
+  // existing kind is a one-row change.
+  const body = {};
+  for (const { name, kind } of STRUCTURED_FIELD_SPECS) {
+    body[name] = STRUCTURED_FIELD_NORMALIZERS[kind](obj[name], warnings);
   }
 
-  // non_goals (advisory negative-scope bullets)
-  const non_goals = Array.isArray(obj.non_goals)
-    ? obj.non_goals.filter((n) => typeof n === 'string' && n.trim().length > 0)
-    : [];
-
-  const wide = normalizeWide(obj.wide);
-  const reason_to_exist = normalizeReasonToExist(obj.reason_to_exist);
-
-  // depends_on: may be at top level or in body
-  const rawDeps = Array.isArray(obj.depends_on) ? obj.depends_on : [];
-  const depends_on = rawDeps.filter(
-    (d) => typeof d === 'string' && d.trim().length > 0,
+  // estimated_test_files is the one warning-coupled scalar: absent (== null)
+  // warns; a non-number, non-null value stays null silently.
+  body.estimated_test_files = normalizeEstimatedTestFiles(
+    obj.estimated_test_files,
+    warnings,
   );
 
-  // estimated_test_files
-  let estimated_test_files = null;
-  if (typeof obj.estimated_test_files === 'number') {
-    estimated_test_files = obj.estimated_test_files;
-  } else if (obj.estimated_test_files == null) {
-    warnings.push(
-      'test-surface-unestimated: estimated_test_files not present.',
-    );
-  }
-
   // Provenance stamp (preserved verbatim; never re-derived here).
-  const mandrel_version =
-    typeof obj.mandrel_version === 'string' && obj.mandrel_version.trim()
-      ? obj.mandrel_version.trim()
-      : null;
-  const authored_at =
-    typeof obj.authored_at === 'string' && obj.authored_at.trim()
-      ? obj.authored_at.trim()
-      : null;
-
-  const body = {
-    goal,
-    slicing,
-    spec,
-    changes,
-    acceptance,
-    verify,
-    references,
-    non_goals,
-    wide,
-    reason_to_exist,
-    depends_on,
-    estimated_test_files,
-    mandrel_version,
-    authored_at,
-  };
+  body.mandrel_version = normalizeProvenanceString(obj.mandrel_version);
+  body.authored_at = normalizeProvenanceString(obj.authored_at);
 
   return {
     body,
@@ -873,6 +862,91 @@ function parseStructuredObject(obj) {
   };
 }
 
+/**
+ * The field-spec table driving {@link parseStructuredObject}, in canonical
+ * body-key order. `kind` selects the normalizer from
+ * {@link STRUCTURED_FIELD_NORMALIZERS}:
+ *   - `text`          — trimmed string, or `''` when absent/non-string.
+ *   - `stringList`    — array filtered to non-empty strings, else `[]`.
+ *   - `pathEntryList` — array normalized entry-wise via `parsePathEntry`
+ *                       (fails closed on a malformed entry), else `[]`.
+ *   - `wide` / `reasonToExist` — the dedicated normalizers shared with the
+ *                       markdown parse path's meta-block recovery.
+ *
+ * @type {Array<{ name: string, kind: keyof typeof STRUCTURED_FIELD_NORMALIZERS }>}
+ */
+const STRUCTURED_FIELD_SPECS = [
+  { name: 'goal', kind: 'text' },
+  // slicing — optional v2 intra-Story delivery slice plan (verbatim text).
+  { name: 'slicing', kind: 'text' },
+  // spec — optional folded Tech Spec (verbatim text).
+  { name: 'spec', kind: 'text' },
+  { name: 'changes', kind: 'pathEntryList' },
+  { name: 'acceptance', kind: 'stringList' },
+  { name: 'verify', kind: 'stringList' },
+  { name: 'references', kind: 'pathEntryList' },
+  // non_goals — advisory negative-scope bullets.
+  { name: 'non_goals', kind: 'stringList' },
+  { name: 'wide', kind: 'wide' },
+  { name: 'reason_to_exist', kind: 'reasonToExist' },
+  // depends_on — may be at top level or in body.
+  { name: 'depends_on', kind: 'stringList' },
+];
+
+/**
+ * One normalizer per {@link STRUCTURED_FIELD_SPECS} kind. Each takes the raw
+ * field value plus the shared warnings sink and returns the canonical value.
+ *
+ * @type {Record<string, (raw: unknown, warnings: string[]) => unknown>}
+ */
+const STRUCTURED_FIELD_NORMALIZERS = {
+  text: (raw) => (typeof raw === 'string' ? raw.trim() : ''),
+  stringList: (raw) =>
+    Array.isArray(raw)
+      ? raw.filter((s) => typeof s === 'string' && s.trim().length > 0)
+      : [],
+  pathEntryList: (raw, warnings) => {
+    const entries = [];
+    for (const item of Array.isArray(raw) ? raw : []) {
+      const entry = parsePathEntry(item, warnings);
+      if (entry !== null) entries.push(entry);
+    }
+    return entries;
+  },
+  wide: (raw) => normalizeWide(raw),
+  reasonToExist: (raw) => normalizeReasonToExist(raw),
+};
+
+/**
+ * Normalize `estimated_test_files`: a number passes through; an absent
+ * (`null`/`undefined`) value warns `test-surface-unestimated`; any other
+ * value stays `null` silently.
+ *
+ * @param {unknown} raw
+ * @param {string[]} warnings
+ * @returns {number|null}
+ */
+function normalizeEstimatedTestFiles(raw, warnings) {
+  if (typeof raw === 'number') return raw;
+  if (raw == null) {
+    warnings.push(
+      'test-surface-unestimated: estimated_test_files not present.',
+    );
+  }
+  return null;
+}
+
+/**
+ * Normalize a provenance stamp field (`mandrel_version` / `authored_at`) to
+ * a non-empty trimmed string or `null`.
+ *
+ * @param {unknown} raw
+ * @returns {string|null}
+ */
+function normalizeProvenanceString(raw) {
+  return typeof raw === 'string' && raw.trim() ? raw.trim() : null;
+}
+
 // ---------------------------------------------------------------------------
 // Serializer
 // ---------------------------------------------------------------------------

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

@@ -166,41 +166,26 @@ export async function resolveForeignDone({ provider, dag, inSetIds }) {
   return resolved.filter((id) => id !== null);
 }
 
-async function main() {
-  const { values } = parseArgs({
-    options: {
-      ids: { type: 'string' },
-      pretty: { type: 'boolean', default: false },
-      native: { type: 'boolean', default: true },
-      help: { type: 'boolean', default: false },
-    },
-    // The documented opt-out is `--no-native`; without allowNegative,
-    // parseArgs rejects it as an unknown option and the CLI has no working
-    // way to skip the dependencies API.
-    allowNegative: true,
-    allowPositionals: false,
-  });
-
-  if (values.help) {
-    process.stdout.write(HELP);
-    return 0;
-  }
-  if (!values.ids) {
-    process.stderr.write(HELP);
-    throw new Error('[resolve-stories] --ids <n,n,...> is required');
-  }
-
-  // stdout is a JSON stream — keep human-readable output on stderr so a
-  // headless caller can pipe this straight into stories-wave-tick.js.
-  routeAllOutputToStderr();
-
-  const ids = parseIds(values.ids);
-  const { provider, config } = resolveStoriesProvider();
+/**
+ * Resolve the requested ids into the `{ stories, dag, done }` envelope and
+ * write it to `stdout`. The flow core behind `main` — provider, config, and
+ * stdout are injected so the whole path is unit-testable without a live
+ * GitHub round-trip. Exported for testing.
+ *
+ * @param {{ ids: string, native?: boolean, pretty?: boolean }} args
+ * @param {{ provider: object, config: object, stdout?: { write(s: string): void } }} deps
+ * @returns {Promise<number>}
+ */
+export async function runResolveStories(
+  { ids: rawIds, native = true, pretty = false },
+  { provider, config, stdout = process.stdout },
+) {
+  const ids = parseIds(rawIds);
   const owner = config.github?.owner;
   const repo = config.github?.repo;
 
   const stories = await fetchStories(provider, ids);
-  const nativeEdges = values.native
+  const nativeEdges = native
     ? await readNativeEdges({ provider, stories, owner, repo })
     : new Map();
 
@@ -224,14 +209,48 @@ async function main() {
     config,
   });
 
-  process.stdout.write(
-    values.pretty
+  stdout.write(
+    pretty
       ? `${JSON.stringify(envelope, null, 2)}\n`
       : `${JSON.stringify(envelope)}\n`,
   );
   return 0;
 }
 
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      ids: { type: 'string' },
+      pretty: { type: 'boolean', default: false },
+      native: { type: 'boolean', default: true },
+      help: { type: 'boolean', default: false },
+    },
+    // The documented opt-out is `--no-native`; without allowNegative,
+    // parseArgs rejects it as an unknown option and the CLI has no working
+    // way to skip the dependencies API.
+    allowNegative: true,
+    allowPositionals: false,
+  });
+
+  if (values.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (!values.ids) {
+    process.stderr.write(HELP);
+    throw new Error('[resolve-stories] --ids <n,n,...> is required');
+  }
+
+  // stdout is a JSON stream — keep human-readable output on stderr so a
+  // headless caller can pipe this straight into stories-wave-tick.js.
+  routeAllOutputToStderr();
+
+  return runResolveStories(
+    { ids: values.ids, native: values.native, pretty: values.pretty },
+    resolveStoriesProvider(),
+  );
+}
+
 runAsCli(import.meta.url, main, {
   source: 'resolve-stories',
   propagateExitCode: true,

package/.agents/scripts/single-story-confirm-merge.js

@@ -158,14 +158,13 @@ function readMaxWaitSecondsFlag() {
  * Resolve the PR number for the Story branch when one was not passed on
  * the CLI. Probes `gh pr list --head <branch> --state all` (the merged PR
  * is no longer `open`, so `--state all` is required). Returns `null` when
- * no PR is found.
+ * no PR is found. Exported for testing.
  *
- * @param {{ cwd: string, storyBranch: string, gh: object }} args
+ * @param {{ storyBranch: string, gh: object }} args
  * @returns {Promise<number|null>}
  */
-async function resolvePrNumber({ cwd, storyBranch, gh }) {
+export async function resolvePrNumber({ storyBranch, gh }) {
   try {
-    void cwd;
     const rows = await gh.pr.list(
       ['--head', storyBranch, '--state', 'all'],
       ['number', 'url'],
@@ -293,11 +292,11 @@ function buildConfirmTerminal({
   });
 }
 
-async function resolveConfirmPrNumber({ prParam, cwd, storyBranch, gh }) {
+async function resolveConfirmPrNumber({ prParam, storyBranch, gh }) {
   const rawPr = prParam ?? readPrFlag();
   let prNumber = Number.parseInt(String(rawPr ?? ''), 10);
   if (!Number.isInteger(prNumber) || prNumber <= 0) {
-    prNumber = await resolvePrNumber({ cwd, storyBranch, gh });
+    prNumber = await resolvePrNumber({ storyBranch, gh });
   }
   return Number.isInteger(prNumber) && prNumber > 0 ? prNumber : null;
 }
@@ -340,7 +339,6 @@ export async function runConfirmMerge({
 
   const prNumber = await resolveConfirmPrNumber({
     prParam,
-    cwd,
     storyBranch,
     gh,
   });

package/.agents/workflows/helpers/deliver-digest.md

@@ -20,16 +20,18 @@ description: >-
 
 ## 1. Dispatch — where the engine runs
 
-Read `stories[].dispatchMode` from the `resolve-stories.js` envelope. Two
-rules produce it, in order:
+Read `stories[].dispatchMode` from the `resolve-stories.js` envelope.
+`inline` names one indivisible resource — **the router's own session** — so one
+rule produces it:
 
 1. **Run topology.** A run resolving **one** Story is `inline`
    whatever its shape — sub-agent isolation is load-bearing only against a
    *concurrent* sibling racing the same checkout, and a one-Story run has none.
-2. **Body shape.** In a multi-Story run, a lite-shaped body is
-   `inline`; a full-shaped body, an unparseable one, or a footprint touching a
-   sensitive-path class is `subagent`. The `route::lite` label is a
-   human-visible hint, never the control signal.
+2. **Every other run is `subagent`.** A multi-Story run dispatches every Story
+   as a sub-agent however trivial its shape: a lite body does not conjure a
+   second session for a sibling to run in, and the wave tick may hand you the
+   whole set on one beat. Shape still sets ceremony and is reported alongside;
+   the `route::lite` label is a human-visible hint, never the control signal.
 
 `inline` removes model-side fan-out only — no `story-worker` boot, no fresh
 acceptance-critic spawn. **`subagent` and `inline` run the same engine**: same