visionclaw 0.1.218 → 0.1.219-dev.codex-issue-2805-worker-runtime.1

package/dist/agent/wake-cycle-runner.js

@@ -1,13 +1,15 @@
 /**
- * WakeCycleRunner — encapsulates the inner session-switch loop, Claude
+ * WakeCycleRunner — encapsulates the wake loop, Claude
  * stream processing, error classification / retry logic, transcript
  * sanitization, and post-cycle transcript memory indexing.
  *
  * Extracted from loop.ts so the main loop is a thin orchestrator.
  */
-import { isEmailChannel, normalizeChannelName, presentsAssistantText } from "../channels/interface.js";
+import { isEmailChannel, presentsAssistantText } from "../channels/interface.js";
 import { isCalendarInterruptMessage } from "./owner-initiated-eligibility.js";
 import { emailAddressesMatch } from "../utils/email.js";
+import { EXTERNAL_WAKE_KIND } from "../channels/queue.js";
+import { nextRecoveryPhase } from "./lifecycle-transitions.js";
 import { COMPACTION_FAILURE_CONTINUATION, CompactionFailureError } from "./compaction-failure.js";
 import { ToolOutputRepairError } from "./transcript-output-repair.js";
 import { getFallbackEngine, getLlmEffort, getLlmRetryEffort, setFallbackEngine } from "./model-provider.js";
@@ -31,36 +33,7 @@ import path from "path";
 import { randomUUID } from "node:crypto";
 import { runContextRefresh } from "./context-refresh.js";
 import { loadToolAbortRecoveryChain, saveToolAbortRecoveryChain } from "./recovery-chain.js";
-import { RECONCILE_WAIT_MS, buildThreadTaskContext, executionEvents, isTaskRelevantMessage, reconcileThreadTasks, recordExecutionEvent, } from "../threads/thread-task-runtime.js";
-import { isThreadTaskContextBlock } from "../threads/thread-task-context.js";
-/**
- * Session memos are internal working text (handoff instructions, worktree
- * paths, "do not notify" constraints). They must never be sent as owner chat.
- *
- * Last-resort ping when a coding completion was armed and this wake never
- * successfully notified (PR #839: do not silently drop the result). The
- * body is a fixed human line — never the memo, never a paraphrase of it.
- */
-async function deliverCodingCompletionFallbackPing(ownerConfig) {
-    const message = t("coding.completion_unnotified", resolveLocale(ownerConfig.language));
-    try {
-        const result = await sendUserNotification({ message, purpose: "completion" });
-        if (result.isError) {
-            const text = result.content
-                .map((c) => "text" in c ? c.text : "")
-                .filter((s) => s.length > 0)
-                .join(" ");
-            logger.warn(`Coding completion notification failed: ${text || "unknown error"}`);
-            return false;
-        }
-        logger.system("Delivered coding completion fallback ping (generic; not the session memo)");
-        return true;
-    }
-    catch (err) {
-        logger.warn(`Coding completion notification threw: ${err instanceof Error ? err.message : String(err)}`);
-        return false;
-    }
-}
+import { getWorkerExecutionRuntime } from "../threads/worker-execution-runtime.js";
 const AUTH_PATTERNS = /\b(401|402|403|authentication|billing|unauthorized|forbidden|api.?key)\b/i;
 // Fatal environment/installation problems that won't fix themselves on retry.
 // In particular: the Claude Agent SDK immediately exits with code 1 when its
@@ -303,15 +276,15 @@ export function isSharedCredentialFailure(err) {
     }
     return classifyError(err) === "provider_failed" && !isEngineScopedFailure(err);
 }
