mandrel 1.68.0 → 1.69.0

package/.agents/scripts/lib/orchestration/epic-runner/progress-reporter/transport.js

@@ -38,10 +38,10 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
 
 /**
  * Fire a curated `epic-progress` webhook event. Event-driven only — called
- * at wave boundaries and after blocker raise/clear transitions. Carries
- * the rollup payload `{ pct, done, total, currentWave, totalWaves, phase,
- * openBlockers }`, which Slack consumers and downstream subscribers use to
- * track epic progress without subscribing to per-story chatter.
+ * per recorder beat and after blocker raise/clear transitions. Carries the
+ * rollup payload `{ pct, done, total, phase, openBlockers }`, which Slack
+ * consumers and downstream subscribers use to track epic progress without
+ * subscribing to per-story chatter.
  *
  * The dispatch passes `skipComment: true` — the operator-facing GitHub
  * comment is owned by `ProgressReporter.fire()` and `upsertEpicRunProgress`,
@@ -50,13 +50,17 @@ export const EPIC_PROGRESS_EVENT = 'epic-progress';
  * Failures are swallowed by design: the runner must keep moving even if
  * the webhook URL is misconfigured or the network is flaky.
  *
+ * Story #4155 — the Epic `/deliver` runtime cut over to the continuous
+ * ready-set scheduler, which has **no wave index**. The wave segment was
+ * dropped from the message and the rollup payload entirely (rather than
+ * rendered as `Wave undefined/undefined`); the sole live caller
+ * (`wave-record-notifications.js`) never supplied wave coordinates.
+ *
  * @param {{
  *   notify: Function|null,
  *   epicId: number,
  *   done: number,
  *   total: number,
- *   currentWave: number,
- *   totalWaves: number,
  *   phase?: string,
  *   openBlockers?: Array<{ reason: string, storyId?: number }>,
  *   logger?: { warn?: Function },
@@ -68,8 +72,6 @@ export async function emitEpicProgress({
   epicId,
   done,
   total,
-  currentWave,
-  totalWaves,
   phase,
   openBlockers = [],
   logger,
@@ -85,7 +87,7 @@ export async function emitEpicProgress({
     blockerCount > 0
       ? ` · 🚧 ${blockerCount} blocker${blockerCount === 1 ? '' : 's'}`
       : '';
-  const message = `Epic #${epicIdNum} progress · Wave ${currentWave}/${totalWaves} · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
+  const message = `Epic #${epicIdNum} progress · ${doneN}/${totalN} stories done (${pct}%)${blockerSuffix}`;
 
   const payload = {
     severity: blockerCount > 0 ? 'high' : 'medium',
@@ -109,8 +111,6 @@ export async function emitEpicProgress({
       pct,
       done: doneN,
       total: totalN,
-      currentWave,
-      totalWaves,
       phase,
       openBlockers: openBlockers ?? [],
     },
@@ -121,11 +121,14 @@ export async function emitEpicProgress({
  * Fire a curated `epic-started` webhook event at /deliver kickoff.
  * The Slack consumer anchors the rest of the epic narrative to this fire.
  * Failures are swallowed.
+ *
+ * Story #4155 — the ready-set runtime has no wave count, so the wave
+ * segment was dropped from the message (rather than rendered as
+ * `undefined wave(s)`); the sole live caller never supplied one.
  */
 export async function emitEpicStarted({
   notify,
   epicId,
-  totalWaves,
   totalStories,
   title,
   logger,
@@ -133,7 +136,7 @@ export async function emitEpicStarted({
   if (typeof notify !== 'function') return null;
   const epicIdNum = Number(epicId);
   if (!Number.isInteger(epicIdNum) || epicIdNum <= 0) return null;
-  const message = `Epic #${epicIdNum} started · ${totalWaves} wave${totalWaves === 1 ? '' : 's'} · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
+  const message = `Epic #${epicIdNum} started · ${totalStories} stor${totalStories === 1 ? 'y' : 'ies'}${title ? ` — ${title}` : ''}`;
   try {
     await notify(
       epicIdNum,

package/.agents/scripts/lib/orchestration/epic-runner/sub-agent-return.js

@@ -241,26 +241,29 @@ export async function reconcileStoryFromGitHub({ provider, storyId } = {}) {
 
 /**
  * Render a single friction-comment body listing every malformed sub-agent
- * return for a given wave. Pure helper — no provider call. Exposed so tests
- * can pin the body shape.
+ * return for a recorder beat. Pure helper — no provider call. Exposed so
+ * tests can pin the body shape.
+ *
+ * Story #4155 — under the ready-set runtime there is no wave index; the
+ * recorder records the Stories it was handed, so the body is keyed by Epic
+ * only.
  *
  * @param {{
  *   epicId: number,
- *   wave: number,
  *   failures: Array<{ storyId: number, error: string, returnText: string }>,
  * }} args
  * @returns {string}
  */
-export function renderMalformedReturnsFriction({ epicId, wave, failures }) {
+export function renderMalformedReturnsFriction({ epicId, failures }) {
   const lines = [
-    `### 🚧 epic-execute friction — Epic #${epicId}, wave ${wave}`,
+    `### 🚧 epic-execute friction — Epic #${epicId}`,
     '',
     `**Reason:** \`malformed-subagent-return\``,
     '',
     `${failures.length} sub-agent return(s) did not match the /deliver return contract.`,
     'Each Story below was reconciled from GitHub (labels + `story-run-progress`)',
-    'and its wave-row downgraded to `failed` unless the live ticket already carried',
-    '`agent::done`.',
+    'and its recorded status downgraded to `failed` unless the live ticket',
+    'already carried `agent::done`.',
     '',
   ];
   for (const f of failures) {

package/.agents/scripts/lib/orchestration/lifecycle/listeners/automerge-predicate.js

@@ -21,7 +21,7 @@
  *     is a hard block evaluated BEFORE the structured-signal evaluator.
  *
  * Either trigger evaluates the same verdict: if `evaluateAutoMergePredicate`
- * reports `clean: true` (no manual interventions, no incomplete waves,
+ * reports `clean: true` (no manual interventions, every Story done,
  * no story blockers, no critical/high review findings, machine-readable
  * "clean sprint" retro trailer), emit `epic.merge.ready`. Otherwise emit
  * `epic.merge.blocked` with a non-empty reason.
@@ -172,38 +172,51 @@ function evaluateStateSignals(state, reasons) {
         .join('; ')}${interventionCount > 3 ? '; …' : ''}`,
     );
   }
-  const waves = Array.isArray(state?.waves) ? state.waves : [];
-  const waveStatuses = waves.map((w) => w.status ?? 'unknown');
-  const nonCompleteWaves = waveStatuses.filter((s) => s !== 'complete');
-  if (nonCompleteWaves.length > 0) {
+  // Story #4155 — the ready-set runtime records a flat per-Story status map
+  // on the checkpoint (`stories: { [id]: { status, blockerCommentId? } }`)
+  // instead of a per-wave `waves[]` history. The clean-run certification
+  // reads it directly: a run is clean only when every Story reached `done`
+  // and none carries a recorded blocker comment.
+  const stories =
+    state?.stories && typeof state.stories === 'object' ? state.stories : {};
+  const storyStatuses = Object.values(stories).map(
+    (s) => s?.status ?? 'pending',
+  );
+  const nonDoneStatuses = storyStatuses.filter((s) => s !== 'done');
+  if (nonDoneStatuses.length > 0) {
     reasons.push(
-      `${nonCompleteWaves.length} wave(s) not complete (statuses: ${nonCompleteWaves.join(', ')})`,
+      `${nonDoneStatuses.length} story(ies) not done (statuses: ${nonDoneStatuses.join(', ')})`,
     );
   }
-  const storyBlockers = countStoryBlockers(waves);
+  const storyBlockers = countStoryBlockers(stories);
   if (storyBlockers > 0) {
     reasons.push(
       `${storyBlockers} story-level blocker(s) recorded in run-state`,
     );
   }
-  return { interventionCount, waveStatuses, storyBlockers };
+  return { interventionCount, storyStatuses, storyBlockers };
 }
 
-function countStoryBlockers(waves) {
+/**
+ * Count blockers in the flat per-Story `stories` status map: each Story with
+ * a recorded `blockerCommentId` and each Story whose status is not `done`
+ * contributes one blocker (matching the prior per-wave count semantics).
+ *
+ * @param {Record<string, { status?: string, blockerCommentId?: string }>} stories
+ * @returns {number}
+ */
+function countStoryBlockers(stories) {
   let blockers = 0;
-  for (const w of waves) {
-    if (!Array.isArray(w.stories)) continue;
-    for (const s of w.stories) {
-      if (
-        s &&
-        typeof s.blockerCommentId === 'string' &&
-        s.blockerCommentId.length > 0
-      ) {
-        blockers += 1;
-      }
-      if (s?.status && s.status !== 'done') {
-        blockers += 1;
-      }
+  for (const s of Object.values(stories ?? {})) {
+    if (
+      s &&
+      typeof s.blockerCommentId === 'string' &&
+      s.blockerCommentId.length > 0
+    ) {
+      blockers += 1;
+    }
+    if (s?.status && s.status !== 'done') {
+      blockers += 1;
     }
   }
   return blockers;
@@ -271,7 +284,7 @@ function evaluateRetroSignals(retro, reasons) {
  *   reasons: string[],
  *   signals: {
  *     manualInterventions: number,
- *     waveStatuses: string[],
+ *     storyStatuses: string[],
  *     storyBlockers: number,
  *     severity: { critical: number|null, high: number|null, medium: number|null, suggestion: number|null },
  *     retroCompact: boolean,
@@ -292,7 +305,7 @@ export function deriveAutoMergeVerdict({ state, codeReview, retro }) {
     reasons,
     signals: {
       manualInterventions: stateSig.interventionCount,
-      waveStatuses: stateSig.waveStatuses,
+      storyStatuses: stateSig.storyStatuses,
       storyBlockers: stateSig.storyBlockers,
       severity: reviewSig.severity,
       retroCompact: retroSig.retroCompact,

package/.agents/scripts/lib/orchestration/manifest-builder.js

@@ -139,6 +139,12 @@ function buildStoryOnlyManifest(stories, epicId) {
       type: 'story',
       branchName: getStoryBranch(epicId, story.id),
       earliestWave,
+      // Carry the resolved cross-Story dependency edges on the entry so the
+      // presentation layer can derive grouping depth at render time via
+      // `assignLayers` (Story #4157) instead of trusting the persisted
+      // `earliestWave`. This is the same `explicitStoryDeps` set the wave
+      // computation consumed, already closed over the scheduled Story set.
+      dependsOn: explicitStoryDeps.get(story.id) ?? [],
       tasks: [],
     };
   });

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

@@ -18,7 +18,7 @@
  *
  * Sizing model (Story #3760 — profile-matrix collapse; Story #3874 — one
  * uniform relaxed profile):
- *   - Flat knobs: `softFiles` (~8), `hardFiles` (~30), `maxAcceptance` (~14),
+ *   - Flat knobs: `softFiles` (~15), `hardFiles` (~30), `maxAcceptance` (~14),
  *     `softAcceptanceCount` (~10). No per-profile ceiling map, no parallel
  *     `testSurface` axis, no selector and no second profile.
  *   - The four-profile `sizingProfile` enum is replaced by a single optional
@@ -32,7 +32,11 @@
 
 export const DEFAULT_TASK_SIZING = Object.freeze({
   // Typical-Story warning thresholds (soft — emit advisory findings).
-  softFiles: 8,
+  // Story #4162 raised `softFiles` 8 → 15: a capability-sized Story routinely
+  // touches a dozen-plus files for one cohesive reason, so the advisory width
+  // nudge fired far too eagerly and biased the decomposer toward over-slicing.
+  // The hard `hardFiles` rejection (30) is unchanged.
+  softFiles: 15,
   softAcceptanceCount: 10,
   // Hard ceilings (rejection unless lifted).
   hardFiles: 30,

package/.agents/scripts/lib/orchestration/wave-record-io.js

@@ -1,25 +1,23 @@
 /**
- * wave-record-io.js — impure helpers for the record-wave CLI: ticket
- * verification, manifest title lookup, and returns reconciliation.
+ * wave-record-io.js — impure helpers for the per-Story status recorder CLI
+ * (`epic-execute-record-wave.js`): ticket verification, manifest title
+ * lookup, and returns reconciliation.
  *
  * These functions all hit the provider and are intentionally kept out of
- * `wave-record-projection.js`, which is the pure projection layer. The
- * parent CLI imports both modules and threads the I/O results through
- * the projection.
+ * `wave-record-projection.js`, which is the pure helper layer. The parent
+ * CLI imports both modules and threads the I/O results through the
+ * projection.
  *
- * Every entry point here is fire-and-forget on the "best-effort" surfaces
- * (manifest title lookup) and explicit-throw on the authoritative ones
- * (`verifyWaveResults` and `resolveResolvedResults` decide what `complete`
- * actually means after the network call lands).
+ * Story #4155 (Epic #4151) — the wave-batch livelock-recovery path
+ * (`planStoryIdsForWave` + the empty-mode-B reconcile) was deleted along
+ * with the wave checkpoint it keyed off. Under the ready-set runtime a
+ * Story's terminal state is always re-derivable from its live label on the
+ * next `tick`, so there is no falsely-`complete` empty wave to recover from
+ * — the recorder records exactly the Stories it was handed.
  *
- * Story #3909 — the per-wave dispatch-manifest refresh hop
- * (`refreshDispatchManifest`) was deleted. It re-ran the full dispatch
- * pipeline (re-fetch every ticket, recompute waves) on every wave tick
- * only to re-render the `dispatch-manifest` comment, which nothing reads
- * for control flow — `loadManifestTitleMap` reads it for rollup-row titles,
- * and those are fixed at plan time. The manifest is now written once at
- * `epic-deliver-prepare` time and left frozen; the surviving operator-facing
- * surface is the `epic-run-progress` rollup the record-wave CLI re-renders.
+ * Story #3909 — the per-wave dispatch-manifest refresh hop was deleted; the
+ * manifest is written once at `epic-deliver-prepare` time and left frozen.
+ * `loadManifestTitleMap` reads it for rollup-row titles.
  */
 
 import { Logger } from '../Logger.js';
@@ -112,14 +110,14 @@ async function verifySingleResult(r, provider) {
  * stale cache cannot mask the discrepancy. A network failure during
  * verification cannot prove the claim either way, so the row is
  * downgraded to `failed` and a `verify-error` discrepancy is recorded —
- * an unverifiable `done` must not let the wave aggregate to `complete`,
- * which is what callers read as "GitHub agrees everything is done."
+ * an unverifiable `done` must not be recorded as `done`, which is what the
+ * auto-merge predicate reads as "GitHub agrees everything is done."
  *
  * Story #3024 — verification runs through {@link concurrentMap} under a
  * bounded cap (default 4, override via
  * `delivery.deliverRunner.verifyConcurrencyCap`). Per-row failures are
  * captured inside the mapper so one Story's `getTicket` throw cannot
- * abort the whole wave — the per-row try/catch lives in
+ * abort the whole batch — the per-row try/catch lives in
  * {@link verifySingleResult} and turns into a `verify-error`
  * discrepancy rather than a rejected mapper. Input order is preserved
  * (mapper-index → output-index), matching the previous serial behaviour.
@@ -183,84 +181,27 @@ export async function loadManifestTitleMap({ provider, epicId }) {
   }
 }
 
-/**
- * Extract the Story IDs planned for `wave` from the checkpoint `plan`
- * (`Story[][]` indexed by wave). Returns `[]` when the plan is missing or
- * the wave index is out of range. Pure helper — exported for unit tests.
- *
- * Story #3907 — the wave-complete livelock recovery (below) keys off this:
- * when mode B records a wave with **no** child returns (the host crashed
- * after the children finished but before `record-wave` ran), every Story in
- * `plan[wave]` is reconciled from GitHub so the wave can record and
- * `currentWave` can advance instead of returning `wave-complete` for the same
- * index forever.
- *
- * @param {object} existing Checkpoint state.
- * @param {number} wave
- * @returns {number[]}
- */
-export function planStoryIdsForWave(existing, wave) {
-  const plan = Array.isArray(existing?.plan) ? existing.plan : [];
-  const entries = Array.isArray(plan[wave]) ? plan[wave] : [];
-  const ids = [];
-  for (const entry of entries) {
-    const id =
-      typeof entry === 'number'
-        ? entry
-        : Number(entry?.id ?? entry?.storyId ?? entry?.number);
-    if (Number.isInteger(id) && id > 0) ids.push(id);
-  }
-  return ids;
-}
-
 /**
  * Parse / reconcile the per-Story returns (or pass `results` through). Posts
  * a single rolled-up friction comment listing every malformed return on
  * failure — non-fatal if the post itself fails.
  *
- * Story #3907 — mode B with an **empty** `returns` array is the
- * wave-complete-livelock recovery path: the host crashed after the wave's
- * children finished but before `record-wave` ran, so no return text survives.
- * Rather than recording an empty (falsely-`complete`) wave, every Story in
- * `plan[wave]` is reconciled from GitHub via {@link reconcileStoryFromGitHub}
- * so the recorded wave reflects the live ticket state. This requires the
- * caller to thread the checkpoint `existing` so the wave's planned Story set
- * is known; without it the empty array degrades to the previous behaviour.
- *
  * @returns {Promise<{ resolvedResults: Array, parseFailures: Array }>}
  */
 export async function resolveResolvedResults({
   provider,
   epicId,
-  wave,
   results,
   returns,
-  existing,
 }) {
   if (returns == null) {
     return { resolvedResults: results, parseFailures: [] };
   }
-  if (Array.isArray(returns) && returns.length === 0 && existing) {
-    const ids = planStoryIdsForWave(existing, wave);
-    if (ids.length > 0) {
-      const resolvedResults = await concurrentMap(
-        ids,
-        (storyId) => reconcileStoryFromGitHub({ provider, storyId }),
-        { concurrency: DEFAULT_VERIFY_CONCURRENCY_CAP },
-      );
-      Logger.warn(
-        `[wave-record-io] Wave ${wave} recorded with no child returns; ` +
-          `reconciled ${ids.length} Story(ies) from GitHub (livelock recovery).`,
-      );
-      return { resolvedResults, parseFailures: [] };
-    }
-  }
   const normalized = await normalizeReturns({ provider, returns });
   if (normalized.parseFailures.length > 0) {
     try {
       const body = renderMalformedReturnsFriction({
         epicId,
-        wave,
         failures: normalized.parseFailures,
       });
       await postStructuredComment(provider, epicId, 'friction', body);

package/.agents/scripts/lib/orchestration/wave-record-notifications.js

@@ -1,14 +1,15 @@
 /**
- * wave-record-notifications.js — webhook-emit helpers extracted from
- * `epic-execute-record-wave.js`.
+ * wave-record-notifications.js — webhook-emit helpers for the per-Story
+ * status recorder CLI (`epic-execute-record-wave.js`).
  *
- * The CLI fires curated webhook events at every wave boundary (started,
- * progress, blocked, unblocked) so the host-LLM-driven `/deliver` path
- * mirrors the wave-loop emits in
- * `lib/orchestration/epic-runner/phases/iterate-waves.js`. Each helper here
- * is fire-and-forget — webhook misconfig or a transient Slack outage must
- * not block the wave loop — so the impure surface is small (the inbound
- * `notifyFn` closure) and the rest is plain control flow.
+ * Story #4155 (Epic #4151) — the Epic `/deliver` runtime cut over from the
+ * wave-batch scheduler to the continuous ready-set core, so these emits are
+ * no longer keyed to a wave boundary. The recorder fires curated webhook
+ * events per recorder beat: `epic-started` once (on the first recorded
+ * Story), `epic-progress` with the run's done/total counts (re-derived from
+ * the checkpoint's flat per-Story `stories` map), and `epic-blocked` when a
+ * Story in this beat blocked or failed. Each helper is fire-and-forget —
+ * webhook misconfig or a transient Slack outage must not block the loop.
  *
  * These helpers stay in their own module to keep the parent CLI a thin
  * runner shell. They are not part of the pure projection layer; they
@@ -20,9 +21,7 @@ import {
   emitEpicBlocked,
   emitEpicProgress,
   emitEpicStarted,
-  emitEpicUnblocked,
 } from './epic-runner/progress-reporter/transport.js';
-import { countDoneStories } from './wave-record-projection.js';
 
 /**
  * Build the notify-bound closure used by the curated webhook emitters. When
@@ -41,25 +40,53 @@ export function buildNotifyFn(injectedNotify, config, provider, defaultNotify) {
 }
 
 /**
- * Fire the curated webhook events for a wave boundary. Each emit is
+ * Count Stories in a terminal `done` state across the checkpoint's flat
+ * per-Story `stories` status map. Pure helper.
+ *
+ * @param {Record<string, { status?: string }>|undefined} stories
+ * @returns {number}
+ */
+export function countDoneStories(stories) {
+  const map = stories && typeof stories === 'object' ? stories : {};
+  let done = 0;
+  for (const rec of Object.values(map)) {
+    if (rec?.status === 'done') done += 1;
+  }
+  return done;
+}
+
+/**
+ * Fire the curated webhook events for a recorder beat. Each emit is
  * fire-and-forget (the emit helpers swallow webhook misconfiguration), but
- * we still serialise them so the order matches the wave-loop emits in
- * `lib/orchestration/epic-runner/phases/iterate-waves.js` for the host-LLM
- * driven /deliver path.
+ * we still serialise them so the order is deterministic.
+ *
+ * - `epic-started` fires exactly once: on the very first recorded Story
+ *   (signalled by `firstRecord === true`), before any Story has been
+ *   recorded on a prior beat.
+ * - `epic-progress` always fires with the run's done/total counts.
+ * - `epic-blocked` fires when this beat recorded at least one blocked or
+ *   failed Story.
+ *
+ * @param {{
+ *   injectedNotify?: Function,
+ *   defaultNotify: Function,
+ *   config: object,
+ *   provider: object,
+ *   epicId: number,
+ *   firstRecord: boolean,
+ *   stories: Record<string, { status?: string }>,
+ *   verified: Array<{ storyId: number, status: string }>,
+ *   blockedStoryIds: number[],
+ * }} args
  */
-export async function emitWaveBoundaryNotifications({
+export async function emitRecordNotifications({
   injectedNotify,
   defaultNotify,
   config,
   provider,
   epicId,
-  wave,
-  status,
-  priorWaves,
-  nextWaves,
-  titleById,
-  totalWaves,
-  nextCurrentWave,
+  firstRecord,
+  stories,
   verified,
   blockedStoryIds,
 }) {
@@ -69,121 +96,50 @@ export async function emitWaveBoundaryNotifications({
     provider,
     defaultNotify,
   );
-  const totalStoriesEstimate = titleById.size;
-  const doneStoriesSoFar = countDoneStories(nextWaves);
-  const priorWaveRecord = priorWaves.find(
-    (w) => Number(w?.index) === Number(wave),
-  );
-  if (priorWaves.length === 0 && wave === 0) {
+  const map = stories && typeof stories === 'object' ? stories : {};
+  const totalStories = Object.keys(map).length;
+  const doneStories = countDoneStories(map);
+
+  if (firstRecord) {
     await emitEpicStarted({
       notify: notifyFn,
       epicId,
-      totalWaves,
-      totalStories: totalStoriesEstimate,
+      totalStories,
       logger: Logger,
     });
   }
-  if (status === 'complete') {
-    await emitCompleteWaveNotifications({
-      notifyFn,
-      epicId,
-      priorWaveRecord,
-      doneStoriesSoFar,
-      totalStoriesEstimate,
-      nextCurrentWave,
-      totalWaves,
-    });
-    return;
-  }
-  await emitFailingWaveNotifications({
-    notifyFn,
-    epicId,
-    status,
-    blockedStoryIds,
-    verified,
-    doneStoriesSoFar,
-    totalStoriesEstimate,
-    nextCurrentWave,
-    totalWaves,
-  });
-}
 
-/** Emit the unblocked-then-progress pair for a `complete` wave. */
-async function emitCompleteWaveNotifications({
-  notifyFn,
-  epicId,
-  priorWaveRecord,
-  doneStoriesSoFar,
-  totalStoriesEstimate,
-  nextCurrentWave,
-  totalWaves,
-}) {
-  const resumedFromHalt =
-    priorWaveRecord &&
-    (priorWaveRecord.status === 'blocked' ||
-      priorWaveRecord.status === 'failed');
-  if (resumedFromHalt) {
-    await emitEpicUnblocked({
+  const blockedIds = Array.isArray(blockedStoryIds) ? blockedStoryIds : [];
+  const failedStoryId = (verified ?? []).find(
+    (r) => r.status === 'failed',
+  )?.storyId;
+  const failingStoryId = blockedIds[0] ?? failedStoryId;
+  const hasFailure = blockedIds.length > 0 || failedStoryId != null;
+
+  if (hasFailure) {
+    await emitEpicBlocked({
       notify: notifyFn,
       epicId,
-      resolvedBlocker: {
-        reason:
-          priorWaveRecord.status === 'blocked'
-            ? 'story_blocked'
-            : 'story_failed',
-      },
+      reason: blockedIds.length > 0 ? 'story_blocked' : 'story_failed',
+      storyId: failingStoryId,
       logger: Logger,
     });
   }
-  await emitEpicProgress({
-    notify: notifyFn,
-    epicId,
-    done: doneStoriesSoFar,
-    total: totalStoriesEstimate,
-    currentWave: nextCurrentWave,
-    totalWaves,
-    phase: 'iterate-waves',
-    openBlockers: [],
-    logger: Logger,
-  });
-  // The `epic-complete` webhook used to fire here, at the post-final-wave
-  // / pre-finalize boundary. That preceded `gh pr create` by minutes — the
-  // operator got an "Epic complete" ping with no PR to click. The fire
-  // moved to `epic-deliver-finalize.js`, which emits it after the PR URL
-  // is captured. See that script for the new emit point.
-}
 
-/** Emit blocked + progress (with open-blocker context) for a non-complete wave. */
-async function emitFailingWaveNotifications({
-  notifyFn,
-  epicId,
-  status,
-  blockedStoryIds,
-  verified,
-  doneStoriesSoFar,
-  totalStoriesEstimate,
-  nextCurrentWave,
-  totalWaves,
-}) {
-  const reason = status === 'blocked' ? 'story_blocked' : 'story_failed';
-  const failingStoryId =
-    blockedStoryIds[0] ?? verified.find((r) => r.status === 'failed')?.storyId;
-  await emitEpicBlocked({
-    notify: notifyFn,
-    epicId,
-    reason,
-    storyId: failingStoryId,
-    logger: Logger,
-  });
   await emitEpicProgress({
     notify: notifyFn,
     epicId,
-    done: doneStoriesSoFar,
-    total: totalStoriesEstimate,
-    currentWave: nextCurrentWave,
-    totalWaves,
-    phase: 'iterate-waves',
-    openBlockers: [{ reason, storyId: failingStoryId }],
+    done: doneStories,
+    total: totalStories,
+    phase: 'wave-loop',
+    openBlockers: hasFailure
+      ? [
+          {
+            reason: blockedIds.length > 0 ? 'story_blocked' : 'story_failed',
+            storyId: failingStoryId,
+          },
+        ]
+      : [],
     logger: Logger,
   });
 }