@telora/daemon 0.20.28 → 0.20.53

package/dist/completion/event-entry-phases.js

@@ -0,0 +1,205 @@
+/**
+ * Entry phases of the completion-event pipeline -- the three that run BEFORE
+ * any factual picture is computed, each able to short-circuit the pipeline:
+ *
+ *   1. applyPlanningRefresh        planning-team delivery discovery / failure
+ *   2. routeReviewWindowCompletion review routing (review pass vs coding pass)
+ *   3. runWakeCycleSelfHeal        pre-guard advanceDeliveryStatuses self-heal
+ *
+ * Split out of event-phases.ts (which kept phases 4-6: the factual picture,
+ * the advancement watchdog, and action side effects) purely to hold both
+ * files under the 800-line daemon module limit. Behavior is unchanged: same
+ * reads, same order, same log lines, same early returns, and delivery
+ * execution_status transition semantics remain owned by the single-writer
+ * reconciler.
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { isStatusCascadable, isStatusAgentActionable } from '../stage-classifier.js';
+import { OPEN_ISSUE_STATUSES } from '../constants.js';
+import { isInReviewWindow } from './advanceability.js';
+import { escalatePlanningFailure } from './event-escalations.js';
+import { createLogger } from '../log.js';
+const log = createLogger({ module: 'focus-executor' });
+// ── Phase 1: planning refresh ───────────────────────────────────────────
+/**
+ * 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.
+ *
+ * Returns true when the team was terminated (planning produced nothing).
+ */
+export async function applyPlanningRefresh(ctx, deps, currentDeliveries) {
+    const { focusId, focusName, teamState } = ctx;
+    if (!teamState.planningPhase)
+        return false;
+    if (currentDeliveries.length === 0) {
+        log.warn(`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 true;
+    }
+    for (const d of currentDeliveries) {
+        teamState.knownDeliveryIds.add(d.id);
+        teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
+    }
+    teamState.planningPhase = false;
+    log.info(`Planning refresh for "${focusName}": ` +
+        `${currentDeliveries.length} delivery(ies) discovered`);
+    return false;
+}
+/**
+ * Review-window handling. Resolves review_requested_at FRESH because it can
+ * be set/cleared between spawn and this event.
+ *
+ * - A completing REVIEW pass routes verify deliveries deterministically
+ *   (runReviewExitHandler) and terminates -> 'terminated'.
+ * - A completing CODING pass during a review window is left alive so the
+ *   review's own completion closes the focus -> 'leave_running'.
+ * - Otherwise -> 'not_in_review' and the pipeline continues.
+ */
+export async function routeReviewWindowCompletion(ctx, deps, currentDeliveries) {
+    const { focusId, focusName, teamState } = ctx;
+    let reviewRequestedAt = null;
+    if (deps.getReviewRequestedAt) {
+        try {
+            reviewRequestedAt = await deps.getReviewRequestedAt(ctx.config, focusId);
+        }
+        catch (err) {
+            log.warn(`getReviewRequestedAt failed for "${focusName}": ${err.message}`);
+            // Fail open: a read failure must not block the existing teardown logic.
+        }
+    }
+    if (!isInReviewWindow(reviewRequestedAt, currentDeliveries))
+        return 'not_in_review';
+    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;
+        log.info(`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) {
+            log.warn(`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) {
+            log.warn(`Deterministic review routing failed for "${focusName}": ${err.message}`);
+        }
+        teamState.shutdownReason = 'work_complete';
+        deps.terminateTeam(focusId);
+        return 'terminated';
+    }
+    // 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.
+    log.info(`"${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.`);
+    return 'leave_running';
+}
+// ── Phase 3: wake-cycle self-heal advance ───────────────────────────────
+/**
+ * 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.)
+ */
+export async function runWakeCycleSelfHeal(ctx, deps, currentDeliveries, currentIssues) {
+    const { focusId, focusName, teamState } = ctx;
+    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));
+    let effectiveDeliveries = currentDeliveries;
+    if (actionableDeliveryIds.size > 0 && !hasActionableWithOpenIssues) {
+        try {
+            await deps.advanceDeliveryStatuses(ctx.config, teamState, teamState.leadSessionId ?? '');
+        }
+        catch (err) {
+            log.warn(`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) {
+                log.info(`All deliveries terminal after wake-cycle advance for "${focusName}" -- terminating team`);
+                teamState.shutdownReason = 'work_complete';
+                deps.terminateTeam(focusId);
+                return { terminated: true, effectiveDeliveries };
+            }
+        }
+        catch (err) {
+            log.warn(`Failed to re-fetch deliveries after wake-cycle advance for "${focusName}": ${err.message}`);
+        }
+    }
+    return { terminated: false, effectiveDeliveries };
+}
+//# sourceMappingURL=event-entry-phases.js.map

package/dist/completion/event-entry-phases.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-entry-phases.js","sourceRoot":"","sources":["../../src/completion/event-entry-phases.ts"],"names":[],"mappings":"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"}

package/dist/completion/event-phases.d.ts

@@ -5,13 +5,16 @@
  * (completion/event.ts) so each sub-decision is independently testable
  * without constructing the whole completion world:
  *
- *   1. applyPlanningRefresh        planning-team delivery discovery / failure
- *   2. routeReviewWindowCompletion review routing (review pass vs coding pass)
- *   3. runWakeCycleSelfHeal        pre-guard advanceDeliveryStatuses self-heal
  *   4. computeCompletionFacts      the post-advance factual picture
  *   5. checkDeliveryAdvancementStall  cross-respawn advancement watchdog
  *   6. executeCompletionAction     side effects of the chosen action
  *
+ * Phases 1-3 -- the pre-decision entry phases that can short-circuit the
+ * pipeline (applyPlanningRefresh, routeReviewWindowCompletion,
+ * runWakeCycleSelfHeal) -- live in event-entry-phases.ts. The split is purely
+ * to hold both files under the 800-line daemon module limit; the pipeline
+ * order and semantics are unchanged.
+ *
  * The decision itself stays pure in completion-decision.ts. Behavior is
  * preserved exactly: same reads, same order, same log lines, same early
  * returns; delivery execution_status transition semantics are untouched
@@ -20,45 +23,6 @@
 import type { FocusDeliveryInfo, FocusIssueInfo, ProgressSnapshot } from '../types.js';
 import { type CompletionAction } from './completion-decision.js';
 import type { CompletionEventContext, CompletionEventDeps } from './event.js';
-/**
- * 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.
- *
- * Returns true when the team was terminated (planning produced nothing).
- */
-export declare function applyPlanningRefresh(ctx: CompletionEventContext, deps: CompletionEventDeps, currentDeliveries: FocusDeliveryInfo[]): Promise<boolean>;
-export type ReviewWindowOutcome = 'terminated' | 'leave_running' | 'not_in_review';
-/**
- * Review-window handling. Resolves review_requested_at FRESH because it can
- * be set/cleared between spawn and this event.
- *
- * - A completing REVIEW pass routes verify deliveries deterministically
- *   (runReviewExitHandler) and terminates -> 'terminated'.
- * - A completing CODING pass during a review window is left alive so the
- *   review's own completion closes the focus -> 'leave_running'.
- * - Otherwise -> 'not_in_review' and the pipeline continues.
- */
-export declare function routeReviewWindowCompletion(ctx: CompletionEventContext, deps: CompletionEventDeps, currentDeliveries: FocusDeliveryInfo[]): Promise<ReviewWindowOutcome>;
-/**
- * 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.)
- */
-export declare function runWakeCycleSelfHeal(ctx: CompletionEventContext, deps: CompletionEventDeps, currentDeliveries: FocusDeliveryInfo[], currentIssues: FocusIssueInfo[]): Promise<{
-    terminated: boolean;
-    effectiveDeliveries: FocusDeliveryInfo[];
-}>;
 /** Everything the decision + action execution need, computed once. */
 export interface CompletionFacts {
     /** The ORIGINAL pre-advance delivery list (tracking-state update uses it). */
@@ -76,6 +40,14 @@ export interface CompletionFacts {
     advancedThisCycle: boolean;
     stuck: FocusDeliveryInfo | null;
     updatedNoProgressCycles: number;
+    /**
+     * True when the team is parked on an open, unanswered directed escalation
+     * (needs_intent / needs_clarification) anchored to a delivery it is working.
+     * Fail-open (a lookup error resolves to false). Routes the decision to the
+     * `hold_blocked_on_directed_escalation` action and suppresses the cross-respawn
+     * advancement watchdog so a blocked team is neither escalated nor re-engaged.
+     */
+    blockedOnDirectedEscalation: boolean;
 }
 /**
  * Recompute the picture on the post-advance state. The team owns exactly two

package/dist/completion/event-phases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-phases.d.ts","sourceRoot":"","sources":["../../src/completion/event-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMvF,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAkB5F,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAO9E;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,iBAAiB,EAAE,iBAAiB,EAAE,GACrC,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAID,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG,eAAe,GAAG,eAAe,CAAC;AAEnF;;;;;;;;;GASG;AACH,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,iBAAiB,EAAE,iBAAiB,EAAE,GACrC,OAAO,CAAC,mBAAmB,CAAC,CA+F9B;AAID;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,iBAAiB,EAAE,iBAAiB,EAAE,EACtC,aAAa,EAAE,cAAc,EAAE,GAC9B,OAAO,CAAC;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,mBAAmB,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAAC,CAiD5E;AAID,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;IACvC,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,aAAa,EAAE,cAAc,EAAE,CAAC;IAChC,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAChC,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,iBAAiB,EAAE,iBAAiB,EAAE,EACtC,mBAAmB,EAAE,iBAAiB,EAAE,EACxC,aAAa,EAAE,cAAc,EAAE,GAC9B,OAAO,CAAC,eAAe,CAAC,CAyI1B;AAID;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,gBAAgB,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAiDlB;AAID;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,gBAAgB,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CA6Mf"}
+{"version":3,"file":"event-phases.d.ts","sourceRoot":"","sources":["../../src/completion/event-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAMvF,OAAO,EAA6B,KAAK,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAiB5F,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAO9E,sEAAsE;AACtE,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;IACvC,mBAAmB,EAAE,iBAAiB,EAAE,CAAC;IACzC,aAAa,EAAE,cAAc,EAAE,CAAC;IAChC,eAAe,EAAE,iBAAiB,EAAE,CAAC;IACrC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,qBAAqB,EAAE,OAAO,CAAC;IAC/B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,aAAa,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvC,YAAY,EAAE,OAAO,CAAC;IACtB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAChC,uBAAuB,EAAE,MAAM,CAAC;IAChC;;;;;;OAMG;IACH,2BAA2B,EAAE,OAAO,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,iBAAiB,EAAE,iBAAiB,EAAE,EACtC,mBAAmB,EAAE,iBAAiB,EAAE,EACxC,aAAa,EAAE,cAAc,EAAE,GAC9B,OAAO,CAAC,eAAe,CAAC,CA2K1B;AAID;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,gBAAgB,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAwDlB;AAID;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,GAAG,EAAE,sBAAsB,EAC3B,IAAI,EAAE,mBAAmB,EACzB,KAAK,EAAE,eAAe,EACtB,MAAM,EAAE,gBAAgB,EACxB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC,CA8Nf"}

package/dist/completion/event-phases.js

@@ -5,217 +5,38 @@
  * (completion/event.ts) so each sub-decision is independently testable
  * without constructing the whole completion world:
  *
- *   1. applyPlanningRefresh        planning-team delivery discovery / failure
- *   2. routeReviewWindowCompletion review routing (review pass vs coding pass)
- *   3. runWakeCycleSelfHeal        pre-guard advanceDeliveryStatuses self-heal
  *   4. computeCompletionFacts      the post-advance factual picture
  *   5. checkDeliveryAdvancementStall  cross-respawn advancement watchdog
  *   6. executeCompletionAction     side effects of the chosen action
  *
+ * Phases 1-3 -- the pre-decision entry phases that can short-circuit the
+ * pipeline (applyPlanningRefresh, routeReviewWindowCompletion,
+ * runWakeCycleSelfHeal) -- live in event-entry-phases.ts. The split is purely
+ * to hold both files under the 800-line daemon module limit; the pipeline
+ * order and semantics are unchanged.
+ *
  * The decision itself stays pure in completion-decision.ts. Behavior is
  * preserved exactly: same reads, same order, same log lines, same early
  * returns; delivery execution_status transition semantics are untouched
  * (single-writer reconciler).
  */
-import { sendMessage, DELIVERY_STATUS } from '@telora/daemon-core';
+import { sendMessage } from '@telora/daemon-core';
 import { isStatusCascadable, isStatusAgentActionable } from '../stage-classifier.js';
 import { buildWakeMessage, buildReEngagementMessage } from '../focus-prompt-builder.js';
 import { OPEN_ISSUE_STATUSES } from '../constants.js';
 import { isAuditPhaseFocus } from '../audit-shape.js';
 import { shouldCheckNonAdvanceable } from './completion-decision.js';
 import { takeProgressSnapshot, snapshotsEqual } from './progress-snapshot.js';
-import { isInReviewWindow, findNonAdvanceableDelivery } from './advanceability.js';
+import { findNonAdvanceableDelivery } from './advanceability.js';
 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';
-import { escalatePlanningFailure, escalateNoProgress, escalateNonAdvanceable, escalateDeliveryAdvancementStalled, } from './event-escalations.js';
+import { escalateNoProgress, escalateNonAdvanceable, escalateDeliveryAdvancementStalled, } from './event-escalations.js';
 import { recordDeliveryAdvancementCycle } from './delivery-advancement-guard.js';
 import { reconcileTerminatedTeamWork as defaultReconcileTerminatedTeamWork, } from './terminated-work-reconcile.js';
 import { createLogger } from '../log.js';
 const log = createLogger({ module: 'focus-executor' });
-// ── Phase 1: planning refresh ───────────────────────────────────────────
-/**
- * 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.
- *
- * Returns true when the team was terminated (planning produced nothing).
- */
-export async function applyPlanningRefresh(ctx, deps, currentDeliveries) {
-    const { focusId, focusName, teamState } = ctx;
-    if (!teamState.planningPhase)
-        return false;
-    if (currentDeliveries.length === 0) {
-        log.warn(`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 true;
-    }
-    for (const d of currentDeliveries) {
-        teamState.knownDeliveryIds.add(d.id);
-        teamState.deliveryStageIds.set(d.id, d.currentWorkflowStageId);
-    }
-    teamState.planningPhase = false;
-    log.info(`Planning refresh for "${focusName}": ` +
-        `${currentDeliveries.length} delivery(ies) discovered`);
-    return false;
-}
-/**
- * Review-window handling. Resolves review_requested_at FRESH because it can
- * be set/cleared between spawn and this event.
- *
- * - A completing REVIEW pass routes verify deliveries deterministically
- *   (runReviewExitHandler) and terminates -> 'terminated'.
- * - A completing CODING pass during a review window is left alive so the
- *   review's own completion closes the focus -> 'leave_running'.
- * - Otherwise -> 'not_in_review' and the pipeline continues.
- */
-export async function routeReviewWindowCompletion(ctx, deps, currentDeliveries) {
-    const { focusId, focusName, teamState } = ctx;
-    let reviewRequestedAt = null;
-    if (deps.getReviewRequestedAt) {
-        try {
-            reviewRequestedAt = await deps.getReviewRequestedAt(ctx.config, focusId);
-        }
-        catch (err) {
-            log.warn(`getReviewRequestedAt failed for "${focusName}": ${err.message}`);
-            // Fail open: a read failure must not block the existing teardown logic.
-        }
-    }
-    if (!isInReviewWindow(reviewRequestedAt, currentDeliveries))
-        return 'not_in_review';
-    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;
-        log.info(`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) {
-            log.warn(`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) {
-            log.warn(`Deterministic review routing failed for "${focusName}": ${err.message}`);
-        }
-        teamState.shutdownReason = 'work_complete';
-        deps.terminateTeam(focusId);
-        return 'terminated';
-    }
-    // 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.
-    log.info(`"${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.`);
-    return 'leave_running';
-}
-// ── Phase 3: wake-cycle self-heal advance ───────────────────────────────
-/**
- * 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.)
- */
-export async function runWakeCycleSelfHeal(ctx, deps, currentDeliveries, currentIssues) {
-    const { focusId, focusName, teamState } = ctx;
-    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));
-    let effectiveDeliveries = currentDeliveries;
-    if (actionableDeliveryIds.size > 0 && !hasActionableWithOpenIssues) {
-        try {
-            await deps.advanceDeliveryStatuses(ctx.config, teamState, teamState.leadSessionId ?? '');
-        }
-        catch (err) {
-            log.warn(`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) {
-                log.info(`All deliveries terminal after wake-cycle advance for "${focusName}" -- terminating team`);
-                teamState.shutdownReason = 'work_complete';
-                deps.terminateTeam(focusId);
-                return { terminated: true, effectiveDeliveries };
-            }
-        }
-        catch (err) {
-            log.warn(`Failed to re-fetch deliveries after wake-cycle advance for "${focusName}": ${err.message}`);
-        }
-    }
-    return { terminated: false, effectiveDeliveries };
-}
 /**
  * Recompute the picture on the post-advance state. The team owns exactly two
  * kinds of non-terminal work: planning deliveries (it scopes them) and
@@ -310,11 +131,40 @@ export async function computeCompletionFacts(ctx, deps, currentDeliveries, effec
         const candidates = postNonTerminal.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
         stuck = await findNonAdvanceableDelivery(candidates, deps.fetchEffectiveWorkflow);
     }
+    // A team parked on its own unanswered DIRECTED escalation (needs_intent /
+    // needs_clarification) anchored to a delivery it is working is BLOCKED on a
+    // human answer, not stalling. Consult the lookup ONLY on the cycle where the
+    // team would otherwise accrue a no-progress increment (has actionable work AND
+    // did not move state), so a healthy cycle never pays the query. FAIL-OPEN: any
+    // lookup error resolves to not-blocked, so a genuine stall is never masked by
+    // a failed check -- the OPPOSITE of the operator-hold gate, which fails closed.
+    let blockedOnDirectedEscalation = false;
+    if (teamHasActionableWork && !madeProgress && deps.findOpenDirectedHold) {
+        const actionableDeliveries = effectiveDeliveries.filter(d => isStatusAgentActionable(d.executionStatus ?? ''));
+        for (const d of actionableDeliveries) {
+            try {
+                if (await deps.findOpenDirectedHold(d.id, focusId)) {
+                    blockedOnDirectedEscalation = true;
+                    break;
+                }
+            }
+            catch (err) {
+                log.warn(`Directed-escalation hold lookup failed for "${focusName}" delivery ${d.id}, ` +
+                    `treating as not-blocked: ${err.message}`);
+            }
+        }
+    }
     // The no-progress counter value AFTER this cycle's reset-or-increment.
     // Only committed to teamState on the actionable-work paths in
     // executeCompletionAction -- the no-actionable-work terminations deliberately
-    // do not touch the counter.
-    const updatedNoProgressCycles = madeProgress ? 0 : (teamState.noProgressCycles ?? 0) + 1;
+    // do not touch the counter. A blocked team FREEZES the counter (neither reset
+    // nor increment): the wait is not progress, but it is not a stall either, so
+    // the count is preserved to resume exactly where it was once the block clears.
+    const updatedNoProgressCycles = madeProgress
+        ? 0
+        : blockedOnDirectedEscalation
+            ? (teamState.noProgressCycles ?? 0)
+            : (teamState.noProgressCycles ?? 0) + 1;
     // Measurable progress this cycle means the prior dirty episode -- if any --
     // is no longer stalled, so the commit-nudge budget resets alongside the
     // no-progress counter.
@@ -336,6 +186,7 @@ export async function computeCompletionFacts(ctx, deps, currentDeliveries, effec
         advancedThisCycle,
         stuck,
         updatedNoProgressCycles,
+        blockedOnDirectedEscalation,
     };
 }
 // ── Phase 5: cross-respawn delivery-advancement watchdog ────────────────
@@ -348,7 +199,14 @@ export async function computeCompletionFacts(ctx, deps, currentDeliveries, effec
  */
 export async function checkDeliveryAdvancementStall(ctx, deps, facts, action, noProgressLimit) {
     const { focusId, focusName, teamState } = ctx;
+    // A team blocked on an unanswered directed escalation must not accrue on THIS
+    // watchdog either: it is the same false-positive the primary no-progress guard
+    // avoids one layer up, and recording it would let the cross-respawn guard file
+    // its own delivery-advancement-stalled team_failure on top of the open question
+    // (criterion 3). Skip recording entirely while blocked -- the counter simply
+    // holds until the block clears.
     const shouldRecord = facts.teamHasActionableWork &&
+        !facts.blockedOnDirectedEscalation &&
         action.kind !== 'escalate_no_progress_and_terminate' &&
         (facts.priorSnapshot === null || !facts.madeProgress);
     const deliveryAdvancement = shouldRecord
@@ -541,6 +399,21 @@ export async function executeCompletionAction(ctx, deps, facts, action, noProgre
             deps.terminateTeam(focusId);
             return;
         }
+        case 'hold_blocked_on_directed_escalation': {
+            // The team is parked on its own unanswered directed escalation. Do NOT
+            // escalate (the open question is already the single signal a human sees),
+            // do NOT send a wake/handoff message (that re-engagement is the model spend
+            // this branch exists to stop), and do NOT terminate (the team resumes in
+            // place when the answer read-back re-engages it). Just commit the FROZEN
+            // no-progress counter + the fresh snapshot and fall silent -- with no
+            // message sent, the team emits no further 'complete', so the completion
+            // loop stops burning cycles until the escalation is answered.
+            teamState.noProgressCycles = updatedNoProgressCycles;
+            teamState.lastProgressSnapshot = snapshot;
+            log.info(`Team for "${focusName}" is blocked on an unanswered directed escalation ` +
+                `-- holding in place (no re-engagement, no team_failure) until it is answered.`);
+            return;
+        }
         case 'handoff_new_work':
         case 'reengage': {
             teamState.noProgressCycles = updatedNoProgressCycles;