-function formatOwnerErrorNotice(category, consecutiveErrors, sleepMin, errMsg) {
+function formatOwnerErrorNotice(category, consecutiveErrors, errMsg) {
     if (category === "fatal") {
-        return `Agent encountered an internal runtime error. Sleeping ${sleepMin}m before retrying.`;
+        return "Agent encountered an internal runtime error. This wake has stopped; the next message or heartbeat will retry.";
     }
     if (category === "local") {
         // Name the cause. The old text blamed the model provider for an error the
         // provider never saw, which is what made the original alert storm
         // impossible to diagnose from the notification alone.
-        return `Agent hit a local session-coordination error (not a provider failure): ${errMsg ?? "unknown cause"}. Sleeping ${sleepMin}m before retrying.`;
+        return `Agent hit a local session-coordination error (not a provider failure): ${errMsg ?? "unknown cause"}. This wake has stopped; the next message or heartbeat will retry.`;
     }
     if (category === "request_invalid") {
         return `Agent stopped this wake because the provider rejected a malformed request (${errMsg ?? "unknown cause"}).`;
@@ -322,7 +295,7 @@ function formatOwnerErrorNotice(category, consecutiveErrors, sleepMin, errMsg) {
     if (category === "empty_turn") {
         return "The assistant returned another empty turn without confirming completion. The task may be incomplete. I stopped automatic continuation to avoid repeating work; existing results should be checked before continuing.";
     }
-    return `Agent encountered an internal model/provider error ${consecutiveErrors} times in a row. Sleeping ${sleepMin}m before retrying.`;
+    return `Agent encountered an internal model/provider error ${consecutiveErrors} times in a row. This wake has stopped; the next message or heartbeat will retry.`;
 }
 function isPromptTooLong(err) {
     const terminalReason = getTerminalReason(err);
@@ -390,7 +363,6 @@ export const MAX_EMPTY_TURN_RETRIES = 1;
 const ERROR_RETRY_COMPACT_USED_PCT = 0.7;
 const BASE_DELAY_MS = 5_000;
 const MAX_DELAY_MS = 5 * 60_000;
-const FATAL_SLEEP_MS = 5 * 60_000;
 /** Max times to retry the LLM call on stream silence timeout before aborting. */
 export const MAX_SILENCE_RETRIES = 3;
 /** Bounded retries for transient stream/network disconnects in any wake cycle. */
@@ -404,26 +376,7 @@ export const MAX_OUTPUT_RECOVERY_ATTEMPTS = 2;
 /** Escalating silence timeouts (ms) per attempt: 5min, 10min, 15min. */
 const SILENCE_TIMEOUT_SCHEDULE_MS = [300_000, 600_000, 900_000];
 /** Decreasing effort levels per attempt to reduce thinking overhead on retries. */
-const EFFORT_SCHEDULE = {
-    coding: ["xhigh", "high", "medium"],
-    general: ["xhigh", "high", "medium"],
-};
-/**
- * A wake retried on a reset session re-sends its first message, whose thread
- * task block (#1996) was built before the reset's reconcile. Swap it for a
- * fresh one so the new session sees exactly one, current copy. Without a
- * task runtime this returns the blocks unchanged.
- */
-export function withFreshThreadTaskBlock(blocks) {
-    const fresh = buildThreadTaskContext();
-    const index = blocks.findIndex((block) => block.type === "text" && isThreadTaskContextBlock(block.text));
-    if (index === -1)
-        return fresh ? [...blocks, { type: "text", text: fresh }] : blocks;
-    const rest = blocks.filter((_, i) => i !== index);
-    if (fresh)
-        rest.splice(index, 0, { type: "text", text: fresh });
-    return rest;
-}
+const EFFORT_SCHEDULE = ["xhigh", "high", "medium"];
 export class WakeCycleRunner {
     externalContextRegistry;
     deps;
@@ -435,13 +388,20 @@ export class WakeCycleRunner {
     localCoordinationErrors = 0;
     /** Empty Claude assistant turns in this wake (not counted as network failures). */
     emptyTurnRetries = 0;
+    /**
+     * Set once a call's silence ceiling is spent. Silence retries live inside
+     * the call, so the outer error handler must not spend another backoff on
+     * the same call. Cleared with the next wake.
+     */
+    silenceRecoveryExhausted = false;
+    /** Recovering only while a spendable bucket is in use. Reset when the wake ends. */
+    recoveryPhase = "Running";
     /**
      * Watchdog recoveries span multiple queue-driven wakes, so this state lives
      * on the resident runner rather than inside a single run() invocation.
      * Attempt count is retained across clean wakes that lack finish/stop so a
-     * recovery chain can actually reach MAX_TOOL_ABORT_RECOVERIES. Temporary
-     * switch_session(handoff) also retains the budget; only finish, stop, or
-     * switch_session(complete) clear it.
+     * recovery chain can actually reach MAX_TOOL_ABORT_RECOVERIES. Only finish
+     * or stop clear it.
      *
      * Ordinary threads also persist the chain, so a restart cannot refill the
      * budget. LabRun queues are process-local and stay in memory.
@@ -521,28 +481,30 @@ export class WakeCycleRunner {
         }
     }
     /**
-     * Execute one full wake cycle: the session-switch inner loop, stream
-     * processing, error recovery, and post-cycle transcript indexing.
+     * Execute one full wake cycle: the wake loop, stream processing, error
+     * recovery, and post-cycle transcript indexing.
      *
      * @param contentBlocks  The multimodal user-message blocks for this cycle.
      * @param trigger        Whether this wake was from a message or heartbeat.
      * @param messages       Inbound messages (empty for heartbeat).
-     * @param calendarSummary Calendar summary string for session-switch context.
      * @param consecutiveErrors Current error counter from previous cycles.
      * @returns Updated consecutive error count.
      */
-    async run(contentBlocks, trigger, messages, calendarSummary, consecutiveErrors) {
+    async run(contentBlocks, trigger, messages, consecutiveErrors) {
         const { config, ownerConfig, session, activityTracker, interruptHandler, messageQueue } = this.deps;
         this.malformedRequestRefreshAttempted = false;
         this.emptyTurnRetries = 0;
+        this.silenceRecoveryExhausted = false;
+        this.recoveryPhase = "Running";
         // --- Capture transcript start lines for post-cycle indexing ---
-        // A wake cycle can switch sessions, so anchor by transcript path instead
-        // of using a single start line captured from whichever session was active
-        // at cycle entry.
+        // Recovery can rotate the session to a new transcript, so anchor by
+        // transcript path instead of using a single start line captured at cycle
+        // entry.
         const wakeCycleId = generateWakeCycleId();
         /** Numbers model turns within this wake for their task-event keys. */
-        let responseSeq = 0;
         let awaitingUser = false;
+        /** The model ended the wake with an accepted finish (not a timeout or exhausted recovery). */
+        let wakeFinished = false;
         let terminalError = false;
         const wakeCycleTimestampStart = new Date().toISOString();
         const transcriptAnchors = new Map();
@@ -552,17 +514,6 @@ export class WakeCycleRunner {
             transcriptAnchors.set(activeTranscript.path, await countFileLines(activeTranscript.path));
         };
         await ensureTranscriptAnchor(resolveIndexableTranscript(session.activeSession.getTranscriptInfo(), session.activeSession.getTranscriptPath()));
-        // Session switch loop: if the agent calls switch_session, we close the
-        // current stream, switch sessions, and re-enter with a new stream.
-        let didSwitch = false;
-        let switchForwardMessage = "";
-        let pendingMemoAck = true;
-        // Armed on a coding→general completion handoff when the coding session
-        // did not notify the owner itself. The re-entered general session is
-        // expected to humanize the memo via notify_user. If this wake never
-        // successfully notifies, runtime last-resorts a fixed human ping (PR #839)
-        // — never the memo body.
-        let pendingCompletionFallback = null;
         // Survives premature-end continuations: a later turn that repeats the
         // answer as prose must not re-deliver after notify_user already landed.
         let notifyUserDeliveredThisWake = false;
@@ -573,7 +524,6 @@ export class WakeCycleRunner {
         let silenceCompactionDone = false;
         const externalContext = await this.externalContextRegistry.collect({
             trigger,
-            sessionMode: session.activeMode,
             messages,
         });
         setCurrentExternalContext(externalContext.section, externalContext.digest, externalContext.providerBlocks);
@@ -589,62 +539,18 @@ export class WakeCycleRunner {
             // failover. If the session cannot be rotated, stay on the current engine
             // and try again next wake rather than replaying its history elsewhere.
             if (recovered) {
-                if (await this.rotateSessionForEngineSwitch(session, String(activeBefore), recovered.recovered, "recovery")) {
-                    contentBlocks = withFreshThreadTaskBlock(contentBlocks);
-                }
-                else {
+                if (!await this.rotateSessionForEngineSwitch(session, String(activeBefore), recovered.recovered, "recovery")) {
                     setFallbackEngine(fallbackBefore);
                 }
             }
         }
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional infinite switch loop
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional: recovery paths re-enter via continue
         wakeLoop: while (true) {
             const activeSession = session.activeSession;
             try {
                 await activeSession.warmUp();
                 await ensureTranscriptAnchor(resolveIndexableTranscript(activeSession.getTranscriptInfo(), activeSession.getTranscriptPath()));
-                let messageContent;
-                if (didSwitch) {
-                    // Handoff boundary (#1996): fold what the previous session did into
-                    // the task checkpoints before the other session reads them. Bounded.
-                    await reconcileThreadTasks("handoff", RECONCILE_WAIT_MS.handoff);
-                    const switchMemos = session.consumeMemosForActive();
-                    const switchParts = [];
-                    switchParts.push(`[Session Switch] time=${new Date().toLocaleString()} active_session=${session.activeMode}`);
-                    if (switchMemos) {
-                        switchParts.push("");
-                        switchParts.push(switchMemos);
-                    }
-                    const codingStatus = session.getCodingSessionStatus();
-                    if (codingStatus && session.activeMode === "general") {
-                        switchParts.push("");
-                        switchParts.push(`## Active Coding Task`);
-                        switchParts.push(codingStatus);
-                    }
-                    if (calendarSummary) {
-                        switchParts.push("");
-                        switchParts.push("## Upcoming Calendar Events");
-                        switchParts.push(calendarSummary);
-                    }
-                    if (switchForwardMessage) {
-                        switchParts.push("");
-                        switchParts.push(switchForwardMessage);
-                    }
-                    // The destination session has its own context: give it the
-                    // thread's tasks as they are now.
-                    const threadTaskBlock = buildThreadTaskContext();
-                    messageContent = [
-                        { type: "text", text: switchParts.join("\n") },
-                        ...(threadTaskBlock ? [{ type: "text", text: threadTaskBlock }] : []),
-                    ];
-                    didSwitch = false;
-                    switchForwardMessage = "";
-                    pendingMemoAck = true;
-                }
-                else {
-                    messageContent =
-                        contentBlocks;
-                }
+                let messageContent = contentBlocks;
                 let streamResult = {
                     toolTimeout: null,
                     finishCalled: false,
@@ -654,6 +560,10 @@ export class WakeCycleRunner {
                     notifyUserDelivered: false,
                     awaitingUser: false,
                 };
+                // A lifecycle-only continuation may call finish without repeating the
+                // answer from the previous turn. Keep that answer through this wake.
+                let lastReplyText = "";
+                let lastReplyPresented = false;
                 let subagentContinuations = 0;
                 let prematureEndContinuations = 0;
                 // turnLoop: each iteration drains one streamed turn (including all
@@ -667,7 +577,7 @@ export class WakeCycleRunner {
                     // Retry this inner business turn only for transient stream/socket failures.
                     while (transientStreamRetries <= MAX_TRANSIENT_STREAM_RETRIES) {
                         try {
-                            for (let silenceAttempt = 1; silenceAttempt <= MAX_SILENCE_RETRIES; silenceAttempt++) {
+                            silenceLoop: for (let silenceAttempt = 1; silenceAttempt <= MAX_SILENCE_RETRIES; silenceAttempt++) {
                                 const scheduledSilenceMs = SILENCE_TIMEOUT_SCHEDULE_MS[silenceAttempt - 1] ?? SILENCE_TIMEOUT_SCHEDULE_MS[SILENCE_TIMEOUT_SCHEDULE_MS.length - 1];
                                 // Pass the scheduled bound. Pi auto-compaction starts after the
                                 // stream is already open (system/compaction_start); processAgentStream
@@ -676,23 +586,20 @@ export class WakeCycleRunner {
                                 if (silenceAttempt > 1) {
                                     activityTracker.notePublicPhase("Still working");
                                 }
-                                const effortSchedule = EFFORT_SCHEDULE[session.activeMode];
-                                const tierEffort = getLlmEffort(config, session.activeMode === "coding" ? "main_coding" : "main_general");
+                                const effortSchedule = EFFORT_SCHEDULE;
+                                const tierEffort = getLlmEffort(config, "main_general");
                                 const effort = tierEffort && silenceAttempt > 1
                                     ? getLlmRetryEffort(tierEffort, silenceAttempt - 1)
                                     : tierEffort ?? effortSchedule[silenceAttempt - 1];
                                 const queryStream = activeSession.sendAndStream(messageContent, { effort, externalContextDigest: externalContext.digest });
-                                if (pendingMemoAck) {
-                                    session.ackMemosForActive();
-                                    pendingMemoAck = false;
-                                }
                                 try {
-                                    streamResult = await processAgentStream(queryStream, activeSession, activityTracker, session.dualSessionEnabled ? session : undefined, config, silenceTimeoutMs);
+                                    streamResult = await processAgentStream(queryStream, activeSession, activityTracker, config, silenceTimeoutMs);
                                     if (streamResult.notifyUserDelivered)
                                         notifyUserDeliveredThisWake = true;
-                                    // One event per model turn with its complete prose; the task
-                                    // sidecar folds it into progress. No-op without a task runtime.
-                                    recordExecutionEvent(executionEvents.response(`${wakeCycleId}:${responseSeq++}`, streamResult.assistantText));
+                                    if (streamResult.lastAssistantText) {
+                                        lastReplyText = streamResult.lastAssistantText;
+                                        lastReplyPresented = streamResult.lastAssistantTextPresented === true;
+                                    }
                                     // A successful SDK envelope can still contain a legitimate empty
                                     // model turn. Apply the same task-state policy as SDK diagnostics.
                                     if (!this.deps.singleShot && streamResult.emptyTurn && !streamResult.finishCalled && !streamResult.toolTimeout) {
@@ -733,22 +640,37 @@ export class WakeCycleRunner {
                                                 `skipping the remaining ${MAX_SILENCE_RETRIES - silenceAttempt} silence retries`);
                                         }
                                     }
-                                    if (silenceAttempt < MAX_SILENCE_RETRIES && engineAnswersProbe) {
+                                    // silenceAttempt counts the tries already made in this call. A dead
+                                    // engine does not get the remaining ones: that is Stopping, not
+                                    // another Recovering retry.
+                                    const silencePhase = nextRecoveryPhase({
+                                        from: this.recoveryPhase,
+                                        bucket: "silence",
+                                        spent: engineAnswersProbe ? silenceAttempt : MAX_SILENCE_RETRIES,
+                                    });
+                                    if (silencePhase === "Recovering")
+                                        this.recoveryPhase = "Recovering";
+                                    if (silencePhase === "Recovering" && engineAnswersProbe) {
                                         const nextTimeoutMs = SILENCE_TIMEOUT_SCHEDULE_MS[silenceAttempt] ?? SILENCE_TIMEOUT_SCHEDULE_MS[SILENCE_TIMEOUT_SCHEDULE_MS.length - 1];
                                         const nextEffort = tierEffort
                                             ? getLlmRetryEffort(tierEffort, silenceAttempt)
                                             : effortSchedule[silenceAttempt];
                                         logger.system(`Stream silence timeout after ${silenceTimeoutMs / 1000}s (attempt ${silenceAttempt}/${MAX_SILENCE_RETRIES}) — engine still answering, retrying LLM call with ${nextTimeoutMs / 1000}s timeout and effort=${nextEffort}...`);
-                                        // Re-send the same messageContent on next iteration
-                                        continue;
+                                        // Re-send the same messageContent on the next attempt of this call.
+                                        continue silenceLoop;
                                     }
                                     // Retries exhausted, or cut short because the engine failed its
-                                    // health probe.
+                                    // health probe. Both are Stopping for this call. A hot engine
+                                    // switch or a successful compaction below continues this wake, so
+                                    // the outer handler is only blocked once this call is actually
+                                    // abandoned.
                                     logger.err(engineAnswersProbe
                                         ? `Stream silence timeout: all ${MAX_SILENCE_RETRIES} attempts exhausted — aborting`
                                         : `Stream silence timeout on attempt ${silenceAttempt}/${MAX_SILENCE_RETRIES} with a failed health probe — aborting`);
-                                    if (this.deps.singleShot)
+                                    if (this.deps.singleShot) {
+                                        this.silenceRecoveryExhausted = true;
                                         throw streamErr;
+                                    }
                                     const locale = resolveLocale(ownerConfig.language);
                                     // Report what actually happened: a probe-driven short circuit may
                                     // have spent only one of the three attempts, and telling the owner
@@ -765,7 +687,6 @@ export class WakeCycleRunner {
                                     const degraded = await this.degradeActiveEngine(engineFallback, "silence_exhausted", session);
                                     if (degraded === "hot") {
                                         consecutiveErrors = 0;
-                                        contentBlocks = withFreshThreadTaskBlock(contentBlocks);
                                         continue wakeLoop;
                                     }
                                     if (degraded === "restarting") {
@@ -784,9 +705,6 @@ export class WakeCycleRunner {
                                         try {
                                             await activeSession.requestCompaction();
                                             consecutiveErrors = 0;
-                                            // The compacted session must see the tasks as the compaction
-                                            // reconcile just left them, not the wake-start block (#1996).
-                                            contentBlocks = withFreshThreadTaskBlock(contentBlocks);
                                             continue wakeLoop;
                                         }
                                         catch (compactErr) {
@@ -803,6 +721,7 @@ export class WakeCycleRunner {
                                         ...taskContinuationRouting(this.deps.agentState.currentTaskReplyTarget),
                                     });
                                     logger.system("Enqueued interrupted-task recovery message for next wake cycle");
+                                    this.silenceRecoveryExhausted = true;
                                     throw streamErr; // propagate so the outer handler records the error
                                 }
                             }
@@ -810,7 +729,18 @@ export class WakeCycleRunner {
                         }
                         catch (streamErr) {
                             // TODO: guard retry against simultaneous stop requests and settle the failed input generator before retrying; both are rare stream/stop races.
-                            if (isTransientStreamFailure(streamErr) && transientStreamRetries < MAX_TRANSIENT_STREAM_RETRIES) {
+                            // transientStreamRetries counts the disconnects already retried in
+                            // this turn. Another one is Recovering; the ceiling throws, and
+                            // the outer handler records it instead of retrying this turn.
+                            const networkPhase = isTransientStreamFailure(streamErr)
+                                ? nextRecoveryPhase({
+                                    from: this.recoveryPhase,
+                                    bucket: "network",
+                                    spent: transientStreamRetries,
+                                })
+                                : null;
+                            if (networkPhase === "Recovering") {
+                                this.recoveryPhase = "Recovering";
                                 transientStreamRetries++;
                                 logger.system(`Transient stream failure (retry ${transientStreamRetries}/${MAX_TRANSIENT_STREAM_RETRIES}) — retrying the current business turn...`);
                                 continue;
@@ -818,30 +748,10 @@ export class WakeCycleRunner {
                             throw streamErr;
                         }
                     }
-                    // An owner-facing notification was DELIVERED this turn — any armed
-                    // coding completion fallback has been superseded by the model's own
-                    // summary. A notify_user call whose tool result errored (channel
-                    // outage, bad explicit target) must not disarm the fallback, or the
-                    // completion is silently lost.
-                    if (streamResult.notifyUserDelivered) {
-                        pendingCompletionFallback = null;
-                    }
                     if (streamResult.finishCalled && streamResult.awaitingUser)
                         awaitingUser = true;
-                    // The coding prompt asks the model to switch back with
-                    // reason="complete", but the generic finish tool is also available
-                    // and can be used after a successful completion notification. In
-                    // that case finish only closes the wake at the stream layer; finalize
-                    // the task here when the receipt is for this exact active task so a
-                    // later general heartbeat cannot resurrect it.
-                    const completionReceiptMatchesActiveCodingTask = session.activeMode === "coding" &&
-                        !session.pendingSwitch &&
-                        !streamResult.awaitingUser &&
-                        Boolean(this.deps.agentState.codingCompletionTaskStartedAt &&
-                            this.deps.agentState.codingCompletionTaskStartedAt === session.getActiveCodingTaskStartedAt());
-                    if (streamResult.finishCalled && completionReceiptMatchesActiveCodingTask) {
-                        session.finalizeCodingCompletionAfterFinish();
-                    }
+                    if (streamResult.finishCalled)
+                        wakeFinished = true;
                     // A watchdog abort is scoped to the active tool. Preserve the result
                     // for the next queue-driven wake rather than resuming the same provider
                     // turn, which keeps lifecycle handling identical for Claude and Pi.
@@ -899,7 +809,7 @@ export class WakeCycleRunner {
                     }
                     // A successful SDK result only means the stream ended; it does not
                     // prove the task ended intentionally. Keep the original wake context
-                    // alive until the model calls finish or requests a session switch.
+                    // alive until the model calls finish.
                     // Gated on "no subagents currently active" (not on whether a subagent
                     // continuation ever fired): while subagents run, the subagent-wait
                     // mechanism above owns the turn; once they are done, the explicit
@@ -907,22 +817,30 @@ export class WakeCycleRunner {
                     // subagent continuation earlier.
                     if (!this.deps.singleShot &&
                         endedWithoutLifecycleAction &&
-                        !session.pendingSwitch &&
                         runningSubagents.length === 0) {
-                        if (prematureEndContinuations < MAX_PREMATURE_END_CONTINUATIONS) {
+                        // prematureEndContinuations counts the continuations already sent in
+                        // this wake. One more is Recovering; the ceiling is Stopping, and
+                        // this wake ends instead of starting another continuation.
+                        const prematurePhase = nextRecoveryPhase({
+                            from: this.recoveryPhase,
+                            bucket: "premature_result",
+                            spent: prematureEndContinuations,
+                        });
+                        if (prematurePhase === "Recovering") {
+                            this.recoveryPhase = "Recovering";
                             prematureEndContinuations++;
-                            logger.warn(`Turn ended without finish or switch_session — continuing in ${session.activeMode} session (${prematureEndContinuations}/${MAX_PREMATURE_END_CONTINUATIONS})`);
+                            logger.warn(`Turn ended without finish — continuing (${prematureEndContinuations}/${MAX_PREMATURE_END_CONTINUATIONS})`);
                             messageContent = [{
                                     type: "text",
                                     text: [
-                                        "Your previous turn ended without an explicit finish or switch_session call, so this wake cycle is still active.",
+                                        "Your previous turn ended without an explicit finish call, so this wake cycle is still active.",
                                         "Inspect the transcript and existing tool results before acting. Do not repeat successful notifications, emails, uploads, or other mutations/side effects.",
-                                        "If the requested work is already complete, only call finish now. Otherwise complete the remaining work, notify the user if needed, then call finish or switch_session as appropriate.",
+                                        "If the requested work is already complete, only call finish now. Otherwise complete the remaining work, notify the user if needed, then call finish.",
                                     ].join("\n"),
                                 }];
                             continue turnLoop;
                         }
-                        const errorMessage = `Wake cycle ended without finish or switch_session after ${MAX_PREMATURE_END_CONTINUATIONS} continuations`;
+                        const errorMessage = `Wake cycle ended without finish after ${MAX_PREMATURE_END_CONTINUATIONS} continuations`;
                         logger.err(errorMessage);
                         // The alert is only actionable when the owner is actually waiting on
                         // something, and it fires at most once per wake cycle — so a long run
@@ -943,7 +861,7 @@ export class WakeCycleRunner {
                         const alreadyNotifiedOwner = this.deps.agentState.notifiedUserThisWake === true;
                         const recoveryAlertEligible = trigger === "message" && !alreadyNotifiedOwner;
                         if (recoveryAlertEligible) {
-                            void notifyOwner(`Agent wake recovery stopped after ${MAX_PREMATURE_END_CONTINUATIONS} attempts in the ${session.activeMode} session. The task may be incomplete; please ask me to resume it.`, config).catch((notifyErr) => {
+                            void notifyOwner(`Agent wake recovery stopped after ${MAX_PREMATURE_END_CONTINUATIONS} attempts. The task may be incomplete; please ask me to resume it.`, config).catch((notifyErr) => {
                                 logger.warn(`Failed to notify owner about exhausted wake recovery: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
                             });
                         }
@@ -976,9 +894,18 @@ export class WakeCycleRunner {
                         }
                     }
                     else {
+                        // The persisted count is this chain's own budget. It survives
+                        // wakes and restarts, so a new wake must not refill it.
+                        const toolAbortPhase = nextRecoveryPhase({
+                            from: this.recoveryPhase,
+                            bucket: "tool_abort",
+                            spent: this.toolAbortRecoveries,
+                        });
                         this.toolAbortRecoveryChainId ??= randomUUID();
                         this.toolAbortRecoveries += 1;
-                        const retryable = this.toolAbortRecoveries <= MAX_TOOL_ABORT_RECOVERIES;
+                        const retryable = toolAbortPhase === "Recovering";
+                        if (retryable)
+                            this.recoveryPhase = "Recovering";
                         if (!retryable)
                             this.toolAbortRecoveryExhausted = true;
                         this.persistToolAbortRecoveryChain();
@@ -1020,12 +947,7 @@ export class WakeCycleRunner {
                     this.clearToolAbortRecoveryBudget();
                 }
                 else if (streamResult.finishCalled) {
-                    // `finishCalled` is also set for accepted switch_session. Temporary
-                    // handoffs must retain the budget; only a real finish tool clears
-                    // here. switch_session(complete) clears below via reason.
-                    if (streamResult.lifecycleTool !== "switch_session") {
-                        this.clearToolAbortRecoveryBudget();
-                    }
+                    this.clearToolAbortRecoveryBudget();
                 }
                 // --- Direct assistant text delivery ---
                 // When the model writes the answer as prose, calls finish, and never
@@ -1033,44 +955,34 @@ export class WakeCycleRunner {
                 // adapters drop `assistant_text`). Send the LAST text block as a
                 // normal notify so the originating channel actually delivers it.
                 // Concatenated earlier blocks, thinking, and tool narration stay out.
-                // Heartbeat, switch_session, singleShot, and toolTimeout stay silent.
+                // Heartbeat, singleShot, and toolTimeout stay silent.
                 // Fin-App matches Telegram: live assistant_text is dropped, so this
                 // last-block notify is the courtesy delivery when finish has no
                 // notify_user. TUI still presents assistant_text in-thread.
-                const fallbackText = streamResult.lastAssistantText;
-                // An accepted switch_session always leaves a pending request here --
-                // `executePendingSwitch` only runs later in this wake -- so
-                // `pendingSwitch` already covers that exit on its own. Requiring an
-                // accepted `finish` below excludes it a second time.
-                const skipBecauseSwitch = Boolean(session.pendingSwitch);
+                const fallbackText = lastReplyText;
                 const skipBecauseNotified = notifyUserDeliveredThisWake || streamResult.notifyUserDelivered;
                 const finishAccepted = streamResult.lifecycleTool === "finish";
                 // Only replies to messages in the initial wake batch are eligible.
                 // Resumes, external wakes and calendars may carry a delivery target
                 // without requesting a reply. Mid-turn work uses explicit notify_user
                 // for its result; a quick acknowledgment does not enable this fallback.
-                const replyMessages = messages.filter((message) => isTaskRelevantMessage(message) && !isCalendarInterruptMessage(message));
+                const replyMessages = messages.filter((message) => message.channel !== "system" && message.meta?.kind !== EXTERNAL_WAKE_KIND && !isCalendarInterruptMessage(message));
                 const fallbackEligible = !this.deps.singleShot &&
                     !streamResult.toolTimeout &&
                     !skipBecauseNotified &&
                     fallbackText.length > 0 &&
                     trigger === "message" &&
                     finishAccepted &&
-                    !skipBecauseSwitch &&
                     replyMessages.length > 0;
                 if (replyMessages.length === 0 && fallbackText.length > 0 && finishAccepted && !skipBecauseNotified) {
                     logger.info("Skipped finish-without-notify fallback: no reply message in the initial wake batch");
                 }
-                if (skipBecauseSwitch && fallbackText.length > 0 && trigger === "message") {
-                    logger.warn(`Skipped assistant_text delivery: the turn took switch_session without notify_user, so this text was NOT delivered to the owner: ${fallbackText.slice(0, 2000)}`);
-                }
                 // Premature-end recovery re-prompts, so unfinished prose is deliberately
                 // not delivered (a rejected `finish` lands here too: it sets neither
                 // `finishCalled` nor `lifecycleTool`). The owner still gets the generic
                 // exhausted-recovery alert, but the text itself would vanish without a
                 // trace -- record it so the drop is diagnosable.
                 if (!finishAccepted &&
-                    !skipBecauseSwitch &&
                     !skipBecauseNotified &&
                     !streamResult.toolTimeout &&
                     fallbackText.length > 0 &&
@@ -1080,16 +992,10 @@ export class WakeCycleRunner {
                 if (fallbackEligible) {
                     const fallbackTarget = resolveDirectAssistantFallbackTarget(replyMessages, ownerConfig.ownerEmail);
                     const livePresentedOnChat = Boolean(fallbackTarget && presentsAssistantText(fallbackTarget.channel)) &&
-                        streamResult.lastAssistantTextPresented === true;
+                        lastReplyPresented;
                     if (livePresentedOnChat) {
                         // Last live block actually landed in chat. Do not splice a
                         // second last-block notify into the same thread.
-                        pendingCompletionFallback = null;
-                    }
-                    else if (fallbackTarget &&
-                        normalizeChannelName(fallbackTarget.channel) === "finapp" &&
-                        session.activeMode === "coding") {
-                        // Coding narration never becomes a Fin-App chat bubble. TUI still last-block notifies.
                     }
                     else if (fallbackTarget) {
                         // Best-effort courtesy delivery: never let a fallback failure
@@ -1111,7 +1017,6 @@ export class WakeCycleRunner {
                             }
                             else {
                                 logger.warn(`Delivered finish-without-notify fallback via ${fallbackTarget.channel} to ${fallbackTarget.to}`);
-                                pendingCompletionFallback = null;
                             }
                         }
                         catch (err) {
@@ -1180,46 +1085,6 @@ export class WakeCycleRunner {
                         logger.warn(`Post-query compaction failed: ${compactErr instanceof Error ? compactErr.message : String(compactErr)}`);
                     }
                 }
-                const switchResult = session.executePendingSwitch();
-                if (switchResult) {
-                    // switch_session sets finishCalled, so the finishCalled branch above
-                    // skips clearing when lifecycleTool is switch_session. Only complete
-                    // clears here; temporary handoff retains the budget.
-                    if (switchResult.reason === "complete") {
-                        this.clearToolAbortRecoveryBudget();
-                    }
-                    didSwitch = true;
-                    switchForwardMessage = [switchResult.workspaceNotice, switchResult.forwardMessage]
-                        .filter(Boolean)
-                        .join("\n\n");
-                    // Completion handoffs are user-visible outcomes. The re-entered
-                    // general session is expected to humanize the memo via notify_user.
-                    // Do not dump the memo as chat (internal working text). Arm a marker:
-                    // a later notify_user / last-block send disarms it; if the cycle
-                    // ends with no successful owner ping, last-resort a fixed human line
-                    // (PR #839: do not silently drop the result). Newest memo wins.
-                    if (switchResult.target === "general" &&
-                        switchResult.ownerNotificationRequired &&
-                        switchResult.completionMemo) {
-                        pendingCompletionFallback = switchResult.completionMemo;
-                    }
-                    // Coding already sent this task's final result. No memo was created,
-                    // so end the wake instead of invoking general for a duplicate summary.
-                    if (switchResult.target === "general" &&
-                        switchResult.ownerNotificationRequired === false &&
-                        switchResult.completionMemo) {
-                        // reason="complete" already cleared the recovery budget above.
-                        logger.system("Coding completion already delivered — ending wake without re-entering general");
-                        this.deps.engineFallback.noteEngineSuccess();
-                        this.invalidJsonBodyRecoveryCount = 0;
-                        this.localCoordinationErrors = 0;
-                        this.emptyTurnRetries = 0;
-                        consecutiveErrors = 0;
-                        break;
-                    }
-                    logger.system(`Re-entering wake cycle for ${switchResult.target} session`);
-                    continue;
-                }
                 this.deps.engineFallback.noteEngineSuccess();
                 this.invalidJsonBodyRecoveryCount = 0;
                 this.localCoordinationErrors = 0;
@@ -1245,23 +1110,14 @@ export class WakeCycleRunner {
                     if (errorResult.kind === "continue_with_message") {
                         consecutiveErrors = errorResult.consecutiveErrors;
                         contentBlocks = [{ type: "text", text: errorResult.message }];
-                        // A rebuilt session starts without the thread's tasks (#1996).
-                        if (errorResult.newSession)
-                            contentBlocks = withFreshThreadTaskBlock(contentBlocks);
-                        didSwitch = false;
-                        switchForwardMessage = "";
                         continue;
                     }
                     if (errorResult.kind === "continue_with_reset") {
                         consecutiveErrors = 0;
-                        contentBlocks = withFreshThreadTaskBlock(contentBlocks);
                         continue;
                     }
                     if (errorResult.kind === "continue_preserve_count") {
                         consecutiveErrors = errorResult.consecutiveErrors;
-                        // Invalid-json recovery may have compacted (#1996): resend the
-                        // current task block. A no-op when nothing changed.
-                        contentBlocks = withFreshThreadTaskBlock(contentBlocks);
                         continue;
                     }
                     consecutiveErrors = errorResult.consecutiveErrors;
@@ -1269,17 +1125,7 @@ export class WakeCycleRunner {
                 }
             }
             break;
-        } // end switch loop
-        // --- Coding completion last-resort ping (PR #839) ---
-        // The wake cycle is over and no owner notification superseded the armed
-        // completion (general silent, errored, or stopped). Send a fixed human
-        // line so the result is not silently lost. Never send the session memo
-        // (handoff instructions, paths, do-not-notify constraints).
-        if (pendingCompletionFallback) {
-            logger.warn("Wake cycle ended without an owner notification for a coding completion — sending a generic ping, not the session memo");
-            await deliverCodingCompletionFallbackPing(ownerConfig);
-            pendingCompletionFallback = null;
-        }
+        } // end wake loop
         // --- Post-wake-cycle transcript indexing (best-effort) ---
         // Usage reports are no longer enqueued immediately here. Instead,
         // indexWakeCycle extracts and stores tool call facts, and the background
@@ -1293,9 +1139,7 @@ export class WakeCycleRunner {
         const wakeCycleOutcome = session.isStopRequested()
             ? "stopped"
             : !terminalError && consecutiveErrors === 0
-                ? didSwitch
-                    ? "switched"
-                    : "completed"
+                ? "completed"
                 : "error";
         // Always index wake cycles — including stopped/error cycles — so that
         // usage metering is consistent for all cycles. The outcome field records
@@ -1304,7 +1148,7 @@ export class WakeCycleRunner {
             const wakeCycleEndLine = await countFileLines(postCycleTranscript.path);
             void indexWakeCycle({
                 wakeCycleId,
-                sessionType: session.activeMode,
+                sessionType: "general",
                 sourceFile: postCycleTranscript.path,
                 sourceFormat: postCycleTranscript.format,
                 startLine: postCycleStartLine,
@@ -1330,10 +1174,11 @@ export class WakeCycleRunner {
                 : awaitingUser
                     ? "waiting_user"
                     : "completed",
+            finished: wakeFinished,
         };
     }
     /**
-     * Handle an error from the session switch loop. Returns:
+     * Handle an error from the wake loop. Returns:
      *  - `continue_with_reset` for recovery paths that should retry immediately
      *    with a clean error counter (compaction/sanitization succeeded)
      *  - `continue_preserve_count` for normal retryable failures that should
@@ -1352,6 +1197,12 @@ export class WakeCycleRunner {
             logger.system(err.message);
             return { kind: "done", consecutiveErrors };
         }
+        if (this.silenceRecoveryExhausted) {
+            // The call already spent its own silence ceiling and moved to Stopping.
+            // Another backoff here would replay that call instead of ending it.
+            logger.system("Stream silence ceiling already spent — ending this wake cycle");
+            return { kind: "done", consecutiveErrors: consecutiveErrors + 1 };
+        }
         const errMsg = err instanceof Error ? err.message : String(err);
         const category = classifyError(err);
         // A local coordination error never reached a provider, so it must not
@@ -1369,6 +1220,8 @@ export class WakeCycleRunner {
         // terminal facts for this run, not a reason to start conversational
         // recovery, notify the owner directly, sleep, or enqueue another wake.
         if (this.deps.singleShot) {
+            // Kept for the failure report, so the caller sees the cause.
+            getWorkerExecutionRuntime()?.noteError(errMsg);
             return { kind: "done", consecutiveErrors };
         }
         if (err instanceof CompactionFailureError ||
@@ -1430,7 +1283,6 @@ export class WakeCycleRunner {
                 message: `${config.agentName}: invalid Pi session could not be reset`,
                 details: {
                     code: "INVALID_PI_SESSION_RECOVERY_FAILED",
-                    activeSession: session.activeMode,
                     sessionId: invalidSessionId ?? "unknown",
                     provider: config.provider,
                     model: reportedModel(config),
@@ -1493,7 +1345,6 @@ export class WakeCycleRunner {
                 message: `${config.agentName}: stale session could not be reset`,
                 details: {
                     code: "SESSION_NOT_FOUND_RECOVERY_FAILED",
-                    activeSession: session.activeMode,
                     sessionId: deadSessionId ?? "unknown",
                     provider: config.provider,
                     model: reportedModel(config),
@@ -1580,7 +1431,7 @@ export class WakeCycleRunner {
             }
             if (recoveryCount === 2) {
                 const oldSessionId = session.activeSession.getSessionId();
-                logger.warn(`Invalid JSON body repeated after compaction; resetting ${session.activeSession.mode} session before retry`);
+                logger.warn("Invalid JSON body repeated after compaction; resetting session before retry");
                 session.activeSession.resetForNewSession("Previous session was reset automatically after repeated provider `400 Invalid JSON body` errors. " +
                     "This usually means the provider rejected the context/payload even after compaction. Continue from memory and the current user request; avoid reloading large prior tool outputs unless needed.");
                 logger.system(`Invalid-json-body recovery reset session: old=${oldSessionId ?? "unknown"} new=${session.activeSession.getSessionId() ?? "pending"}`);
@@ -1595,7 +1446,6 @@ export class WakeCycleRunner {
                     code: "INVALID_JSON_BODY_RECOVERY_FAILED",
                     consecutiveInvalidJsonBodyErrors: recoveryCount,
                     actionsAttempted: ["compaction", "session_reset", "controlled_restart"],
-                    activeSession: session.activeSession.mode,
                     provider: config.provider,
                     model: reportedModel(config),
                 },
@@ -1620,16 +1470,15 @@ export class WakeCycleRunner {
                 return { kind: "continue_preserve_count", consecutiveErrors };
             }
             // Retries exhausted: tell the owner what actually broke, naming the
-            // local cause instead of blaming the model provider.
-            const sleepMin = FATAL_SLEEP_MS / 60_000;
+            // local cause instead of blaming the model provider. The wake ends here.
+            // Sleeping would keep the foreground slot busy until the timer fired.
             logger.warn(`Notifying owner about persistent local coordination error: ${errMsg}`);
             try {
-                await notifyOwner(formatOwnerErrorNotice(category, consecutiveErrors, sleepMin, errMsg), config);
+                await notifyOwner(formatOwnerErrorNotice(category, consecutiveErrors, errMsg), config);
             }
             catch (notifyErr) {
                 logger.warn(`Failed to send error notification to owner: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
             }
-            await new Promise((r) => setTimeout(r, FATAL_SLEEP_MS));
             return { kind: "done", consecutiveErrors };
         }
         // --- Known malformed Responses replay ---
@@ -1668,7 +1517,7 @@ export class WakeCycleRunner {
             }
             logger.err(`Malformed Responses replay recovery failed — ending wake: ${errMsg}`);
             try {
-                await notifyOwner(formatOwnerErrorNotice(category, consecutiveErrors, 0, errMsg), config);
+                await notifyOwner(formatOwnerErrorNotice(category, consecutiveErrors, errMsg), config);
             }
             catch (notifyErr) {
                 logger.warn(`Failed to send error notification to owner: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
@@ -1680,10 +1529,7 @@ export class WakeCycleRunner {
         // whether this wake has work that still needs an explicit resolution.
         if (category === "empty_turn") {
             const { activityTracker, interruptHandler } = this.deps;
-            const hasPendingWork = activityTracker.getTodos().some((todo) => todo.status === "pending" || todo.status === "in_progress") || activityTracker.getActiveSubagents().length > 0
-                // Paused tasks persist across wakes; they do not make an otherwise
-                // idle heartbeat responsible for resuming coding work.
-                || session.getCodingSessionState() === "in_progress";
+            const hasPendingWork = activityTracker.getTodos().some((todo) => todo.status === "pending" || todo.status === "in_progress") || activityTracker.getActiveSubagents().length > 0;
             const idleHeartbeat = wake.trigger === "heartbeat"
                 && wake.messages.length === 0
                 && !interruptHandler.hasAcceptedWorkThisCycle()
@@ -1692,39 +1538,45 @@ export class WakeCycleRunner {
                 logger.system("Empty assistant turn on an idle heartbeat — ending normally without retry");
                 return { kind: "completed", consecutiveErrors: 0 };
             }
-            this.emptyTurnRetries++;
-            if (this.emptyTurnRetries <= MAX_EMPTY_TURN_RETRIES) {
-                const message = [
-                    "Your previous turn ended with no additional content. This alone does not indicate whether the task is complete.",
-                    "Review the current request, task state, and existing tool results before acting. Do not repeat successful notifications, emails, uploads, or other side effects.",
-                    "If no work remains, only call finish (or switch_session for a required handoff). Otherwise continue only the unfinished work, wait for running subagents as needed, then finish.",
-                    "If completion cannot be verified or user input is needed, explain what remains uncertain to the user and call finish(awaiting_user=true).",
-                ].join("\n");
-                logger.system("Empty assistant turn with unresolved work — sending one explicit continuation");
-                // Context pressure is independent of the empty response. Only compact
-                // when the usage snapshot warrants it, and retain bounded recovery.
+            const phase = nextRecoveryPhase({
+                from: this.recoveryPhase,
+                bucket: "empty_turn",
+                spent: this.emptyTurnRetries,
+            });
+            if (phase === "Stopping") {
+                logger.warn(`Empty-turn continuation did not confirm task completion: ${errMsg}`);
                 try {
-                    await this.compactBeforeErrorRetry(session, "empty-turn continuation");
+                    await notifyOwner(formatOwnerErrorNotice(category, this.emptyTurnRetries, errMsg), config);
                 }
-                catch (compactErr) {
-                    if (!(compactErr instanceof CompactionFailureError))
-                        throw compactErr;
-                    const recovery = await this.recoverOversizedContext(compactErr, session, consecutiveErrors);
-                    if (recovery.kind !== "continue_with_reset")
-                        return recovery;
-                    // The session was rebuilt: it has no task block in its history.
-                    return { kind: "continue_with_message", consecutiveErrors: 0, message, newSession: true };
+                catch (notifyErr) {
+                    logger.warn(`Failed to send empty-turn notification to owner: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
                 }
-                return { kind: "continue_with_message", consecutiveErrors, message };
+                return { kind: "done", consecutiveErrors };
             }
-            logger.warn(`Empty-turn continuation did not confirm task completion: ${errMsg}`);
+            this.recoveryPhase = "Recovering";
+            this.emptyTurnRetries++;
+            const message = [
+                "Your previous turn ended with no additional content. This alone does not indicate whether the task is complete.",
+                "Review the current request, task state, and existing tool results before acting. Do not repeat successful notifications, emails, uploads, or other side effects.",
+                "If no work remains, only call finish. Otherwise continue only the unfinished work, wait for running subagents as needed, then finish.",
+                "If completion cannot be verified or user input is needed, explain what remains uncertain to the user and call finish(awaiting_user=true).",
+            ].join("\n");
+            logger.system("Empty assistant turn with unresolved work — sending one explicit continuation");
+            // Context pressure is independent of the empty response. Only compact
+            // when the usage snapshot warrants it, and retain bounded recovery.
             try {
-                await notifyOwner(formatOwnerErrorNotice(category, this.emptyTurnRetries, 0, errMsg), config);
+                await this.compactBeforeErrorRetry(session, "empty-turn continuation");
             }
-            catch (notifyErr) {
-                logger.warn(`Failed to send empty-turn notification to owner: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
+            catch (compactErr) {
+                if (!(compactErr instanceof CompactionFailureError))
+                    throw compactErr;
+                const recovery = await this.recoverOversizedContext(compactErr, session, consecutiveErrors);
+                if (recovery.kind !== "continue_with_reset")
+                    return recovery;
+                // The session was rebuilt: it has no task block in its history.
+                return { kind: "continue_with_message", consecutiveErrors: 0, message, newSession: true };
             }
-            return { kind: "done", consecutiveErrors };
+            return { kind: "continue_with_message", consecutiveErrors, message };
         }
         // --- Engine fallback (issue #2519) ---
         // Engine-scoped failures cool the engine down and move on; failures of the
@@ -1763,10 +1615,22 @@ export class WakeCycleRunner {
                 logger.system("No alternate engine available for transient network failures; keeping consecutiveErrors and the cooldown");
             }
         }
-        if (category === "fatal" ||
-            consecutiveErrors >= MAX_RETRIES_BEFORE_NOTIFY) {
-            const sleepMin = FATAL_SLEEP_MS / 60_000;
-            const notice = formatOwnerErrorNotice(category, consecutiveErrors, sleepMin);
+        // consecutiveErrors counts the failures already seen in this wake. The
+        // notify threshold is the unknown bucket, not the network disconnect
+        // ceiling. Reaching it is Stopping: notify, then end the wake. The next
+        // attempt waits for a queued message or the proactive timer, not a sleep
+        // that holds this slot.
+        const unknownPhase = category === "fatal"
+            ? "Stopping"
+            : nextRecoveryPhase({
+                from: this.recoveryPhase,
+                bucket: "unknown",
+                spent: consecutiveErrors,
+            });
+        if (unknownPhase === "Recovering")
+            this.recoveryPhase = "Recovering";
+        if (unknownPhase === "Stopping") {
+            const notice = formatOwnerErrorNotice(category, consecutiveErrors);
             logger.warn(`Notifying owner about repeated agent error: ${errMsg}`);
             try {
                 await notifyOwner(notice, config);
@@ -1775,7 +1639,6 @@ export class WakeCycleRunner {
                 logger.warn(`Failed to send error notification to owner: ${notifyErr instanceof Error ? notifyErr.message : String(notifyErr)}`);
             }
             consecutiveErrors = 0;
-            await new Promise((r) => setTimeout(r, FATAL_SLEEP_MS));
         }
         else {
             try {
@@ -1815,8 +1678,8 @@ export class WakeCycleRunner {
             return;
         }
         // Between the failed `/compact` and the end of the cycle the session may
-        // have been switched (coding <-> general) or already rotated by the error
-        // path. Only rotate the session that actually failed to compact.
+        // have already been rotated by the error path. Only rotate the session
+        // that actually failed to compact.
         if (pending.sessionId === null || session.activeSession.getSessionId() !== pending.sessionId) {
             logger.system(`Post-query compaction failed terminally (${err.errorCode}) but the active session changed before the cycle ended; leaving rotation to the next check`);
             return;
@@ -1854,8 +1717,15 @@ export class WakeCycleRunner {
         // Two recovery turns total: repair, then one refresh. The second branch is
         // gated by the ceiling, so raising MAX_OUTPUT_RECOVERY_ATTEMPTS is what
         // allows another turn. Advancing before I/O keeps a failed repair from
-        // resetting the allowance.
-        if (attempts[recoveryKind] === 0) {
+        // resetting the allowance. The two kinds keep separate counts.
+        const outputPhase = nextRecoveryPhase({
+            from: this.recoveryPhase,
+            bucket: recoveryKind === "policy_refused" ? "policy_refusal" : "oversized",
+            spent: attempts[recoveryKind],
+        });
+        if (outputPhase === "Recovering")
+            this.recoveryPhase = "Recovering";
+        if (attempts[recoveryKind] === 0 && outputPhase === "Recovering") {
             attempts[recoveryKind]++;
             if (!compactionAlreadyFailed) {
                 try {
@@ -1874,7 +1744,7 @@ export class WakeCycleRunner {
                 logger.system("SDK auto-compaction already failed — skipping same-session transcript repair and rotating context");
             }
         }
-        if (attempts[recoveryKind] < MAX_OUTPUT_RECOVERY_ATTEMPTS) {
+        if (attempts[recoveryKind] < MAX_OUTPUT_RECOVERY_ATTEMPTS && outputPhase === "Recovering") {
             attempts[recoveryKind]++;
             const previousId = session.activeSession.getSessionId();
             try {