@telora/daemon 0.20.2 → 0.20.9

package/dist/completion/event.js

@@ -5,18 +5,15 @@
  * team lead completes a work cycle: terminate if done, send more work, or
  * (for planning teams) refresh from MCP-written deliveries / escalate.
  */
-import { sendMessage, DELIVERY_STATUS, loadEnvConfig } from '@telora/daemon-core';
-import { isStatusCascadable, isStatusAgentActionable } from '../stage-classifier.js';
+import { loadEnvConfig } from '@telora/daemon-core';
+import { isStatusCascadable } from '../stage-classifier.js';
 import { getFocusDeliveries, getFocusIssues } from '../queries/focuses.js';
 import { getActiveFocuses } from '../supabase.js';
-import { buildWakeMessage, buildReEngagementMessage } from '../focus-prompt-builder.js';
-import { OPEN_ISSUE_STATUSES } from '../constants.js';
-import { isAuditPhaseFocus } from '../audit-shape.js';
 import { terminateTeam as defaultTerminateTeam } from './team-lifecycle.js';
 import { createEscalation as defaultCreateEscalation, hasOpenTeamFailureEscalation as defaultHasOpenTeamFailureEscalation, } from '../queries/issues.js';
 import { advanceDeliveryStatuses as defaultAdvanceDeliveryStatuses, runReviewExitHandler as defaultRunReviewExitHandler, } from './team-completion.js';
 import { fetchEffectiveWorkflowWithTransitions as defaultFetchEffectiveWorkflowWithTransitions } from '../queries/workflows.js';
-import { decideCompletionAction, shouldCheckNonAdvanceable } from './completion-decision.js';
+import { decideCompletionAction } from './completion-decision.js';
 import { takeProgressSnapshot, snapshotsEqual } from './progress-snapshot.js';
 // Review-window + non-advanceability predicates extracted to ./advanceability.ts
 // (keeps this file under the structural size lint). Imported for use below and
