mandrel 2.59.0 → 2.60.0

package/.agents/scripts/lib/orchestration/story-follow-ups.js

@@ -9,7 +9,10 @@
  * @module lib/orchestration/story-follow-ups
  */
 
-import { signalsFile } from '../config/temp-paths.js';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { orchestrationLogDir, signalsFile } from '../config/temp-paths.js';
 import { graduateRetroProposals } from '../feedback-loop/retro-proposals-graduator.js';
 import {
   DEFAULT_FRAMEWORK_REPO,
@@ -30,6 +33,76 @@ import { upsertStructuredComment } from './ticketing.js';
 
 const FOLLOW_UPS_COMMENT_TYPE = 'follow-ups';
 
+/**
+ * Publish a rendered roll-up — as a `follow-ups` comment when the run actually
+ * filed something, and as a run artifact under the temp root when it did not.
+ *
+ * Story #5341 made the filing the condition. The comment had been
+ * unconditional, and the corpus it rendered is dominated by noise: #5324's
+ * roll-up carried 116 signals and filed nothing, and #4653 / #4833 / #4834 /
+ * #4836 record filings that were false or leaked from fixtures. A comment that
+ * says "nothing to do" on every Story trains its readers to skip the one that
+ * does not — while the roll-up itself is still written, so nothing is lost,
+ * only moved off the ticket.
+ *
+ * @param {object} args
+ * @param {number} args.anchorId — the ticket the roll-up belongs to.
+ * @param {string} args.body — the rendered roll-up.
+ * @param {number} args.filedCount — issues this roll-up actually filed.
+ * @param {object} args.provider
+ * @param {object} [args.config]
+ * @returns {Promise<{ posted: boolean, artifactPath: string|null, summary: string }>}
+ */
+export async function publishFollowUpsRollup({
+  anchorId,
+  body,
+  filedCount,
+  provider,
+  config,
+}) {
+  return filedCount > 0
+    ? postFollowUpsComment({ anchorId, body, filedCount, provider })
+    : parkFollowUpsRollup({ anchorId, body, config });
+}
+
+/**
+ * Post the roll-up as the `follow-ups` structured comment.
+ *
+ * @param {object} args
+ * @returns {Promise<{ posted: true, artifactPath: null, summary: string }>}
+ */
+async function postFollowUpsComment({ anchorId, body, filedCount, provider }) {
+  await upsertStructuredComment(
+    provider,
+    anchorId,
+    FOLLOW_UPS_COMMENT_TYPE,
+    body,
+  );
+  return {
+    posted: true,
+    artifactPath: null,
+    summary: `Captured follow-ups for #${anchorId} (filed=${filedCount}).`,
+  };
+}
+
+/**
+ * Write the roll-up to the run artifacts under the temp root.
+ *
+ * @param {object} args
+ * @returns {Promise<{ posted: false, artifactPath: string, summary: string }>}
+ */
+async function parkFollowUpsRollup({ anchorId, body, config }) {
+  const dir = orchestrationLogDir(config);
+  const artifactPath = path.join(dir, `follow-ups-rollup-${anchorId}.md`);
+  await mkdir(dir, { recursive: true });
+  await writeFile(artifactPath, `${body}\n`, 'utf8');
+  return {
+    posted: false,
+    artifactPath,
+    summary: `No follow-ups filed for #${anchorId} — roll-up kept at ${artifactPath}.`,
+  };
+}
+
 /** Milliseconds in one day — the unit `frictionWindowDays` is expressed in. */
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 
@@ -708,6 +781,52 @@ export function buildFollowUpsCommentBody({
   return lines.join('\n');
 }
 
+/**
+ * Compose the routed proposals for one Story's friction corpus.
+ *
+ * @param {number} sid
+ * @param {Array<object>} signals
+ * @param {object} [config]
+ * @returns {object}
+ */
+function composeStoryProposals(sid, signals, config) {
+  const repos = resolveFollowUpRepos(config);
+  return composeRoutedProposals({
+    anchorId: sid,
+    anchorKind: 'story',
+    frameworkRepo: repos.frameworkRepo,
+    consumerRepo: repos.consumerRepo,
+    signals,
+    // Derived, not hardcoded `[]` (Story #4649). This is the escape hatch
+    // the retired story-scope threshold carve-out was standing in for: a
+    // Story still parked at `agent::blocked` files at a single occurrence,
+    // while one that blocked and self-resolved nets out entirely.
+    unresolvedBlockedEvents: deriveUnresolvedBlockedEvents(signals),
+  });
+}
+
+/**
+ * Hand one Story's routed proposals to the graduator.
+ *
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+function fileStoryProposals({ sid, proposals, provider, config, cwd }) {
+  const repos = resolveFollowUpRepos(config);
+  return graduateRetroProposals({
+    epicId: sid,
+    provider,
+    config,
+    currentRepo: repos.currentRepo,
+    // The resolved bucket object, not a re-split of the slug: routing is
+    // decided once in `github/framework-repo.js`.
+    frameworkRepo: repos.repos.framework,
+    platformRepo: repos.repos.platform,
+    routedProposals: proposals,
+    cwd,
+  });
+}
+
 /**
  * Capture and persist Story follow-ups. Never throws — the land must not
  * fail because follow-up filing flaked.
@@ -743,29 +862,12 @@ export async function captureStoryFollowUps({
   }
   try {
     const signals = await gatherStoryFrictionSignals(sid, config);
-    const repos = resolveFollowUpRepos(config);
-    const proposals = composeRoutedProposals({
-      anchorId: sid,
-      anchorKind: 'story',
-      frameworkRepo: repos.frameworkRepo,
-      consumerRepo: repos.consumerRepo,
-      signals,
-      // Derived, not hardcoded `[]` (Story #4649). This is the escape hatch
-      // the retired story-scope threshold carve-out was standing in for: a
-      // Story still parked at `agent::blocked` files at a single occurrence,
-      // while one that blocked and self-resolved nets out entirely.
-      unresolvedBlockedEvents: deriveUnresolvedBlockedEvents(signals),
-    });
-    const graduated = await graduateRetroProposals({
-      epicId: sid,
+    const proposals = composeStoryProposals(sid, signals, config);
+    const graduated = await fileStoryProposals({
+      sid,
+      proposals,
       provider,
       config,
-      currentRepo: repos.currentRepo,
-      // The resolved bucket object, not a re-split of the slug: routing is
-      // decided once in `github/framework-repo.js`.
-      frameworkRepo: repos.repos.framework,
-      platformRepo: repos.repos.platform,
-      routedProposals: proposals,
       cwd,
     });
     const body = buildFollowUpsCommentBody({
@@ -775,30 +877,45 @@ export async function captureStoryFollowUps({
       signalCount: signals.length,
       categories: summarizeSignalCategories(signals),
     });
-    await upsertStructuredComment(provider, sid, FOLLOW_UPS_COMMENT_TYPE, body);
-    progress?.(
-      'FOLLOW-UPS',
-      `Captured follow-ups for Story #${sid} (filed=${graduated.filed?.length ?? 0}).`,
-    );
+    const filedCount = graduated.filed?.length ?? 0;
+    const published = await publishFollowUpsRollup({
+      anchorId: sid,
+      body,
+      filedCount,
+      provider,
+      config,
+    });
+    progress?.('FOLLOW-UPS', published.summary);
     return {
       ok: true,
       storyId: sid,
       proposals,
       graduated,
       signalCount: signals.length,
+      commentPosted: published.posted,
+      artifactPath: published.artifactPath,
     };
   } catch (err) {
-    Logger.warn(
-      `[story-follow-ups] capture failed for #${sid}: ${err?.message ?? err}`,
-    );
-    progress?.(
-      'FOLLOW-UPS',
-      `⚠️ Follow-up capture failed (close continues): ${err?.message ?? err}`,
-    );
-    return {
-      ok: false,
-      reason: 'capture-failed',
-      error: String(err?.message ?? err),
-    };
+    return reportCaptureFailure(sid, err, progress);
   }
 }
+
+/**
+ * Report a failed capture without failing the close around it — follow-up
+ * capture is a reporting step, so a provider or filesystem fault degrades the
+ * report and never the land.
+ *
+ * @param {number} sid
+ * @param {unknown} err
+ * @param {((tag: string, msg: string) => void)} [progress]
+ * @returns {{ ok: false, reason: string, error: string }}
+ */
+function reportCaptureFailure(sid, err, progress) {
+  const detail = String(err?.message ?? err);
+  Logger.warn(`[story-follow-ups] capture failed for #${sid}: ${detail}`);
+  progress?.(
+    'FOLLOW-UPS',
+    `⚠️ Follow-up capture failed (close continues): ${detail}`,
+  );
+  return { ok: false, reason: 'capture-failed', error: detail };
+}

package/.agents/scripts/lib/orchestration/story-init-envelope.js

@@ -0,0 +1,71 @@
+/**
+ * story-init-envelope.js — read back the envelope `single-story-init.js`
+ * writes for one Story.
+ *
+ * Init routes its full result object to
+ * `<tempRoot>/orchestration/story-init-result-<id>.log` through
+ * `emitTerseResult`, wrapped in the same `--- STORY INIT RESULT ---` markers
+ * the legacy inline dump used. Story #5343 retired the `story-init` ticket
+ * comment that duplicated it, which makes this file the durable record of
+ * what a run was seeded with — most load-bearingly the `runScopedConfig` pin
+ * `run-scoped-config.js` compares against at close.
+ *
+ * Total and non-throwing: a missing, unreadable or unparseable envelope
+ * resolves to `null`, and the caller reports the degrade. Reading it is
+ * always best-effort — the temp tree is reapable by design.
+ *
+ * @module lib/orchestration/story-init-envelope
+ */
+
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { orchestrationLogDir } from '../config/temp-paths.js';
+
+/**
+ * Read one Story's init envelope, or `null` when there is none to read.
+ *
+ * @param {{
+ *   storyId: number|string,
+ *   config?: object,
+ *   readFileFn?: typeof readFileSync,
+ * }} args
+ * @returns {object|null} the parsed init result, or `null`.
+ */
+function readStoryInitEnvelope({ storyId, config, readFileFn = readFileSync }) {
+  const file = path.join(
+    orchestrationLogDir(config),
+    `story-init-result-${storyId}.log`,
+  );
+  try {
+    // The log brackets the pretty JSON with human markers, so take the
+    // outermost brace span rather than parsing the whole file.
+    const fence = /\{[\s\S]*\}/.exec(readFileFn(file, 'utf8'));
+    const payload = fence ? JSON.parse(fence[0]) : null;
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The `runScopedConfig` pin off one Story's init envelope, or `null` when the
+ * envelope is absent or carries none. The write half is
+ * `run-scoped-config.js#pinRunScopedConfig`, which `single-story-init.js`
+ * records on the envelope this reads back.
+ *
+ * @param {{
+ *   storyId: number|string,
+ *   config?: object,
+ *   readEnvelopeFn?: typeof readStoryInitEnvelope,
+ * }} args
+ * @returns {Record<string, unknown>|null}
+ */
+export function readRunScopedPin({
+  storyId,
+  config,
+  readEnvelopeFn = readStoryInitEnvelope,
+}) {
+  const pin = readEnvelopeFn({ storyId, config })?.runScopedConfig;
+  return pin && typeof pin === 'object' ? pin : null;
+}

package/.agents/scripts/lib/orchestration/task-body-validator.js

@@ -19,9 +19,11 @@
  * the 2-tier hierarchy (Epic → Story).
  *
  * Required after parse/normalize: a non-empty `goal`, and non-empty
- * `changes`, `acceptance`, and `verify` arrays — and `changes` items must
- * name at least one path-shaped token so vague verbs ("clean up",
- * "refactor") can't slip through.
+ * `changes` and `acceptance` arrays — and `changes` items must name at least
+ * one path-shaped token so vague verbs ("clean up", "refactor") can't slip
+ * through. Story #5342 dropped the non-empty `verify` requirement: an empty
+ * `verify[]` is a dry-run warning the ticket validator raises, not a
+ * refusal.
  *
  * `acceptance` / `verify` are the **top-level machine contract** (Story
  * #4541). The decomposer prompt tells authors to write those lists once at
@@ -43,8 +45,8 @@
  *
  * `body.verify` entries are commands, nothing more: Story #5312 deleted the
  * `(<tier>)` suffix, the `manual:<reason>` escape and the repair pass that
- * appended the suffix for the author. The only verify rule left is that the
- * list is non-empty.
+ * appended the suffix for the author, and Story #5342 deleted the last rule
+ * — the non-empty check. This validator no longer scores `verify` at all.
  *
  * The errors are batched and surfaced as a single thrown Error so the
  * planner can see every offending slug in one pass instead of fixing one
@@ -69,7 +71,7 @@ import { FILE_ASSUMPTION_VALUES } from './file-assumption-enum.js';
  * Story body to a markdown string, so a *string* body is NOT skipped here
  * (Story #3906) — `validateTaskBodyShape` parses it back into structured
  * form via `parseStoryBody` before applying the section rules. This is what
- * makes the non-empty-verify / vague-verb / non-empty-goal checks actually fire
+ * makes the vague-verb / non-empty-goal checks actually fire
  * on real plans. Features (and everything else) use narrative string bodies
  * and are skipped by the `type !== 'story'` guard.
  *
@@ -185,7 +187,6 @@ export function validateTaskBodyShape(ticket) {
   }
   errors.push(...collectChangesErrors(prefix, body.changes));
   errors.push(...collectAcceptanceErrors(prefix, body.acceptance));
-  errors.push(...collectVerifyErrors(prefix, body.verify));
   errors.push(...collectReferencesErrors(prefix, body.references));
   return errors;
 }
@@ -306,16 +307,6 @@ function collectAcceptanceErrors(prefix, rawAcceptance) {
  * @param {unknown} rawVerify
  * @returns {string[]}
  */
-function collectVerifyErrors(prefix, rawVerify) {
-  const verify = Array.isArray(rawVerify) ? rawVerify : [];
-  if (verify.length === 0) {
-    return [
-      `${prefix}: verify must list at least one entry — author it at the ticket's top level (preferred) or in the body's ## Verify section.`,
-    ];
-  }
-  return [];
-}
-
 /**
  * Validate every 2-tier Story in `tickets` whose `body` is a structured
  * object. Returns an array of error strings (one per offending slug); empty

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

@@ -3,7 +3,6 @@ import { normalizeOwnedProvenance } from '../findings/provenance-field.js';
 import { detectCycle } from '../Graph.js';
 import { gitSpawn } from '../git-utils.js';
 
-import { Logger } from '../Logger.js';
 import { validateStoryFileAssumptions } from './file-assumptions.js';
 import { isExternalDependencyRef } from './plan-persist/external-deps.js';
 import {
@@ -41,38 +40,6 @@ function collectPathsFromText(text, paths) {
   }
 }
 
-/**
- * Resolve every acceptance line a Story declares, across both authoring
- * shapes (Story #4541).
- *
- * The canonical shape is a **serialized string body** with the criteria at
- * the ticket's **top level** — the machine contract persist syncs into the
- * body. `validateAcceptanceSubjectPrefix` used to read `body.acceptance` on
- * an object body only, so on every real plan it scanned nothing and the gate
- * silently passed. Union both sources (deduplicated) so the gate fires on
- * whichever surface the author used.
- *
- * @param {object} story
- * @returns {string[]}
- */
-function resolveAcceptanceLines(story) {
-  const lines = new Set();
-  if (Array.isArray(story?.acceptance)) {
-    for (const item of story.acceptance) lines.add(String(item ?? ''));
-  }
-  const body = story?.body;
-  let bodyAcceptance = null;
-  if (typeof body === 'string' && body.trim().length > 0) {
-    bodyAcceptance = parseStoryBodyOrThrow(story).acceptance;
-  } else if (body !== null && typeof body === 'object') {
-    bodyAcceptance = body.acceptance;
-  }
-  if (Array.isArray(bodyAcceptance)) {
-    for (const item of bodyAcceptance) lines.add(String(item ?? ''));
-  }
-  return [...lines];
-}
-
 function collectTaskPathReferences(task) {
   const paths = new Set();
   const body = task.body;
@@ -283,117 +250,6 @@ export function validateAcFreshness({
   return misses.map((m) => renderMissLine(m, baseBranchRef));
 }
 
-/**
- * Allowed leading Conventional-Commits types. Mirrors the `changelog-sections`
- * keys in `release-please-config.json` and the `type-enum` list in
- * `commitlint.config.js`. When a planner LLM prescribes a commit subject in a
- * Task acceptance item via the "Commit subject begins with '<prefix>:'" form,
- * the captured prefix must reduce to one of these types (optionally followed
- * by a `(scope)` qualifier) — anything else fails commitlint locally and
- * release-please's changelog parser on `main`, so the decompose is rejected
- * before the Story branch is ever cut.
- *
- * Epic #2501 introduced this guard after the legacy `baseline-refresh`
- * leading-token prescription created a wave of commit-msg hook failures
- * across story-deliver sub-agents. See
- * `.agents/skills/core/gates-and-baselines/SKILL.md` for the canonical refresh
- * shape (Conventional-Commits subject + `baseline-refresh: true` body
- * trailer).
- */
-const ALLOWED_COMMIT_TYPES = new Set([
-  'feat',
-  'fix',
-  'chore',
-  'refactor',
-  'perf',
-  'docs',
-  'style',
-  'test',
-  'build',
-  'ci',
-  'revert',
-]);
-
-/**
- * Regex matching the canonical "Commit subject begins with '<prefix>:'"
- * prescription shape the planner emits in `body.acceptance[]` entries.
- * The leading quote is captured loosely (single, double, or backtick) so the
- * three quoting styles the decomposer LLM has historically emitted all
- * match. The captured group is the prefix token *without* the trailing
- * colon — callers normalize by stripping an optional `(scope)` qualifier
- * before comparing against the allowed-types set.
- */
-const SUBJECT_PREFIX_RE = /Commit subject begins with ['"`]([^'"`]+):['"`]/g;
-
-/**
- * Scan every Story's `body.acceptance[]` for "Commit subject begins with
- * '<prefix>:'" prescriptions and reject the decompose when any captured
- * prefix is not a valid Conventional-Commits type.
- *
- * A captured prefix of the form `chore(baselines)` is accepted — the
- * leading `chore` is in the allowed-types set, and the `(scope)` qualifier
- * is the standard Conventional-Commits scope shape. A captured prefix of
- * the form `baseline-refresh` is rejected because no Conventional-Commits
- * type starts with that token.
- *
- * Only acceptance criteria are scanned; `body.goal` / `body.verify` /
- * `body.changes` are not commit-subject prescriptions by convention and
- * scanning them would surface false positives from prose that happens to
- * quote a forbidden prefix while explaining why it's forbidden.
- *
- * Both authoring shapes are covered (Story #4541): the canonical top-level
- * `acceptance[]` on a serialized string body, and the pre-serialize
- * `body.acceptance[]` object shape. Scanning only the latter made the gate
- * inert on every real plan.
- *
- * @param {object}   opts
- * @param {object[]} opts.tickets - Validated ticket hierarchy.
- * @throws {ValidationError} when one or more Story acceptance items
- *   prescribe a forbidden subject prefix. The error carries
- *   `code: 'forbidden-subject-prefix'` and a `violations[]` payload
- *   listing each `{ slug, prefix, line }` so the decompose loop can
- *   surface the exact offending text to the operator.
- */
-export function validateAcceptanceSubjectPrefix({ tickets }) {
-  const violations = [];
-  const stories = (tickets ?? []).filter((t) => t.type === 'story');
-  for (const story of stories) {
-    for (const line of resolveAcceptanceLines(story)) {
-      // Reset the global regex between iterations.
-      SUBJECT_PREFIX_RE.lastIndex = 0;
-      let match = SUBJECT_PREFIX_RE.exec(line);
-      while (match !== null) {
-        const rawPrefix = match[1];
-        // Strip an optional `(scope)` qualifier — `chore(baselines)` reduces
-        // to `chore` for the allowed-types check.
-        const type = rawPrefix.replace(/\(.*\)$/, '').trim();
-        if (!ALLOWED_COMMIT_TYPES.has(type)) {
-          violations.push({
-            slug: story.slug ?? '<unknown>',
-            prefix: rawPrefix,
-            line,
-          });
-        }
-        match = SUBJECT_PREFIX_RE.exec(line);
-      }
-    }
-  }
-  if (violations.length === 0) return;
-  const allowed = [...ALLOWED_COMMIT_TYPES].join('|');
-  const lines = violations
-    .map(
-      (v) =>
-        `  - "${v.slug}" → forbidden subject prefix "${v.prefix}:" in acceptance item: ${v.line}`,
-    )
-    .join('\n');
-  const err = new ValidationError(
-    `Cross-Validation Failed: ${violations.length} Story acceptance item(s) prescribe a non-Conventional-Commits subject prefix:\n${lines}\n\nAllowed leading types: ${allowed}. Use a Conventional-Commits subject (e.g. "chore(baselines): refresh ...") and a body trailer (e.g. "baseline-refresh: true") for machine-readable markers. See Epic #2501.`,
-    { violations },
-  );
-  err.code = 'forbidden-subject-prefix';
-  throw err;
-}
-
 /**
  * Render one missing-path warning with a remediation hint pointing at the
  * Story's `changes[]`. For `tests/**` paths we suggest the explicit
@@ -482,44 +338,55 @@ function assertAllTicketsAreStories({ tickets, stories }) {
 }
 
 /**
- * Return true when a Story object carries inline acceptance + verify
- * arrays — the inline-contract shape (Epic #3078) where the Story is itself the
- * implementation unit and acceptance / verify live on the Story body
- * rather than in child Task tickets.
+ * Return true when a Story carries a non-empty top-level `acceptance[]` —
+ * the inline-contract shape (Epic #3078) where the Story is itself the
+ * implementation unit and its criteria live on the Story rather than in
+ * child Task tickets.
  *
- * Both arrays must be present, be actual arrays, and contain at least
- * one entry. Either alone is insufficient — a Story with only
- * `acceptance[]` (no `verify[]`) cannot be implemented without a
- * verification handle, and a Story with only `verify[]` (no
- * `acceptance[]`) carries no observable criterion. Requiring both is the
- * inline-contract invariant every Story must satisfy.
+ * Story #5342 narrowed the invariant to `acceptance[]` alone. A Story with
+ * no observable criterion is genuinely unimplementable and nothing
+ * downstream can recover it; an empty `verify[]` only means the deliverer
+ * picks the commands, which the close gate chain runs regardless — so that
+ * half is a warning ({@link collectMissingVerifyWarnings}), not a refusal.
  */
-function hasInlineAcceptanceAndVerify(story) {
+function hasInlineAcceptance(story) {
   if (story === null || typeof story !== 'object') return false;
-  const { acceptance, verify } = story;
-  return (
-    Array.isArray(acceptance) &&
-    acceptance.length > 0 &&
-    Array.isArray(verify) &&
-    verify.length > 0
-  );
+  const { acceptance } = story;
+  return Array.isArray(acceptance) && acceptance.length > 0;
 }
 
 function assertEveryStoryHasInlineContract({ stories }) {
-  // Every Story is its own implementation
-  // unit and MUST carry a non-empty inline contract — top-level
-  // `acceptance[]` AND `verify[]`. A Story missing either is the legacy
-  // 4-tier shape that expected child Tasks; there is no Task tier any
-  // more, so such a Story is unimplementable and the decompose is
-  // rejected outright.
-  const missing = stories.filter((s) => !hasInlineAcceptanceAndVerify(s));
+  const missing = stories.filter((s) => !hasInlineAcceptance(s));
   if (missing.length === 0) return;
   const list = missing.map((s) => `"${s.title}" (${s.slug})`).join(', ');
   throw new Error(
-    `Cross-Validation Failed: ${missing.length} Story/Stories lack an inline acceptance + verify contract: ${list}. Every Story must carry non-empty top-level acceptance[] and verify[].`,
+    `Cross-Validation Failed: ${missing.length} Story/Stories lack an inline acceptance contract: ${list}. Every Story must carry a non-empty top-level acceptance[] — the outcomes a PR reviewer confirms once it lands.`,
   );
 }
 
+/**
+ * One warning per Story with no `verify[]` entry (Story #5342).
+ *
+ * Demoted from the hard refusal above: an absent verify list costs the
+ * acceptance critic its cheapest evidence, which is worth saying on the
+ * dry-run, but it never makes the Story unimplementable — the deliverer
+ * derives the commands and the close gate chain runs either way.
+ *
+ * @param {object[]} stories
+ * @returns {string[]}
+ */
+function collectMissingVerifyWarnings(stories) {
+  return (stories ?? [])
+    .filter((s) => !Array.isArray(s?.verify) || s.verify.length === 0)
+    .map(
+      (s) =>
+        `Story "${s.slug ?? s.title ?? '<unknown>'}" lists no verify[] entry — ` +
+        'the deliverer and the acceptance critic have no mechanical check to ' +
+        'read as evidence. Add the exact command or test path unless the ' +
+        'Story genuinely has none.',
+    );
+}
+
 /**
  * Shape-check the optional per-Story `provenance` field (Story #5045).
  *
@@ -619,19 +486,12 @@ export function validateAndNormalizeTickets(tickets, opts = {}) {
   assertAcyclic(slugAdjacency);
 
   // Story #4541 — refuse an unparseable Story body up front, with a named
-  // error pointing at the offending section + entry. Must precede both the
-  // subject-prefix scan and the freshness gate: each parses the body, and
-  // the freshness gate's net-new whitelist comes from `body.changes`, so a
-  // malformed body used to surface as a stale-path miss naming the paths the
-  // Story had legitimately declared.
+  // error pointing at the offending section + entry. Must precede the
+  // freshness gate: it parses the body, and its net-new whitelist comes from
+  // `body.changes`, so a malformed body used to surface as a stale-path miss
+  // naming the paths the Story had legitimately declared.
   assertStoryBodiesParse({ tickets });
 
-  // Reject any Task acceptance item that prescribes a non-Conventional-Commits
-  // subject prefix (e.g. legacy "Commit subject begins with 'baseline-refresh:'"
-  // from pre-Epic-#2501 planner output). Runs before the freshness gate so
-  // the failure mode is reported up-front rather than after a git probe.
-  validateAcceptanceSubjectPrefix({ tickets });
-
   // Hoist a single memoized (ref, path) → boolean probe shared across both
   // git-probe gates below. Without this, `validateAcFreshness` and
   // `validateStoryFileAssumptions` each maintain an independent cache, so a
@@ -643,7 +503,7 @@ export function validateAndNormalizeTickets(tickets, opts = {}) {
     ? makeMemoizedGitRunner(opts.gitRunner ?? defaultGitRunner)
     : null;
 
-  const warnings = [];
+  const warnings = [...collectMissingVerifyWarnings(stories)];
   // Story #5312: a goal / acceptance / verify path absent at base is a
   // warning the dry-run lists, not a refusal. Skipped when the caller omits
   // `baseBranchRef` so unit tests keep their semantics; production
@@ -702,5 +562,6 @@ export const _internal = {
   assertNoUnknownDeps,
   assertAcyclic,
   attachFindingsAndErrors,
-  hasInlineAcceptanceAndVerify,
+  hasInlineAcceptance,
+  collectMissingVerifyWarnings,
 };