mandrel 2.58.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-conflicts.js

@@ -8,13 +8,12 @@ import { computeStoryReachability } from './story-reachability.js';
  * `collectStoryAssumptionEntries` (Story #3302) and the sizing gate's
  * `resolveStoryBody` (Story #4271).
  *
- * The decomposer emits `body` as the canonical serialized **string**, but
- * the conflict passes (`indexConsumers`, `computeMissingBddScaffoldFindings`,
- * and the producer path scan in `collectStoryProducerPaths`) historically
- * read `story.body` only when it was already an object — so on the
- * production string shape the `implicit-cross-story-dep` and
- * `missing-bdd-scaffold` findings emitted nothing. Parsing the body once at the entry point and
- * threading the normalized Story through every pass restores parity.
+ * The decomposer emits `body` as the canonical serialized **string**, but the
+ * conflict passes (the producer path scan in `collectStoryProducerPaths`, and
+ * the two substring-match advisories Story #5332 retired) historically read
+ * `story.body` only when it was already an object — so on the production
+ * string shape they emitted nothing. Parsing the body once at the entry point
+ * and threading the normalized Story through every pass restores parity.
  *
  * `collectStoryAssumptionEntries` already parses string bodies itself, so a
  * normalized object body round-trips through it unchanged. The returned Story
@@ -76,16 +75,20 @@ function normalizeStoryBody(story) {
  * @property {string}          path        Producer path written by ≥2 Stories.
  * @property {string[]}        storySlugs  Story slugs in the conflict cluster.
  *
- * @typedef {object} ImplicitCrossStoryDepFinding
- * @property {'implicit-cross-story-dep'} kind
- * @property {'hard'|'soft'}   severity
- * @property {string}          path        Path consumed without a depends_on link.
- * @property {{ storySlug: string, taskSlug: string }} producer
- * @property {{ storySlug: string, taskSlug: string, sourceField: 'acceptance'|'verify' }} consumer
- *
- * @typedef {SharedEditorFinding | ImplicitCrossStoryDepFinding} ConflictFinding
+ * @typedef {SharedEditorFinding} ConflictFinding
  */
 
+/**
+ * Story #5332 retired the `implicit-cross-story-dep` and
+ * `missing-bdd-scaffold` findings, leaving `shared-editor` as the one
+ * conflict kind. Both matched a producer path as a **substring** of a
+ * consumer's `acceptance[]` / `verify[]` text — the noise-prone shape the
+ * planning-diet ADR (`20260912-5312`) itself calls out — and both had been
+ * unreachable on the real payload for most of their life (see
+ * {@link computeAssembledConflictFindings}). What they nudged for, ordering a
+ * consumer after its producer, the same-wave collision refusal now enforces
+ * on declarations rather than guesses at from prose.
+
 /**
  * Every conflict class is advisory (`'soft'`) since Story #5312: the
  * `planning.failOnSharedEditors` / `requireExplicitCrossStoryDeps` /
@@ -160,46 +163,6 @@ function indexProducers(stories) {
   return producers;
 }
 
-/**
- * Build the consumers index — `Array<{path, storySlug, taskSlug, sourceField}>`.
- *
- * For each Task, scan `body.acceptance` and `body.verify` joined text for
- * literal substring occurrences of any known producer path. Only producer
- * paths are matched (intersect-then-test), so free-text path-like tokens
- * that no one writes never produce false positives.
- *
- * A Story is not its own consumer — entries whose producer is the same
- * Story are skipped to keep the surface focused on cross-Story signal.
- */
-function indexConsumers(stories, producers) {
-  const consumers = [];
-  if (producers.size === 0) return consumers;
-  const producerPaths = Array.from(producers.keys()).sort(
-    (a, b) => b.length - a.length,
-  );
-  for (const story of stories) {
-    const body = story.body;
-    if (!body || typeof body !== 'object') continue;
-    for (const sourceField of ['acceptance', 'verify']) {
-      const items = Array.isArray(body[sourceField]) ? body[sourceField] : [];
-      if (items.length === 0) continue;
-      const joined = items.map((it) => String(it ?? '')).join('\n');
-      for (const path of producerPaths) {
-        if (!joined.includes(path)) continue;
-        const producerEntries = producers.get(path) ?? [];
-        if (producerEntries.some((p) => p.taskSlug === story.slug)) continue;
-        consumers.push({
-          path,
-          storySlug: storySlugOf(story),
-          taskSlug: story.slug,
-          sourceField,
-        });
-      }
-    }
-  }
-  return consumers;
-}
-
 function inSameWave(reach, slugA, slugB) {
   if (slugA === slugB) return false;
   const a = reach.get(slugA);
@@ -240,133 +203,6 @@ function computeSharedEditorFindings(producers, reach, severity) {
   return findings;
 }
 
-/**
- * Emit one `implicit-cross-story-dep` finding per consumer entry whose
- * producer Story is not transitively reachable from the consumer Story.
- *
- * Multiple producers per path are possible — the finding pins the *first*
- * producer in declaration order (sufficient signal; the operator typically
- * fixes the missing `depends_on` by linking to whichever Story they
- * recognize). Consumers already covered by a transitive dependency to
- * *some* producer are silently allowed even if other producers exist.
- */
-function computeImplicitDepFindings(consumers, producers, reach, severity) {
-  const findings = [];
-  for (const consumer of consumers) {
-    const producerEntries = producers.get(consumer.path) ?? [];
-    if (producerEntries.length === 0) continue;
-    const reachable = reach.get(consumer.storySlug) ?? new Set();
-    const alreadyDependsOnSome = producerEntries.some(
-      (p) => p.storySlug === consumer.storySlug || reachable.has(p.storySlug),
-    );
-    if (alreadyDependsOnSome) continue;
-    const producer = producerEntries[0];
-    findings.push({
-      kind: 'implicit-cross-story-dep',
-      severity,
-      path: consumer.path,
-      producer: {
-        storySlug: producer.storySlug,
-        taskSlug: producer.taskSlug,
-      },
-      consumer: {
-        storySlug: consumer.storySlug,
-        taskSlug: consumer.taskSlug,
-        sourceField: consumer.sourceField,
-      },
-    });
-  }
-  return findings;
-}
-
-/**
- * Compute `missing-bdd-scaffold` findings (Story #3857).
- *
- * The features-first delivery model requires every `.feature` file a Story
- * verifies against to already exist when that Story runs. When a Story's
- * `verify[]` references a `.feature` path that another Story declares with
- * `assumption: "creates"`, the consumer is correct only if the producer
- * lands in an *earlier* wave — otherwise the consumer's `verify[]` runs
- * against a file that does not yet exist and verification fails mid-delivery.
- *
- * A finding fires for each consumer/producer pair where:
- *   - the path ends in `.feature`,
- *   - a *different* Story declares that path as `assumption: "creates"`, and
- *   - the consumer Story does not transitively `depends_on` the producer
- *     (i.e. they share a wave, or the producer runs later).
- *
- * The finding is advisory (`'soft'`) — it is a nudge to add a `depends_on`
- * link to the wave-0 scaffold Story (or to the producing Story), not a hard
- * block. The remediation is the same shape as `implicit-cross-story-dep`:
- * order the consumer after the producer so the scaffold lands first.
- *
- * @param {object[]} stories
- * @param {Map<string, Set<string>>} reach  Transitive predecessor sets.
- * @param {'soft'|'hard'} severity
- * @returns {object[]} `missing-bdd-scaffold` findings.
- */
-function computeMissingBddScaffoldFindings(stories, reach, severity) {
-  // Index every `.feature` path declared `creates` to its producing Story.
-  // A path may be created by more than one Story (unusual); pin the first in
-  // declaration order, mirroring the implicit-dep finding's single-producer
-  // shape.
-  const featureCreators = new Map(); // path -> storySlug (first creator)
-  for (const story of stories) {
-    const body = story?.body;
-    if (!body || typeof body !== 'object') continue;
-    const changes = Array.isArray(body.changes) ? body.changes : [];
-    for (const change of changes) {
-      if (
-        change === null ||
-        typeof change !== 'object' ||
-        change.assumption !== 'creates' ||
-        typeof change.path !== 'string' ||
-        !change.path.endsWith('.feature')
-      )
-        continue;
-      if (!featureCreators.has(change.path)) {
-        featureCreators.set(change.path, storySlugOf(story));
-      }
-    }
-  }
-  if (featureCreators.size === 0) return [];
-
-  const creatorPaths = Array.from(featureCreators.keys()).sort(
-    (a, b) => b.length - a.length,
-  );
-  const findings = [];
-  const seen = new Set(); // dedupe `${consumerSlug}::${path}` pairs
-  for (const story of stories) {
-    const body = story?.body;
-    if (!body || typeof body !== 'object') continue;
-    const verifyItems = Array.isArray(body.verify) ? body.verify : [];
-    if (verifyItems.length === 0) continue;
-    const joined = verifyItems.map((it) => String(it ?? '')).join('\n');
-    const consumerSlug = storySlugOf(story);
-    for (const path of creatorPaths) {
-      if (!joined.includes(path)) continue;
-      const producerSlug = featureCreators.get(path);
-      // A Story that creates the file it verifies is fine — no cross-Story gap.
-      if (producerSlug === consumerSlug) continue;
-      // Producer already runs in an earlier wave → consumer is correctly
-      // ordered, scaffold lands first, no finding.
-      const reachable = reach.get(consumerSlug) ?? new Set();
-      if (reachable.has(producerSlug)) continue;
-      const key = `${consumerSlug}::${path}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      findings.push({
-        kind: 'missing-bdd-scaffold',
-        severity,
-        path,
-        producer: { storySlug: producerSlug },
-        consumer: { storySlug: consumerSlug, sourceField: 'verify' },
-      });
-    }
-  }
-  return findings;
-}
-
 /**
  * Public entry point. Walks the normalized ticket spec once and returns
  * the structured cross-Story findings array. Every finding is `'soft'`
@@ -384,13 +220,8 @@ export function computeConflictFindings({ stories } = {}) {
   // shape across every conflict pass.
   const storyList = (stories ?? []).map(normalizeStoryBody);
   const producers = indexProducers(storyList);
-  const consumers = indexConsumers(storyList, producers);
   const reach = computeStoryReachability(storyList);
-  return [
-    ...computeSharedEditorFindings(producers, reach, SOFT),
-    ...computeImplicitDepFindings(consumers, producers, reach, SOFT),
-    ...computeMissingBddScaffoldFindings(storyList, reach, SOFT),
-  ];
+  return computeSharedEditorFindings(producers, reach, SOFT);
 }
 
 /**
@@ -402,11 +233,11 @@ export function computeConflictFindings({ stories } = {}) {
  * persisted. That is not a cosmetic ordering nit: the canonical authoring shape
  * carries `acceptance[]` / `verify[]` at the ticket's **top level**, and it is
  * assembly's `syncContractFieldFromTopLevel` that folds them into the body.
- * `indexConsumers` scans `body.acceptance` / `body.verify` for producer paths —
- * so on the real payload it scanned two empty arrays, and every
- * `implicit-cross-story-dep` and `missing-bdd-scaffold` finding was silently
- * unreachable. Running the passes again over the serialized bodies restores
- * them.
+ * The two retired advisories scanned `body.acceptance` / `body.verify` for
+ * producer paths, so on the real payload they scanned two empty arrays and
+ * were silently unreachable. Running the passes again over the serialized
+ * bodies is what keeps the surviving `shared-editor` pass honest about what
+ * persist actually writes.
  *
  * @param {{ stories: Array<{ slug: string, title: string, body: string, depends_on?: string[] }> }} args
  * @returns {ConflictFinding[]}
@@ -457,13 +288,7 @@ export function conflictFindingKey(finding) {
  * of this list is how readers drift apart, so it is defined exactly once and
  * imported.
  */
-export const CONFLICT_KINDS = Object.freeze(
-  new Set([
-    'shared-editor',
-    'implicit-cross-story-dep',
-    'missing-bdd-scaffold',
-  ]),
-);
+export const CONFLICT_KINDS = Object.freeze(new Set(['shared-editor']));
 
 /**
  * Render a conflict finding as a human-readable line. Every finding is soft
@@ -476,12 +301,6 @@ export function renderHardConflictError(finding) {
     const stories = finding.storySlugs.map((s) => `"${s}"`).join(', ');
     return `Shared-editor conflict: "${finding.path}" is written by ${finding.storySlugs.length} concurrent Stories (${stories}). Add depends_on chains between them or split the edits into a dedicated late-wave wiring Story.`;
   }
-  if (finding.kind === 'implicit-cross-story-dep') {
-    return `Implicit cross-Story dependency: Story "${finding.consumer.storySlug}" references "${finding.path}" (produced by Story "${finding.producer.storySlug}") via body.${finding.consumer.sourceField}, but Story "${finding.consumer.storySlug}" has no depends_on link to Story "${finding.producer.storySlug}". Add depends_on: ["${finding.producer.storySlug}"] to the consumer Story or remove the reference.`;
-  }
-  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 carry their own message — render it rather
   // than a shape-blind generic line, so the soft surface
   // (`surfaceSoftConflictFindings`) stays legible for every kind.
@@ -496,10 +315,7 @@ export const _internal = {
   collectStoryProducerPaths,
   WRITE_IMPLYING_ASSUMPTIONS,
   indexProducers,
-  indexConsumers,
   computeStoryReachability,
   inSameWave,
   computeSharedEditorFindings,
-  computeImplicitDepFindings,
-  computeMissingBddScaffoldFindings,
 };