@@ -27,29 +24,21 @@ export { isInReviewWindow, isDeliveryNonAdvanceable, findNonAdvanceableDelivery
 import { getFocusWorktree as defaultGetFocusWorktree } from '../focus-worktree-state.js';
 import { worktreeHasUncommittedChanges as defaultWorktreeHasUncommittedChanges } from '../worktree/index.js';
 import { readWorktreeHeadSha as defaultReadWorktreeHeadSha } from '../git/index.js';
-import { resolveAutoRemediationBudget } from '../delivery-advance-block.js';
 // Escalation builders + their reason-string constants live in
 // event-escalations.ts; re-exported here so existing importers are unaffected.
-import { escalatePlanningFailure, escalateNoProgress, escalateNonAdvanceable, escalateDeliveryAdvancementStalled, } from './event-escalations.js';
 export { PLANNING_NO_DELIVERIES_REASON, NO_PROGRESS_ESCALATION_REASON, NON_ADVANCEABLE_ESCALATION_REASON, NON_ADVANCEABLE_CAUSE, DELIVERY_ADVANCEMENT_STALLED_REASON, DELIVERY_ADVANCEMENT_STALLED_CAUSE, escalatePlanningFailure, escalateNoProgress, escalateNonAdvanceable, escalateDeliveryAdvancementStalled, } from './event-escalations.js';
-import { recordDeliveryAdvancementCycle } from './delivery-advancement-guard.js';
 import { reconcileTerminatedTeamWork as defaultReconcileTerminatedTeamWork, } from './terminated-work-reconcile.js';
+import { applyPlanningRefresh, routeReviewWindowCompletion, runWakeCycleSelfHeal, computeCompletionFacts, checkDeliveryAdvancementStall, executeCompletionAction, } from './event-phases.js';
+import { createLogger } from '../log.js';
+const log = createLogger({ module: 'focus-executor' });
 /**
  * Maximum consecutive re-engagement cycles with no measurable progress before
  * the scope-coverage guard escalates. Configurable via env so operators can
  * relax or tighten the bound without a code change.
  */
 export const SCOPE_COVERAGE_NO_PROGRESS_LIMIT = loadEnvConfig().TELORA_SCOPE_COVERAGE_NO_PROGRESS_LIMIT;
-export function resolveDeliveryAdvancementNoProgressLimit(envConfig = loadEnvConfig(), env = process.env) {
-    const typedConfig = envConfig;
-    if (typeof typedConfig.TELORA_DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT === 'number') {
-        return typedConfig.TELORA_DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT;
-    }
-    const raw = env.TELORA_DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT;
-    if (raw === undefined || raw === '')
-        return 3;
-    const parsed = Number(raw);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : 3;
+export function resolveDeliveryAdvancementNoProgressLimit(envConfig = loadEnvConfig()) {
+    return envConfig.TELORA_DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT;
 }
 export const DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT = resolveDeliveryAdvancementNoProgressLimit();
 async function defaultGetReviewRequestedAt(config, focusId) {
@@ -93,594 +82,49 @@ const defaultDeps = {
  * deep nesting inside an async Promise chain inside an event listener.
  */
 export async function handleCompletionEvent(ctx, deps = defaultDeps) {
-    const { focusId, focusName, teamState, completionDetector, proc } = ctx;
+    const { focusId, focusName, teamState } = ctx;
     const [currentDeliveries, currentIssues] = await Promise.all([
         deps.getFocusDeliveries(focusId),
         deps.getFocusIssues(focusId),
     ]);
-    // Wake-cycle refresh (Option A): planning teams spawn with knownDeliveryIds
-    // empty. The MCP-driven planning turn writes deliveries to the DB, so we
-    // re-snapshot them here before any downstream merge/completion logic looks
-    // at the set. WHY Option A: keeps the refresh on the existing wake path
-    // instead of polling, so it runs exactly when new deliveries become visible.
-    if (teamState.planningPhase) {
-        if (currentDeliveries.length === 0) {
-            console.warn(`[focus-executor] Planning team for "${focusName}" produced no deliveries ` +
-                `-- escalating and terminating`);
-            await escalatePlanningFailure({
-                organizationId: teamState.organizationId,
-                sessionId: teamState.leadSessionId ?? '',
-                focusId,
-                focusName,
-                agentRoleId: teamState.roleId,
-            }, deps);
-            teamState.shutdownReason = 'work_complete';
-            deps.terminateTeam(focusId);
-            return;
-        }
-        for (const d of currentDeliveries) {
-            teamState.knownDeliveryIds.add(d.id);
-            teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
-        }
-        teamState.planningPhase = false;
-        console.log(`[focus-executor] Planning refresh for "${focusName}": ` +
-            `${currentDeliveries.length} delivery(ies) discovered`);
-    }
-    // Review-window handling. Resolve review_requested_at FRESH because it can be
-    // set/cleared between spawn and this event.
-    let reviewRequestedAt = null;
-    if (deps.getReviewRequestedAt) {
-        try {
-            reviewRequestedAt = await deps.getReviewRequestedAt(ctx.config, focusId);
-        }
-        catch (err) {
-            console.warn(`[focus-executor] getReviewRequestedAt failed for "${focusName}": ${err.message}`);
-            // Fail open: a read failure must not block the existing teardown logic.
-        }
-    }
-    if (isInReviewWindow(reviewRequestedAt, currentDeliveries)) {
-        const verifyCount = currentDeliveries.filter(d => d.executionStatus === DELIVERY_STATUS.VERIFY).length;
-        if (teamState.sessionType === 'review') {
-            // A REVIEW pass just completed -- it emitted its result, which IS the
-            // "a review cycle ran" signal. Close the focus DETERMINISTICALLY now,
-            // keyed on THIS completion event rather than on process exit. A review
-            // resumes its prior session to preserve context (INJ-D) and runs as an
-            // interactive stream-json process that emits a result but never exits;
-            // the old exit-keyed close therefore waited forever (the review-resume
-            // deadlock). runReviewExitHandler routes verify deliveries by the
-            // deterministic signal -- a pass that filed zero new issues and has no
-            // open work closes verify->done; open work routes verify->verify_failed
-            // to re-iterate -- and clears review_requested_at. The review team is then
-            // torn down: closure has ALREADY happened, so it no longer matters whether
-            // the process exits cleanly or is SIGTERM'd, and the next review cycle
-            // resumes the same session id to review only the new delta.
-            //
-            // succeeded is the ACTUAL result of the review turn (!isError), NOT a
-            // hardcoded true. A review that erred (e.g. the CLI failed to start, or a
-            // model/engine mismatch) emits a result event with isError=true and files
-            // no defects -- the old `succeeded: true` made that indistinguishable from
-            // a genuinely clean review, so an errored/no-op review auto-approved
-            // verify->done WITHOUT a real review. With the real flag, an errored
-            // review leaves the delivery in verify; the next auto-review poll
-            // re-triggers, and a persistently failing review is bounded by the
-            // review_window_stalled escalation.
-            const reviewSucceeded = !ctx.completionInfo.result.isError;
-            console.log(`[focus-executor] Review pass completed for "${focusName}" (${verifyCount} ` +
-                `delivery(ies) in verify, succeeded=${reviewSucceeded}) -- routing deterministically ` +
-                `by filed issues, then terminating.`);
-            // Coverage evidence: spawn-tip (what the review saw, carried on the team
-            // state) is stamped as the watermark; exit-tip (HEAD now) is compared to
-            // it to detect mid-review drift. Exit-tip is best-effort via injected git
-            // deps; null makes coverage unconfirmable (auto-approve withheld).
-            const reviewSpawnTip = teamState.reviewSpawnTip;
-            let currentBranchTip = null;
-            try {
-                const wt = deps.getFocusWorktree?.(focusId);
-                if (wt?.worktreePath) {
-                    currentBranchTip = deps.readWorktreeHeadSha?.(wt.worktreePath) ?? null;
-                }
-            }
-            catch (err) {
-                console.warn(`[focus-executor] Could not resolve exit-tip for "${focusName}" coverage gate: ${err.message}`);
-            }
-            try {
-                await deps.runReviewExitHandler({
-                    focusId,
-                    focusName,
-                    organizationId: teamState.organizationId,
-                    productId: teamState.productId,
-                    sessionId: teamState.leadSessionId ?? '',
-                    sessionType: 'review',
-                    succeeded: reviewSucceeded,
-                    reviewSpawnTip,
-                    currentBranchTip,
-                });
-            }
-            catch (err) {
-                console.warn(`[focus-executor] Deterministic review routing failed for "${focusName}": ${err.message}`);
-            }
-            teamState.shutdownReason = 'work_complete';
-            deps.terminateTeam(focusId);
-            return;
-        }
-        // A non-review (coding) team completed a cycle while a review is in flight.
-        // Do NOT tear it down on the all-terminal / no-actionable-work branches
-        // below: `verify` is cascadable, so they would SIGTERM the team mid-review.
-        // Leave it running; the review team's own completion closes the focus.
-        console.log(`[focus-executor] "${focusName}" is in a review window (review_requested_at set, ` +
-            `${verifyCount} delivery(ies) in verify) and the completing session is a ` +
-            `${teamState.sessionType} pass -- not tearing down; the review pass completion routes ` +
-            `the verify deliveries.`);
+    // 1. Planning refresh: discover MCP-written deliveries (or escalate an
+    //    empty planning result and terminate).
+    if (await applyPlanningRefresh(ctx, deps, currentDeliveries))
         return;
-    }
-    // Scope-coverage guard: only terminate when EVERY delivery is in a
-    // terminal-for-the-team state (verify, done, cancelled). The
-    // existing isStatusCascadable() classifier matches that set; non-terminal
-    // states (planning, queued, verify_failed, coding, paused) block termination
-    // so the team is re-engaged on remaining work instead of idle-quitting
-    // while unfinished deliveries are still in flight.
+    // 2. Review-window routing: a review pass closes the focus deterministically
+    //    and terminates; a coding pass mid-review is left running.
+    if (await routeReviewWindowCompletion(ctx, deps, currentDeliveries) !== 'not_in_review')
+        return;
+    // 3. Scope-coverage termination: only terminate when EVERY delivery is in a
+    //    terminal-for-the-team state (verify, done, cancelled) -- non-terminal
+    //    states keep the team engaged instead of idle-quitting.
     const nonTerminal = currentDeliveries.filter(d => !isStatusCascadable(d.executionStatus ?? ''));
     if (nonTerminal.length === 0) {
-        console.log(`[focus-executor] All deliveries terminal for "${focusName}" -- terminating team`);
+        log.info(`All deliveries terminal for "${focusName}" -- terminating team`);
         teamState.shutdownReason = 'work_complete';
         deps.terminateTeam(focusId);
         return;
     }
-    // Determine the team's actionable workload up front: both the verify_failed
-    // self-heal and the no-progress guard below depend on whether any
-    // agent-actionable delivery (queued / coding / verify_failed) still carries
-    // an open issue the team can act on.
-    const actionableDeliveryIds = new Set(currentDeliveries
-        .filter(d => isStatusAgentActionable(d.executionStatus ?? ''))
-        .map(d => d.id));
-    const hasActionableWithOpenIssues = currentIssues.some(i => actionableDeliveryIds.has(i.deliveryId) && OPEN_ISSUE_STATUSES.has(i.status));
-    // Self-heal BEFORE the no-progress guard. When actionable deliveries exist
-    // but none carry open issues, the team has nothing left to code. The common
-    // cause is a review that bounced a delivery to verify_failed while all its
-    // issues are already Done. The daemon's transparent
-    // verify_failed -> coding -> verify stepping (advanceDeliveryStatuses) clears
-    // that. Running it here -- before snapshotting -- means a benign "no work to
-    // do" cycle either terminates the team cleanly (all deliveries now terminal)
-    // or shows up as real progress (the delivery status moved), instead of being
-    // counted as coder no-progress. Either way it can no longer accrue toward a
-    // spurious team_failure escalation. (Previously this advance ran only AFTER
-    // the guard, so the counter could reach the limit and escalate first.)
-    let effectiveDeliveries = currentDeliveries;
-    if (actionableDeliveryIds.size > 0 && !hasActionableWithOpenIssues) {
-        try {
-            await deps.advanceDeliveryStatuses(ctx.config, teamState, teamState.leadSessionId ?? '');
-        }
-        catch (err) {
-            console.warn(`[focus-executor] Wake-cycle advanceDeliveryStatuses failed for "${focusName}": ${err.message}`);
-        }
-        // Re-fetch and re-check termination after the advance -- if every delivery
-        // is now terminal-for-the-team, exit cleanly and hand off to review
-        // routing / verification instead of sending a stale re-engagement.
-        try {
-            effectiveDeliveries = await deps.getFocusDeliveries(focusId);
-            const stillNonTerminal = effectiveDeliveries.filter(d => !isStatusCascadable(d.executionStatus ?? ''));
-            if (stillNonTerminal.length === 0) {
-                console.log(`[focus-executor] All deliveries terminal after wake-cycle advance for "${focusName}" -- terminating team`);
-                teamState.shutdownReason = 'work_complete';
-                deps.terminateTeam(focusId);
-                return;
-            }
-        }
-        catch (err) {
-            console.warn(`[focus-executor] Failed to re-fetch deliveries after wake-cycle advance for "${focusName}": ${err.message}`);
-        }
-    }
-    // Recompute the picture on the post-advance state. The team owns exactly two
-    // kinds of non-terminal work: planning deliveries (it scopes them) and
-    // agent-actionable deliveries that still carry open issues (it codes them).
-    const postNonTerminal = effectiveDeliveries.filter(d => !isStatusCascadable(d.executionStatus ?? ''));
-    const postActionableIds = new Set(effectiveDeliveries
-        .filter(d => isStatusAgentActionable(d.executionStatus ?? ''))
-        .map(d => d.id));
-    const postHasActionableOpen = currentIssues.some(i => postActionableIds.has(i.deliveryId) && OPEN_ISSUE_STATUSES.has(i.status));
-    // A read_only focus is awaiting the human ratify gate (audit intake): its
-    // `planning` deliveries are held, not team work the team is failing to
-    // advance. Counting them as actionable made a not-yet-ratified audit focus
-    // accrue no-progress cycles it could never clear -> a spurious no-progress
-    // team_failure (escalation aa58d9c3, focus "Test Quality Audit"). Resolve the
-    // ratification state FRESH (it can flip read_only=false the moment a human
-    // ratifies) and fail open to readOnly=false so a lookup failure preserves the
-    // prior (escalate-eligible) behavior rather than silently muting the guard.
-    // Resolve the audit-phase state FRESH: an explicit read_only=true, OR the
-    // second structural signal (audit-origin AND not-yet-ratified). The second
-    // signal makes a flag-absent audit focus (read_only silently null) still count
-    // as audit-phase here, so its held `planning` deliveries are NOT treated as
-    // team-actionable -- degrading gracefully instead of the spurious no-progress
-    // team_failure (injection #7; escalation aa58d9c3 does not reproduce). Fail
-    // open to NOT-audit-phase so a lookup failure preserves the prior
-    // (escalate-eligible) behavior rather than silently muting the guard.
-    let focusAuditPhase = false;
-    if (deps.getFocusRatificationState) {
-        try {
-            const st = await deps.getFocusRatificationState(ctx.config, focusId);
-            focusAuditPhase = isAuditPhaseFocus({
-                readOnly: st.readOnly,
-                auditOrigin: st.auditOrigin ?? false,
-                ratified: st.ratifiedAt != null,
-            });
-        }
-        catch (err) {
-            console.warn(`[focus-executor] getFocusRatificationState failed for "${focusName}", ` +
-                `treating as not-audit-phase: ${err.message}`);
-        }
-    }
-    // Planning deliveries count as team-actionable ONLY on a non-audit-phase focus
-    // (where the team is expected to scope them). On an audit-phase focus they await
-    // ratification, so they do not keep the team on the no-progress path. A
-    // genuinely stuck planning delivery on a NORMAL focus still escalates
-    // (true-positive preserved). Queued deliveries with zero open issues already
-    // contribute nothing here -- postHasActionableOpen requires an open issue on an
-    // agent-actionable delivery -- so a freshly-scoped, not-yet-started queued
-    // delivery does not, on its own, accrue no-progress cycles.
-    const hasPlanning = !focusAuditPhase && effectiveDeliveries.some(d => (d.executionStatus ?? '') === 'planning');
-    const teamHasActionableWork = hasPlanning || postHasActionableOpen;
-    // Resolve the focus worktree once for BOTH the git-activity snapshot
-    // dimension and the dirty re-wake guard below. A team that wrote AND committed
-    // code this cycle moved the focus branch HEAD even when no DB state moved;
-    // feeding that sha into the snapshot makes the commit reset the no-progress
-    // counter through the EXISTING madeProgress/snapshotsEqual machinery (no
-    // change to the madeProgress logic is needed). null when no worktree is
-    // registered or git could not be read -- the watchdog then behaves exactly as
-    // before on the git axis.
-    const resolveWorktree = deps.getFocusWorktree ?? defaultGetFocusWorktree;
-    const readHeadSha = deps.readWorktreeHeadSha ?? defaultReadWorktreeHeadSha;
-    const focusWorktreePath = resolveWorktree(focusId)?.worktreePath ?? null;
-    const focusHeadSha = focusWorktreePath !== null ? readHeadSha(focusWorktreePath) : null;
-    // Capture the (post-advance) snapshot for progress detection. Treat both null
-    // and undefined as "no prior snapshot" -- legacy test fixtures may not set
-    // the field, and a fresh team has lastProgressSnapshot=null. Snapshotting the
-    // effective (refreshed) deliveries ensures a self-heal that moved a delivery
-    // out of verify_failed registers as progress and resets the counter.
-    //
-    // Computed BEFORE the no-actionable-work branch so the non-advanceable guard
-    // below can gate on "no progress this cycle" -- the branch returns early, so
-    // the original (post-branch) snapshot location was never reached on this path.
-    const snapshot = takeProgressSnapshot(effectiveDeliveries, currentIssues, focusHeadSha);
-    const priorSnapshot = teamState.lastProgressSnapshot ?? null;
-    // NB: a GENUINE review window is already handled ABOVE by the isInReviewWindow
-    // early-return (review_requested_at set AND a delivery still in `verify` ->
-    // the coding team does not tear down and never reaches this counter logic;
-    // deliveries stay in `verify` throughout a review per the lifecycle). So a
-    // blanket "review_requested_at => progress" flag here would NOT protect a
-    // genuine review (that path never gets here) -- it would only fire in the
-    // degenerate state "review_requested_at set, NO verify delivery" (deliveries
-    // already bounced to verify_failed, or an in_review delivery). Treating THAT
-    // as focus-wide progress masks a co-resident genuinely-stuck queued/coding
-    // delivery the team owns and is not moving (the team-stall the watchdog must
-    // still catch). It is unnecessary besides: the bounced-to-verify_failed case
-    // is covered by verifyFailedPendingRequeue below, an in_review delivery is
-    // non-actionable and routes to terminate_no_actionable_work, and a review
-    // that never runs is caught by the review-window staleness detector. So there
-    // is deliberately NO review_requested_at progress flag here.
-    // verify_failed-pending-requeue is daemon-owned advancement. A delivery left
-    // in verify_failed is waiting on the daemon's transparent
-    // verify_failed -> queued requeue (listener-auto-advance); the TEAM cannot
-    // move it until that requeue lands, even though verify_failed is
-    // agent-actionable and keeps teamHasActionableWork true. Without this, a
-    // verify_failed delivery that sits flat across cycles (same status, same
-    // gate_state, same iteration_count -- the entry bump already happened) would
-    // accrue toward a spurious team_failure no-progress escalation purely on
-    // daemon requeue latency. The injection calls this out explicitly: exclude
-    // verify_failed-pending-requeue from the team_failure no-progress path. The
-    // safety backfill that makes this patience safe is the D3 verify_failed
-    // iteration-cap detector -- a genuinely unbounded re-code cycle escalates with
-    // its own verify_gate_unclearable reason, so excluding it here cannot hide a
-    // real wedge.
-    //
-    // CRITICAL SCOPING: this resets the no-progress counter (madeProgress) but is
-    // deliberately NOT folded into advancedThisCycle below. advancedThisCycle
-    // gates the structural dead-end guard, which fires only on the !actionable
-    // path. A verify_failed delivery that is genuinely non-advanceable (NULL
-    // workflow stage -> the daemon can never requeue it) survives the pre-guard
-    // self-heal advance and lands on that !actionable path; it MUST still escalate
-    // as a non-advanceable dead end (the spawn -> idle-exit -> respawn thrash).
-    // "Pending requeue" means the daemon can requeue it; a NULL-stage verify_failed
-    // is NOT pending requeue, it is wedged. Counting it as advancement would
-    // re-open the very thrash this watchdog exists to stop.
-    const verifyFailedPendingRequeue = effectiveDeliveries.some(d => (d.executionStatus ?? '') === 'verify_failed');
-    const madeProgress = verifyFailedPendingRequeue || priorSnapshot === null
-        ? true
-        : !snapshotsEqual(priorSnapshot, snapshot);
-    // Did the team *positively advance* state this cycle? Distinct from
-    // madeProgress: a null prior snapshot (a FRESH or RESPAWNED team) is NOT
-    // evidence of advancement -- the team simply has no baseline to compare
-    // against. madeProgress treats a null prior as `true` so a team's first cycle
-    // is not penalised toward the multi-cycle no-progress counter; but the
-    // structural dead-end guard below must NOT inherit that optimism. In the real
-    // thrash the daemon terminates and respawns the team every poll, so the
-    // completion handler ALWAYS sees priorSnapshot === null -> madeProgress always
-    // true -> the dead-end guard (when gated on !madeProgress) was unreachable and
-    // the focus churned forever. Gate the dead-end guard on !advancedThisCycle
-    // instead: false for a null prior (eligible -> can escalate), and false for an
-    // unchanged snapshot (genuinely stuck), but true when the team actually moved
-    // state this cycle (a live, progressing team is not wedged).
-    // verify_failed-pending-requeue is deliberately NOT included here (see the
-    // CRITICAL SCOPING note above): a NULL-stage verify_failed reaches the
-    // !actionable dead-end guard and must remain eligible to escalate.
-    const advancedThisCycle = priorSnapshot !== null && !snapshotsEqual(priorSnapshot, snapshot);
-    // ── Decide: handoff vs terminate ────────────────────────────────────────
-    // The decision tree is pure and isolated in completion-decision.ts
-    // (decideCompletionAction); this handler computes the facts and executes
-    // the chosen action's side effects.
-    //
-    // Non-advanceability lookup, gated by shouldCheckNonAdvanceable: scoped to
-    // agent-actionable deliveries (queued / coding / verify_failed). Those are
-    // the states the team is *expected* to move; when one carries no open
-    // issues AND cannot be advanced by the daemon either, it is a true dead
-    // end -> the thrash loop. Daemon/review-managed states (in_review, paused)
-    // are deliberately excluded: another subsystem owns advancing them, so a
-    // NULL/manual stage there is not a thrash dead end and must keep
-    // terminating cleanly. Gated on !advancedThisCycle (NOT !madeProgress):
-    // the daemon respawns the team every poll, so a wedged focus reaches here
-    // with a null prior snapshot EVERY cycle. !madeProgress was therefore never
-    // true on the live thrash path and the guard never fired -- the focus
-    // churned a fresh team indefinitely.
-    let stuck = null;
-    if (shouldCheckNonAdvanceable({ teamHasActionableWork, advancedThisCycle })) {
-        const candidates = postNonTerminal.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
-        stuck = await findNonAdvanceableDelivery(candidates, deps.fetchEffectiveWorkflow);
-    }
-    // The no-progress counter value AFTER this cycle's reset-or-increment.
-    // Only committed to teamState on the actionable-work paths below -- the
-    // no-actionable-work terminations deliberately do not touch the counter
-    // (matching the pre-decision-extraction behavior).
-    const updatedNoProgressCycles = madeProgress ? 0 : (teamState.noProgressCycles ?? 0) + 1;
-    // Measurable progress this cycle (any axis moved, including a fresh commit on
-    // the focus branch) means the prior dirty episode -- if any -- is no longer
-    // stalled, so the commit-nudge budget resets alongside the no-progress
-    // counter. Committed to teamState on the same branches that commit the
-    // no-progress counter (the actionable-work paths), keeping the two in lockstep.
-    if (madeProgress) {
-        teamState.commitNudgeAttempts = 0;
-    }
+    // 4. Wake-cycle self-heal: clear verify_failed-with-all-Done via the
+    //    daemon's transparent advance before any progress accounting.
+    const heal = await runWakeCycleSelfHeal(ctx, deps, currentDeliveries, currentIssues);
+    if (heal.terminated)
+        return;
+    // 5. Compute the factual picture once, then decide (pure).
+    const facts = await computeCompletionFacts(ctx, deps, currentDeliveries, heal.effectiveDeliveries, currentIssues);
     const action = decideCompletionAction({
-        teamHasActionableWork,
-        advancedThisCycle,
-        hasNonAdvanceableStuck: stuck !== null,
-        noProgressCycles: updatedNoProgressCycles,
+        teamHasActionableWork: facts.teamHasActionableWork,
+        advancedThisCycle: facts.advancedThisCycle,
+        hasNonAdvanceableStuck: facts.stuck !== null,
+        noProgressCycles: facts.updatedNoProgressCycles,
         noProgressLimit: SCOPE_COVERAGE_NO_PROGRESS_LIMIT,
-        hasActionableOpenIssues: postHasActionableOpen,
+        hasActionableOpenIssues: facts.postHasActionableOpen,
     });
-    const shouldRecordDeliveryAdvancementCycle = teamHasActionableWork &&
-        action.kind !== 'escalate_no_progress_and_terminate' &&
-        (priorSnapshot === null || !madeProgress);
-    const deliveryAdvancement = shouldRecordDeliveryAdvancementCycle
-        ? recordDeliveryAdvancementCycle(focusId, effectiveDeliveries, 
-        // Reuse the SAME issue + head-sha values event.ts already computed for the
-        // madeProgress snapshot above -- passed through, never re-derived -- so the
-        // guard's cross-respawn progress axes stay consistent with madeProgress
-        // without a second issue fetch or git read (AC#5). These broaden the guard
-        // beyond execution_status so a done delivery pinned at `coding` alongside a
-        // freshly-added queued sibling no longer reads as a stall while real issue
-        // transitions and commits land (escalation a4a4d0ac).
-        currentIssues, focusHeadSha, DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT)
-        : null;
-    if (deliveryAdvancement?.thresholdReached) {
-        let alreadyEscalated = false;
-        try {
-            alreadyEscalated = await deps.hasOpenTeamFailureEscalation(focusId);
-        }
-        catch (err) {
-            console.warn(`[focus-executor] Open-escalation check failed for "${focusName}", proceeding to escalate delivery-advancement stall: ${err.message}`);
-        }
-        if (!alreadyEscalated) {
-            await escalateDeliveryAdvancementStalled({
-                organizationId: teamState.organizationId,
-                sessionId: teamState.leadSessionId ?? '',
-                focusId,
-                focusName,
-                agentRoleId: teamState.roleId,
-                cycles: deliveryAdvancement.noAdvancementCycles,
-                deliveries: effectiveDeliveries,
-            }, deps);
-        }
-        else {
-            console.log(`[focus-executor] Delivery-advancement stall for "${focusName}" but an open ` +
-                `team_failure escalation already exists -- terminating without filing a duplicate`);
-        }
-        teamState.shutdownReason = 'work_complete';
-        deps.terminateTeam(focusId);
+    // 6. Cross-respawn delivery-advancement watchdog (may escalate + terminate).
+    if (await checkDeliveryAdvancementStall(ctx, deps, facts, action, DELIVERY_ADVANCEMENT_NO_PROGRESS_LIMIT))
         return;
-    }
-    switch (action.kind) {
-        case 'escalate_non_advanceable_and_terminate': {
-            // No team-actionable work AND the team did not advance state this cycle
-            // AND at least one remaining non-terminal delivery is *non-advanceable*
-            // (NULL stage, or no automatic transition out of its current stage):
-            // nothing -- not the team, not the daemon -- will ever move it.
-            // Terminating cleanly would just feed the spawn -> idle-exit -> respawn
-            // thrash loop. Per the asymmetry principle the daemon must escalate,
-            // never silently churn. File EXACTLY ONE escalation (idempotent: skip if
-            // one is already open) and terminate. The escalation is filed as
-            // escalation_kind 'team_failure', which the existing respawn guard
-            // already suppresses, so the focus is not immediately respawned.
-            let alreadyEscalated = false;
-            try {
-                alreadyEscalated = await deps.hasOpenTeamFailureEscalation(focusId);
-            }
-            catch (err) {
-                console.warn(`[focus-executor] Open-escalation check failed for "${focusName}", proceeding to escalate: ${err.message}`);
-            }
-            if (!alreadyEscalated) {
-                console.warn(`[focus-executor] Non-advanceable delivery for "${focusName}" -- ` +
-                    `"${stuck.name}" [${stuck.executionStatus ?? 'draft'}] cannot be advanced ` +
-                    `(stage=${stuck.currentWorkflowStageId ?? 'NULL'}); escalating and terminating ` +
-                    `instead of respawning`);
-                await escalateNonAdvanceable({
-                    organizationId: teamState.organizationId,
-                    sessionId: teamState.leadSessionId ?? '',
-                    focusId,
-                    focusName,
-                    agentRoleId: teamState.roleId,
-                    stuck: stuck,
-                    remaining: postNonTerminal,
-                }, deps);
-            }
-            else {
-                console.log(`[focus-executor] Non-advanceable delivery for "${focusName}" but an open ` +
-                    `escalation already exists -- terminating without filing a duplicate`);
-            }
-            teamState.lastProgressSnapshot = snapshot;
-            teamState.shutdownReason = 'work_complete';
-            deps.terminateTeam(focusId);
-            return;
-        }
-        case 'terminate_no_actionable_work': {
-            // Every remaining non-terminal delivery is in a daemon/review-managed
-            // state the coding team cannot advance (in_review, paused, or a
-            // verify_failed the self-heal could not yet clear). The team is NOT
-            // stuck on work it can do -- it has nothing to do. Terminate cleanly
-            // and let the daemon (on-exit advance), the listener auto-advance, and
-            // the review routing move these deliveries.
-            console.log(`[focus-executor] No team-actionable work remains for "${focusName}" -- ` +
-                `${postNonTerminal.length} non-terminal delivery(ies) in daemon-managed states ` +
-                `(in_review / paused / verify-pending); terminating cleanly without escalation`);
-            teamState.shutdownReason = 'work_complete';
-            deps.terminateTeam(focusId);
-            return;
-        }
-        case 'escalate_no_progress_and_terminate': {
-            // ── Git-aware re-wake-before-terminate ────────────────────────────────
-            // This is the path that was KILLING PRODUCERS: a coding team that wrote
-            // all its code but did not commit it sees no delivery/issue STATE move, so
-            // it crosses the no-progress threshold and -- without this guard -- is
-            // escalated + terminated. Once it is dead the commit-gate has no live team
-            // to re-wake, so the uncommitted work is stranded until a human commits.
-            //
-            // Before escalating, check whether the team actually PRODUCED work: a
-            // dirty focus worktree (uncommitted changes) means there is real work to
-            // preserve. If so AND a live lead is still reachable AND the commit-nudge
-            // budget is not exhausted, nudge the lead to commit instead of killing it.
-            // The team stays alive, commits its own work, and the delivery advances
-            // out of coding through the normal commit-gate -- no manual commit, no
-            // escalation. A genuinely idle team (clean tree, OR no live lead, OR
-            // budget exhausted) falls through to the unchanged escalate+terminate
-            // behavior below, so a team that will never commit still escalates.
-            const worktreeIsDirty = focusWorktreePath !== null &&
-                (deps.worktreeHasUncommittedChanges ?? defaultWorktreeHasUncommittedChanges)(focusWorktreePath);
-            const liveLead = teamState.leadStdin;
-            // Budget mirrors the advance-block auto-remediation budget so the two
-            // re-wake paths (this one and delivery-advance-block's) bound retries the
-            // same way; resolveAutoRemediationBudget reads TELORA_AUTO_REMEDIATION_BUDGET.
-            const commitNudgeBudget = resolveAutoRemediationBudget();
-            const nudgesSpent = teamState.commitNudgeAttempts ?? 0;
-            if (worktreeIsDirty && liveLead && nudgesSpent < commitNudgeBudget) {
-                // Keep the producing team alive: nudge it to commit, record the
-                // snapshot + bump the per-episode nudge counter, reset the completion
-                // detector so the next 'complete' event is a fresh cycle, and RETURN
-                // WITHOUT terminating or escalating.
-                teamState.commitNudgeAttempts = nudgesSpent + 1;
-                teamState.lastProgressSnapshot = snapshot;
-                console.warn(`[focus-executor] No-progress threshold reached for "${focusName}", but the ` +
-                    `focus worktree has uncommitted changes and a live lead is reachable -- ` +
-                    `re-waking the team to commit instead of terminating ` +
-                    `(commit-nudge attempt ${teamState.commitNudgeAttempts}/${commitNudgeBudget}).`);
-                sendMessage(liveLead, `Your focus worktree has uncommitted changes, so the daemon cannot advance ` +
-                    `the delivery and will not terminate the team yet. Please commit your work in ` +
-                    `${focusWorktreePath}, and move every finished issue to In Review (its delivery ` +
-                    `advances out of coding once its work issues are Done/Verified/In Review). The ` +
-                    `daemon advances automatically once the worktree is clean. (commit-nudge attempt ` +
-                    `${teamState.commitNudgeAttempts}/${commitNudgeBudget})`);
-                completionDetector.reset();
-                return;
-            }
-            // ── Reconcile captured work into the verify gate ──────────────────────
-            // The commit-nudge re-wake did not fire (clean tree, OR no live lead, OR
-            // budget exhausted). Before escalating, rescue any committed work: the
-            // reconciler safety-commits a dirty worktree so the team's bytes are
-            // captured, and if the focus branch now carries committed work, it flips
-            // each finished coding delivery's In-Progress issues -> In Review and
-            // advances coding -> verify so the work re-enters the review gate instead
-            // of dead-ending in coding (the recurring stall this focus fixes). The
-            // no-progress team_failure escalation below fires ONLY when nothing was
-            // reconciled -- i.e. genuinely nothing was produced.
-            const reconcile = deps.reconcileTerminatedTeamWork ?? defaultReconcileTerminatedTeamWork;
-            let reconciled = { reconciledCount: 0, workCaptured: false };
-            try {
-                reconciled = await reconcile({
-                    config: ctx.config,
-                    teamState,
-                    deliveries: effectiveDeliveries,
-                    issues: currentIssues,
-                    worktreePath: focusWorktreePath,
-                    sessionId: teamState.leadSessionId ?? '',
-                });
-            }
-            catch (err) {
-                console.warn(`[focus-executor] Terminated-work reconciliation failed for "${focusName}": ${err.message}`);
-            }
-            if (reconciled.reconciledCount > 0) {
-                // Committed work re-entered the gate -- terminate cleanly, NO team_failure.
-                teamState.commitNudgeAttempts = 0;
-                teamState.noProgressCycles = updatedNoProgressCycles;
-                teamState.lastProgressSnapshot = snapshot;
-                console.log(`[focus-executor] Terminated team for "${focusName}" had committed work -- ` +
-                    `reconciled ${reconciled.reconciledCount} coding delivery(ies) into verify; ` +
-                    `terminating WITHOUT a team_failure escalation.`);
-                teamState.shutdownReason = 'work_complete';
-                deps.terminateTeam(focusId);
-                return;
-            }
-            // Crossed the no-progress threshold: escalate and shut the team down so
-            // a human can intervene. Reached only when the team HAS actionable work
-            // it owns -- a planning delivery to scope, or a coding delivery whose
-            // issues stay open -- yet has not moved it for N consecutive cycles. The
-            // no-actionable-work cases (verify_failed-with-all-Done, in_review,
-            // paused) terminate cleanly above and never reach here, so this
-            // escalation now means a genuinely stuck team, not a daemon-managed
-            // transition. The worktree is clean here (or no lead / budget spent), so
-            // the dirty episode -- if there was one -- is over: reset the nudge counter.
-            teamState.commitNudgeAttempts = 0;
-            teamState.noProgressCycles = updatedNoProgressCycles;
-            teamState.lastProgressSnapshot = snapshot;
-            console.warn(`[focus-executor] Scope-coverage guard tripped for "${focusName}" -- ` +
-                `${teamState.noProgressCycles} consecutive cycles with no progress on ${postNonTerminal.length} ` +
-                `non-terminal delivery(ies); escalating and terminating`);
-            await escalateNoProgress({
-                organizationId: teamState.organizationId,
-                sessionId: teamState.leadSessionId ?? '',
-                focusId,
-                focusName,
-                agentRoleId: teamState.roleId,
-                cycles: teamState.noProgressCycles,
-                remaining: postNonTerminal,
-            }, deps);
-            teamState.shutdownReason = 'work_complete';
-            deps.terminateTeam(focusId);
-            return;
-        }
-        case 'handoff_new_work':
-        case 'reengage': {
-            teamState.noProgressCycles = updatedNoProgressCycles;
-            teamState.lastProgressSnapshot = snapshot;
-            // Actionable deliveries with open issues -> wake message with the new
-            // work. Otherwise (planning deliveries remain) -> re-engagement nudge to
-            // scope them.
-            let message;
-            if (action.kind === 'handoff_new_work') {
-                console.log(`[focus-executor] Mid-focus handoff for "${focusName}" -- sending new work`);
-                message = buildWakeMessage(effectiveDeliveries, currentIssues, teamState.knownDeliveryIds);
-            }
-            else {
-                console.log(`[focus-executor] Re-engaging "${focusName}" -- ${postNonTerminal.length} non-terminal ` +
-                    `delivery(ies) remain (cycle ${teamState.noProgressCycles}/${SCOPE_COVERAGE_NO_PROGRESS_LIMIT})`);
-                message = buildReEngagementMessage(postNonTerminal, currentIssues);
-            }
-            // Update tracking state
-            for (const d of currentDeliveries) {
-                teamState.knownDeliveryIds.add(d.id);
-                teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
-            }
-            completionDetector.reset();
-            sendMessage(proc.stdin, message);
-            return;
-        }
-    }
+    // 7. Execute the chosen action's side effects.
+    await executeCompletionAction(ctx, deps, facts, action, SCOPE_COVERAGE_NO_PROGRESS_LIMIT);
 }
 // ── Progress snapshot helpers ───────────────────────────────────────────
 // Extracted to ./progress-snapshot.ts (keeps this file under the structural