mandrel 2.31.0 → 2.32.0

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

@@ -393,12 +393,13 @@ async function emitBlockedFriction(ticketId, fromState, newState, opts) {
  *   `agent::done` at story-close (after the merge lands), not when the
  *   last Task commit landed on the still-unmerged Story branch. The
  *   parameter is preserved for callers that still suppress cascade
- *   explicitly (e.g. batch-transition helpers).
+ *   explicitly (`single-story-init.js`, and `bulk.js` where the upward
+ *   recursion is driven by hand instead).
  *
  *   `ticketSnapshot` (Story #1795 / Epic #1788) is an optional pre-fetched
- *   ticket object. When the caller already holds the ticket (e.g.
- *   `batchTransitionTickets`, which loops over a list it just hydrated),
- *   passing the snapshot eliminates the two `getTicket` round-trips that
+ *   ticket object. When the caller already holds the ticket — e.g. it
+ *   hydrated the ticket to inspect its labels first — passing the
+ *   snapshot eliminates the two `getTicket` round-trips that
  *   `transitionTicketState` would otherwise issue — one for the notify
  *   `fromState` lookup and one inside `provider.updateTicket`'s label
  *   merge path. Backwards compatible: when omitted, behaviour is unchanged.

package/.agents/scripts/lib/orchestration/verify-tier-repair.js

@@ -0,0 +1,107 @@
+/**
+ * verify-tier-repair.js — repair-before-judging for the `verify[]` tier suffix
+ * (Story #5005).
+ *
+ * The tier suffix (`… (unit)`) is a deterministic, mechanically-derivable
+ * formality. `task-body-validator.js` already computed the corrected entry in
+ * order to print it as a "Suggested fix" — then rejected the plan anyway and
+ * charged the author a full re-drafting round to paste that exact string back.
+ * This module applies the inference the validator already trusts, so the hard
+ * error is reserved for the entries only the author can resolve.
+ *
+ * It lives beside the validator rather than inside it because the validator's
+ * job is to *judge*: mixing a mutating repair pass into a module of pure
+ * collectors muddies both. `persist-helpers.js#validateTickets` calls this
+ * first, then `validateTaskBodies`.
+ *
+ * @module lib/orchestration/verify-tier-repair
+ */
+
+import { suggestVerifyFix } from '../story-body/body-format-lints.js';
+import {
+  parse as parseStoryBody,
+  serialize as serializeStoryBody,
+} from '../story-body/story-body.js';
+import { VERIFY_TIER_VALUES } from './task-body-validator.js';
+
+/** A parenthesised tier drawn from the canonical vocabulary, at end of entry. */
+const VERIFY_TIER_RE = new RegExp(
+  `\\((?:${VERIFY_TIER_VALUES.join('|')})\\)\\s*$`,
+);
+
+/**
+ * Rewrite one `verify[]` list, appending the inferable testing tier to any
+ * entry missing one. Returns `null` when nothing changed, so callers can keep
+ * an already-compliant list byte-identical (and skip re-serializing the body
+ * it came from).
+ *
+ * @param {unknown} rawVerify
+ * @returns {string[]|null} The corrected list, or `null` when no fix applied.
+ */
+function repairVerifyList(rawVerify) {
+  if (!Array.isArray(rawVerify)) return null;
+  let changed = false;
+  const next = rawVerify.map((entry) => {
+    if (typeof entry !== 'string') return entry;
+    if (entry.startsWith('manual:') || VERIFY_TIER_RE.test(entry)) return entry;
+    const fix = suggestVerifyFix(entry);
+    if (fix === null) return entry;
+    changed = true;
+    return fix;
+  });
+  return changed ? next : null;
+}
+
+/**
+ * Repair the `## Verify` section of a serialized (string) body, in place on
+ * the ticket. Only re-serializes when a fix actually applied, so a compliant
+ * body is never round-tripped through `parse → serialize`.
+ *
+ * Leaving the body untouched while the top level was repaired would be worse
+ * than not repairing at all: `syncContractFieldFromTopLevel` fails closed on a
+ * body section that disagrees with its top-level array, so both sides must be
+ * repaired by the same rule or neither.
+ *
+ * @param {object} ticket
+ */
+function repairStringBodyVerify(ticket) {
+  let parsed;
+  try {
+    parsed = parseStoryBody(ticket.body).body;
+  } catch {
+    // An unparseable body is already a hard error in `validateTaskBodyShape`;
+    // there is nothing to repair and nothing to report twice.
+    return;
+  }
+  const repaired = repairVerifyList(parsed.verify);
+  if (repaired === null) return;
+  ticket.body = serializeStoryBody({ ...parsed, verify: repaired });
+}
+
+/**
+ * Auto-append the testing tier to `verify[]` entries that omit one, wherever
+ * `suggestVerifyFix` can infer it from the command. An entry whose tier cannot
+ * be inferred is left untouched and still hard-errors downstream.
+ *
+ * Mutates `tickets` in place (the persist pipeline threads this same array on
+ * to assembly) and returns it. Already-compliant tickets are untouched, so
+ * their persisted output stays byte-identical. Total — a non-array argument
+ * and non-Story tickets are no-ops.
+ *
+ * @param {object[]} tickets
+ * @returns {object[]} `tickets`
+ */
+export function normalizeVerifyTiers(tickets) {
+  for (const ticket of Array.isArray(tickets) ? tickets : []) {
+    if (!ticket || ticket.type !== 'story' || ticket.body == null) continue;
+    const topLevel = repairVerifyList(ticket.verify);
+    if (topLevel !== null) ticket.verify = topLevel;
+    if (typeof ticket.body === 'string') {
+      repairStringBodyVerify(ticket);
+      continue;
+    }
+    const bodyLevel = repairVerifyList(ticket.body.verify);
+    if (bodyLevel !== null) ticket.body.verify = bodyLevel;
+  }
+  return tickets;
+}

package/.agents/scripts/lib/qa/coverage-verdict.js

@@ -34,17 +34,12 @@
 //   operator-facing string explaining the verdict (always populated,
 //   including for present tiers).
 //
-//   acceptanceMatrix(criteria) -> {
-//     tiers: TIERS,
-//     rows: [{ id, label, verdict }, ...],
-//   }
-//
-//   Maps each acceptance criterion to its per-tier `coverageVerdict`, giving
-//   the AC × test-tier matrix the markdown report (lib/qa/coverage-report.js)
-//   renders.
+// Story #5008 removed the `acceptanceMatrix` feeder and the markdown report it
+// fed: the QA workflows read the per-tier verdict and author the missing-test
+// prose directly, so the AC x tier matrix was a round-trip with no reader.
 
-/** The three test tiers, in pyramid order (base → top). */
-export const TIERS = Object.freeze(['unit', 'contract', 'acceptance']);
+/** The three test tiers, in pyramid order (base -> top). */
+const TIERS = Object.freeze(['unit', 'contract', 'acceptance']);
 
 const PRESENT = 'present';
 const ABSENT = 'absent';
@@ -217,80 +212,3 @@ export function coverageVerdict(surface = {}) {
 
   return verdict;
 }
-
-/**
- * Normalize a single criterion descriptor into `{id, label, surface}`. A
- * descriptor may carry `id`, `label` (falls back to id), and either a nested
- * `surface` or a flat `{symbol, tests}` shape.
- */
-function normalizeOne(entry, index) {
-  const e = entry && typeof entry === 'object' ? entry : {};
-  const id =
-    typeof e.id === 'string' && e.id.trim() !== ''
-      ? e.id.trim()
-      : `AC-${index + 1}`;
-  const label =
-    typeof e.label === 'string' && e.label.trim() !== '' ? e.label.trim() : id;
-
-  let surface;
-  if (e.surface && typeof e.surface === 'object') {
-    surface = e.surface;
-  } else if (Array.isArray(e.tests) || typeof e.symbol === 'string') {
-    surface = { symbol: e.symbol, tests: e.tests };
-  } else {
-    surface = {};
-  }
-
-  return { id, label, surface };
-}
-
-/**
- * Normalize the criteria input for {@link acceptanceMatrix}. Accepts either an
- * array of criterion descriptors or a plain object keyed by criterion id whose
- * values are surfaces (or `{surface}` wrappers). Returns a normalized array of
- * `{id, label, surface}`.
- *
- * @param {Array<object>|object} criteria
- * @returns {Array<{id:string,label:string,surface:object}>}
- */
-function normalizeCriteria(criteria) {
-  if (Array.isArray(criteria)) {
-    return criteria.map((entry, index) => normalizeOne(entry, index));
-  }
-  if (criteria && typeof criteria === 'object') {
-    return Object.entries(criteria).map(([id, value], index) =>
-      normalizeOne(
-        value && typeof value === 'object' && !Array.isArray(value)
-          ? { id, ...value }
-          : { id, surface: { tests: value } },
-        index,
-      ),
-    );
-  }
-  throw new TypeError(
-    'acceptanceMatrix: criteria must be an array or an object',
-  );
-}
-
-/**
- * Build the AC × test-tier matrix: for each acceptance criterion, the per-tier
- * {@link coverageVerdict}. This is the structured shape the markdown report
- * (`lib/qa/coverage-report.js`) renders into a table.
- *
- * @param {Array<{id?:string,label?:string,surface?:object,symbol?:string,tests?:Array}>|Record<string,object>} criteria
- *   Acceptance criteria, either as an array of descriptors or an object keyed
- *   by criterion id. Each descriptor names a surface (nested `surface`, or a
- *   flat `{symbol, tests}`).
- * @returns {{tiers: ReadonlyArray<string>,
- *            rows: Array<{id:string,label:string,
- *                         verdict:ReturnType<typeof coverageVerdict>}>}}
- */
-export function acceptanceMatrix(criteria) {
-  const normalized = normalizeCriteria(criteria);
-  const rows = normalized.map(({ id, label, surface }) => ({
-    id,
-    label,
-    verdict: coverageVerdict(surface),
-  }));
-  return { tiers: TIERS, rows };
-}

package/.agents/scripts/lib/signals/detectors/common.js

@@ -2,7 +2,7 @@
  * detectors/common.js — shared helpers for the signals layer.
  *
  * Hoisted out of the detector modules (retry, rework) plus
- * `signals/read.js` and `signals/schema.js`, all of which shipped
+ * the since-deleted `signals/read.js`, and `signals/schema.js`, all of which shipped
  * byte-equivalent copies of these predicates. See Story #2464.
  */
 

package/.agents/scripts/lib/signals/index.js

@@ -1,7 +1,7 @@
 /**
  * `lib/signals/` barrel.
  *
- * Consumers do `import { read, schema, buildSpanTree, appendSignal } from './lib/signals/index.js'`
+ * Consumers do `import { schema, appendSignal } from './lib/signals/index.js'`
  * (or `import * as signals from './lib/signals/index.js'`) so a future
  * shape migration only has to touch this file.
  *
@@ -9,18 +9,20 @@
  *   - Epic #1181 / Story #1438 / Task #1459 — initial barrel with `read`
  *     + `schema`; `buildSpanTree` was a throwing placeholder.
  *   - Epic #1181 / Story #1440 / Task #1461 — placeholder replaced by
- *     the real export from `./span-tree.js`.
+ *     the real span-tree builder.
  *   - Story #1476 — `appendSignal` / `appendTrace` re-exported here
  *     via `./write.js` so the gate scripts (and any
  *     new code) converge on `lib/signals/` instead of importing the
  *     writer directly from `lib/observability/`.
+ *   - Story #5003 — the reader half (`read`, `buildSpanTree`) went with the
+ *     debug viewer that consumed it: it walked a `run-<id>/` layout no v2
+ *     writer populates. `appendTrace` went with the trace hook, its only
+ *     producer. What remains is the live write surface.
  *
  * @module lib/signals
  */
 
-import { read } from './read.js';
 import * as schema from './schema.js';
-import { buildSpanTree } from './span-tree.js';
-import { appendSignal, appendTrace, forEachLine } from './write.js';
+import { appendSignal, forEachLine } from './write.js';
 
-export { appendSignal, appendTrace, buildSpanTree, forEachLine, read, schema };
+export { appendSignal, forEachLine, schema };

package/.agents/scripts/lib/signals/schema.js

@@ -2,10 +2,10 @@
  * Signals schema — single source of truth for event-kind constants and
  * shape guards (Epic #1181 / Story #1438 / Task #1458).
  *
- * Both writers (`lib/observability/signals-writer.js` callers) and
- * readers (`lib/signals/read.js`, the retro's gather-signals phase)
- * import their field names from this module so the on-disk NDJSON shape
- * stays under one schema.
+ * Both writers (`lib/observability/signals-writer.js` callers) and readers
+ * (its `forEachLine` / `forEachSignalStreamLine` walkers, and the retro's
+ * gather-signals phase) import their field names from this module so the
+ * on-disk NDJSON shape stays under one schema.
  *
  * Pure module: importing has **no I/O side effects**. The exported
  * `EVENT_KINDS` object is `Object.freeze`'d so consumers can use it as a
@@ -14,30 +14,25 @@
  * ## Event-kind enumeration
  *
  * The set below is the audited union of `kind:` literals emitted via
- * `signals-writer.appendSignal` and `signals-writer.appendTrace` across
- * the codebase as of Epic #1181 (audit-snapshot 2026-05-11):
+ * `signals-writer.appendSignal` across the codebase as of Epic #1181
+ * (audit-snapshot 2026-05-11):
  *
  * Signals-writer `appendSignal` call sites:
  *   - `friction`       — quality-gate / runtime friction (diagnose-friction.js,
  *                        lib/gates/friction.js)
  *   - `acceptance-eval` — acceptance-eval.js per-criterion terminus signal.
- *   - `wave-start` / `wave-complete` — wave-window anchors; `wave-start` also
- *                        anchors span-tree Story spans
- *   - `wave-end`       — span-tree pairing anchor (retained for span-tree)
+ *   - `wave-start` / `wave-complete` — wave-window anchors.
+ *   - `wave-end`       — wave-window pairing anchor.
  *   - `state-transition` — notification-derived window anchor.
  *
  * The `dispatched` kind was deleted in the Epic #4406 signal-contract
  * cutover — it had no live emitter and no consumer.
  *
- * Signals-writer `appendTrace` call sites (traces.ndjson sibling, but
- * sharing the same envelope shape — `tool-trace-hook.js`):
- *   - `trace`          — per-tool-call timing record
- *
- * Detector-emitted / aggregator-consumed kinds (`rework`, `retry` are
- * emitted by `lib/signals/detectors/*`; `hotspot`, `churn`, `idle` remain
- * pinned in the enum for the aggregator's kind-count rollup even though no
- * live detector emits them):
- *   - `hotspot`, `rework`, `churn`, `idle`, `retry`
+ * Producerless kinds, pinned in the enum so a re-introduction needs no schema
+ * bump. Story #5003 deleted the last emitters of `trace` (the tool-trace hook
+ * and its `appendTrace` writer limb) and of `rework` / `retry` (the detector
+ * pair the hook fed); `hotspot`, `churn`, `idle` never had one:
+ *   - `trace`, `hotspot`, `rework`, `churn`, `idle`, `retry`
  *
  * ## Common envelope (canonical — Epic #4406 / Story #4413)
  *
@@ -68,18 +63,18 @@ import { isPositiveInt } from './detectors/common.js';
 
 /**
  * Frozen enumeration of every event kind currently emitted by
- * `signals-writer.appendSignal` / `appendTrace`, plus the
- * aggregator-consumed kinds whose detectors are future Stories.
+ * `signals-writer.appendSignal`, plus the producerless kinds a future Story
+ * may re-introduce an emitter for.
  *
  * Field names are kebab-cased to match the on-disk literals.
  */
 export const EVENT_KINDS = Object.freeze({
   FRICTION: 'friction',
   TRACE: 'trace',
-  // Wave-window forensics signals: `wave-start` / `wave-end` anchor the
-  // span-tree's Story spans. Story #4545 deleted the `waveParallelism`
-  // consumer (perf-aggregator) with the execution-analysis surface; these
-  // kinds stay as the span-tree's anchors.
+  // Wave-window forensics signals. Story #4545 deleted the `waveParallelism`
+  // consumer (perf-aggregator) with the execution-analysis surface, and
+  // Story #5003 deleted the span-tree that paired them; the kinds stay
+  // pinned so a re-introduced window reader needs no schema bump.
   WAVE_START: 'wave-start',
   WAVE_END: 'wave-end',
   WAVE_COMPLETE: 'wave-complete',
@@ -156,7 +151,7 @@ function isTimestamp(v) {
  * recognised `kind`. Canonical keys only — the legacy `timestamp` / `epic`
  * aliases were deleted in the Epic #4406 cutover.
  *
- * Returns true when the envelope is well-formed. Used by `lib/signals/read`
+ * Returns true when the envelope is well-formed. Used by the stream readers
  * to discard malformed lines before yielding them to the consumer.
  *
  * @param {unknown} evt

package/.agents/scripts/lib/signals/write.js

@@ -1,18 +1,18 @@
 /**
- * `lib/signals/write.js` — thin re-export of the signals/traces writer.
+ * `lib/signals/write.js` — thin re-export of the signals writer.
  *
  * The real implementation lives at `../observability/signals-writer.js`
  * (Epic #1030 / Story #1041). This module exists so callers can converge
- * on `lib/signals/` for both reads and writes — the reader barrel landed
- * in Epic #1181 / Story #1438, but the writer surface was still split
- * across `lib/observability/`. New code should `import { appendSignal }
- * from './lib/signals/index.js'` (or `'./lib/signals/write.js'` for a
- * narrower import); legacy direct imports from `lib/observability/` keep
- * working unchanged.
+ * on `lib/signals/` for the write surface. New code should
+ * `import { appendSignal } from './lib/signals/index.js'` (or
+ * `'./lib/signals/write.js'` for a narrower import); legacy direct imports
+ * from `lib/observability/` keep working unchanged.
+ *
+ * `appendTrace` was removed in Story #5003 together with the tool-trace
+ * hook — its only producer — and the viewer that was its only reader.
  */
 
 export {
   appendSignal,
-  appendTrace,
   forEachLine,
 } from '../observability/signals-writer.js';

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

@@ -21,7 +21,6 @@
  *   wide:                { reason } | null,// declared-wide footprint (optional)
  *   reason_to_exist:     string | null,    // one-sentence cohesion reason (optional)
  *   depends_on:          string[],         // blocker story slugs or #ids
- *   estimated_test_files: number | null,   // absent → null (informational)
  * }
  * ```
  *
@@ -79,7 +78,6 @@ import { suggestPathEntryFix } from './body-format-lints.js';
  * @property {{ reason: string }|null} wide      - Declared-wide footprint (reason), or null.
  * @property {string|null}   reason_to_exist     - One-sentence cohesion reason ("why this Story exists"), or null.
  * @property {string[]}      depends_on          - Blocking story slugs / issue refs.
- * @property {number|null}   estimated_test_files - Test surface count or null.
  * @property {string|null}   mandrel_version     - Framework version stamped at authoring, or null.
  * @property {string|null}   authored_at         - Authoring date (YYYY-MM-DD) stamped at authoring, or null.
  */
@@ -334,7 +332,7 @@ const META_BLOCK_RE = /<!--\s*meta:\s*([\s\S]*?)\s*-->/;
 const META_OBJECT_RE = /<!--\s*meta:\s*(\{[\s\S]*?\})\s*-->/;
 
 /**
- * Extract the `wide` / `estimated_test_files` fields from the trailing
+ * Extract the `wide` / `reason_to_exist` fields from the trailing
  * `<!-- meta: {...} -->` comment block written by {@link serialize}. Returns
  * canonical-shaped values (null when absent or malformed) so the parser
  * round-trips the meta block faithfully.
@@ -350,13 +348,12 @@ const META_OBJECT_RE = /<!--\s*meta:\s*(\{[\s\S]*?\})\s*-->/;
  * rather than dropping or re-deriving it.
  *
  * @param {string} markdown
- * @returns {{ wide: { reason: string }|null, reason_to_exist: string|null, estimated_test_files: number|null, mandrel_version: string|null, authored_at: string|null }}
+ * @returns {{ wide: { reason: string }|null, reason_to_exist: string|null, mandrel_version: string|null, authored_at: string|null }}
  */
 function extractMeta(markdown) {
   const result = {
     wide: null,
     reason_to_exist: null,
-    estimated_test_files: null,
     mandrel_version: null,
     authored_at: null,
   };
@@ -377,9 +374,6 @@ function extractMeta(markdown) {
 
   result.wide = normalizeWide(parsed.wide);
   result.reason_to_exist = normalizeReasonToExist(parsed.reason_to_exist);
-  if (typeof parsed.estimated_test_files === 'number') {
-    result.estimated_test_files = parsed.estimated_test_files;
-  }
   if (
     typeof parsed.mandrel_version === 'string' &&
     parsed.mandrel_version.trim()
@@ -579,7 +573,6 @@ function isMachineMarkerLine(line) {
 function parseUnstructuredBody(input, preamble, footer) {
   const warnings = [
     'unstructured-body: no structured sections found; returning minimal body from preamble text.',
-    'test-surface-unestimated: estimated_test_files not present.',
   ];
   const body = {
     goal: preamble || input.trim(),
@@ -593,7 +586,6 @@ function parseUnstructuredBody(input, preamble, footer) {
     wide: null,
     reason_to_exist: null,
     depends_on: extractBlockedBy(footer),
-    estimated_test_files: null,
     mandrel_version: null,
     authored_at: null,
   };
@@ -688,11 +680,6 @@ function parseTextListSection(lines) {
  * `result.warnings` to detect legacy path entries that should be
  * migrated.
  *
- * Informational finding emitted on `result.warnings`:
- * - `test-surface-unestimated` — when `estimated_test_files` is absent
- *   from both a structured body and the markdown. Callers that care about
- *   test-surface coverage SHOULD surface this to the operator.
- *
  * @param {string|object} input - Markdown string or already-structured body object.
  * @returns {ParseResult}
  * @throws {StoryBodyParseError} When the body is structurally unrecoverable.
@@ -765,20 +752,16 @@ export function parse(input) {
   const non_goals = parseTextListSection(sections.get('non_goals') ?? []);
   const dependsOn = extractBlockedBy(footer);
 
-  // --- Recover wide / estimated_test_files from the meta block ---
+  // --- Recover wide / reason_to_exist / provenance from the meta block ---
   // serialize() writes these into a trailing `<!-- meta: {...} -->` comment
   // so round-trips preserve them. Absent meta block → canonical null defaults.
+  // Unknown keys are ignored, so a body carrying a retired meta field parses
+  // clean and simply drops it.
   const meta = extractMeta(input);
-  const estimated_test_files = meta.estimated_test_files;
   const wide = meta.wide;
   const reason_to_exist = meta.reason_to_exist;
   const mandrel_version = meta.mandrel_version;
   const authored_at = meta.authored_at;
-  if (estimated_test_files === null) {
-    warnings.push(
-      'test-surface-unestimated: estimated_test_files not present.',
-    );
-  }
 
   const body = {
     goal,
@@ -792,7 +775,6 @@ export function parse(input) {
     wide,
     reason_to_exist,
     depends_on: dependsOn,
-    estimated_test_files,
     mandrel_version,
     authored_at,
   };
@@ -834,13 +816,6 @@ function parseStructuredObject(obj) {
     body[name] = STRUCTURED_FIELD_NORMALIZERS[kind](obj[name], warnings);
   }
 
-  // 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,
-  );
-
   // Provenance stamp (preserved verbatim; never re-derived here).
   body.mandrel_version = normalizeProvenanceString(obj.mandrel_version);
   body.authored_at = normalizeProvenanceString(obj.authored_at);
@@ -917,25 +892,6 @@ const STRUCTURED_FIELD_NORMALIZERS = {
   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`.
@@ -1066,11 +1022,11 @@ const SERIALIZE_SECTIONS = [
 
 /**
  * Build the trailing `<!-- meta: {...} -->` block carrying the fields that
- * have no human-readable section (`wide`, `reason_to_exist`,
- * `estimated_test_files`). Returns the empty string when no meta field is
- * present so {@link serialize} appends nothing.
+ * have no human-readable section (`wide`, `reason_to_exist`). Returns the
+ * empty string when no meta field is present so {@link serialize} appends
+ * nothing.
  *
- * Key insertion order (`wide` → `reason_to_exist` → `estimated_test_files` →
+ * Key insertion order (`wide` → `reason_to_exist` →
  * `mandrel_version` → `authored_at`) is load-bearing: it fixes the serialized
  * JSON byte sequence the parser's meta round-trip and the unit suite assert
  * against. The provenance stamp keys are appended **last** so every
@@ -1089,9 +1045,6 @@ function serializeMetaBlock(body) {
   if (reasonToExist !== null) {
     metaFields.reason_to_exist = reasonToExist;
   }
-  if (typeof body.estimated_test_files === 'number') {
-    metaFields.estimated_test_files = body.estimated_test_files;
-  }
   if (typeof body.mandrel_version === 'string' && body.mandrel_version.trim()) {
     metaFields.mandrel_version = body.mandrel_version.trim();
   }
@@ -1153,9 +1106,9 @@ function serializeFooter(body, opts) {
  * `## Goal`, `## Slicing`, `## Spec`, `## Changes`, `## Acceptance`,
  * `## Verify`, `## References`, `## Non-Goals` (each omitted when empty).
  *
- * `wide`, `reason_to_exist`, and `estimated_test_files` are emitted as a
- * fenced `<!-- meta -->` comment block so round-trips preserve them without
- * polluting the human-readable body.
+ * `wide` and `reason_to_exist` are emitted as a fenced `<!-- meta -->`
+ * comment block so round-trips preserve them without polluting the
+ * human-readable body.
  *
  * @param {StoryBody} body
  * @param {SerializeOptions} [opts]

package/.agents/scripts/lib/temp-retention.js

@@ -31,7 +31,7 @@
  * ## Keep-class
  *
  * `signals.ndjson` is the artifact whose value *starts* when the run ends —
- * `signals-view`, `acceptance-eval`, and the loop-health check all read it
+ * `acceptance-eval` and the loop-health check both read it
  * long after the Story merged. It is excluded twice over: it is not in the
  * evidence basename allowlist, and {@link KEEP_BASENAMES} is re-checked at
  * the deletion site. Defence in depth is warranted for the one file whose