visionclaw 0.1.219-dev.codex-issue-2805-worker-runtime.3 → 0.1.219-dev.codex-fix-2941-activity-foreground.1

package/dist/agent/loop.js

@@ -5,7 +5,7 @@
  * sleep/wake loop. Each concern is delegated to a focused module:
  *
  *  - HeartbeatManager:  runtime heartbeat lifecycle
- *  - ReplyWatchdog:     deterministic acknowledgment and handoff pressure timer
+ *  - ReplyWatchdog:     fast-responder fallback timer
  *  - WakeCycleRunner:   wake loop, stream processing, error retry,
  *                       transcript indexing
  *  - InterruptHandler:  mid-turn message injection
@@ -13,11 +13,11 @@
  *  - ChannelManager:    messaging channel adapters
  */
 import { createDefaultExternalContextRegistry, ExternalContextRegistry } from "./external-context/registry.js";
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { beginLifecycleRun, createLifecycleRunId, deriveShadowLifecycleState, endLifecycleRun, traceLifecycle, traceShadowLifecycle } from "./lifecycle-trace.js";
-import { closeHostEntry, endForegroundWake } from "./lifecycle-transitions.js";
-import { isProactiveWakeEnabled, isTunnelEnabled, isWorkspaceEnabled } from "../config/types.js";
-import { DEFAULT_THREAD_ID, normalizeChannelName, resolveThreadId } from "../channels/interface.js";
+import { endForegroundWake } from "./lifecycle-transitions.js";
+import { isProactiveWakeEnabled, isThreadTasksEnabled, isTunnelEnabled, isWorkspaceEnabled } from "../config/types.js";
+import { DEFAULT_THREAD_ID, resolveThreadId } from "../channels/interface.js";
 import { buildSystemPrompt } from "./system-prompt.js";
 import { SessionManager } from "./session-manager.js";
 import { buildWakeContext } from "./context.js";
@@ -27,7 +27,7 @@ import { ActivityTracker } from "./activity-tracker.js";
 import { ThreadActivityController } from "../threads/thread-activity-controller.js";
 import { shouldNotifyUpdate } from "../utils/version-check.js";
 import { shouldRunProactiveUpgradeCheck } from "./update-reminder-policy.js";
-import { loadOwnerConfig, consumePendingUpgrade, consumePendingRestart, writePendingRestart, getConfigDir, ownerConfigExists, saveOwnerConfig, deleteOnboardingSession, } from "../config/index.js";
+import { getConfigFile, loadOwnerConfig, consumePendingUpgrade, consumePendingRestart, writePendingRestart, getConfigDir, ownerConfigExists, saveOwnerConfig, deleteOnboardingSession, } from "../config/index.js";
 import { syncSystemTimezone } from "../utils/timezone.js";
 import { logger } from "../logger.js";
 import { cleanOldScreenshots } from "../tools/screenshot.js";
@@ -40,7 +40,7 @@ import { runOnboardingGate } from "./onboarding-gate.js";
 import { OnboardingServiceClient } from "../onboarding/onboarding-service-client.js";
 import { deliverPendingQqWelcome, sendWelcomeMessages } from "../onboarding/send-invite.js";
 import { resumePendingChannelBinding } from "../onboarding/resume-channel-binding.js";
-import { answerAndDrop, executionGateReply, runServiceGate, serviceGateMessage, shouldEnforceServiceGate } from "./service-gate.js";
+import { answerAndDrop, executionGateReply, persistedServiceStopped, runServiceGate, serviceGateMessage, shouldEnforceServiceGate } from "./service-gate.js";
 import { InterruptHandler } from "./interrupt-handler.js";
 import { ownerTranscriptionContext } from "../transcription-context.js";
 import { transcribeVoiceMessages } from "../utils/transcribe.js";
@@ -55,8 +55,7 @@ import { t, resolveLocale } from "../i18n/index.js";
 import { formatMessageSummary, previewIncomingForConsole, buildIncomingLogData } from "./message-format.js";
 import { buildReplyMapKeyFromMessage, buildReplyTarget, groupActivityDeliveryTargetForMessage, resolveTaskReplyTarget } from "./reply-target.js";
 import { notifyOwnerViaResolvedChain } from "./owner-notify.js";
-import { hasUsableOwnerChannel, listBoundOwnerChannels, resolveOwnerDefaultTarget } from "./owner-channel-resolver.js";
-import { runForemanBusinessRead } from "../threads/foreman-business.js";
+import { hasUsableOwnerChannel, resolveOwnerDefaultTarget } from "./owner-channel-resolver.js";
 import { buildRuntimeSurface, } from "./runtime-surface.js";
 import { getAgentEngine } from "./engines/engine-factory.js";
 import { prepareEngineSwitchBoundary } from "./engine-switch.js";
@@ -92,11 +91,12 @@ import { backfillMissingThreadApplications, migrateLegacyThreadApplications, thr
 import { currentApplicationContext, inheritThreadApplication, threadApplication } from "../threads/application-context.js";
 import { ForemanHost } from "../threads/foreman-host.js";
 import { ForemanStore } from "../threads/foreman-store.js";
-import { canDelegateTasks, foremanEventsOf, getForemanClient, installForemanClient, isForemanRuntime, supportsTaskRuntime } from "../threads/foreman-protocol.js";
+import { foremanEventsOf, getForemanClient, installForemanClient, isForemanRuntime } from "../threads/foreman-protocol.js";
 import { ForegroundTaskTracker, installForegroundTaskTracker } from "../threads/foreground-task.js";
 import { ThreadApplicationConflict } from "../threads/thread-meta.js";
 import { assertRuntimeApplicationId } from "../config/application-config.js";
 import { migrateProfileToAgentsMd } from "../config/agents-md-migration.js";
+import { ThreadTaskRuntime, endWakeThreadTasks, isTaskRelevantMessage, isTaskResumeMessage, retireStaleResume, setThreadTaskRuntime, } from "../threads/thread-task-runtime.js";
 /**
  * Grace period before an idle cross-runtime engine recovery restarts.
  * Short on purpose: the gate only fires when nothing is in flight.
@@ -112,8 +112,6 @@ const WORKER_EXECUTION_IDLE_GRACE_MS = 10_000;
  * Main agent loop. This is the entry point that runs forever.
  */
 export async function startAgentLoop(config, options) {
-    if (options?.signal?.aborted)
-        return;
     const workerMode = options?.workerMode ?? null;
     const workerExecution = workerMode?.execution ?? null;
     if (workerMode && workerExecution) {
@@ -179,6 +177,19 @@ export async function startAgentLoop(config, options) {
         // orphaned worker can no longer commit claims owned by its successor.
         ...(workerMode ? { ownerId: workerMode.relay.workerInstanceId } : {}),
     });
+    // Thread task store (#1996): opened by the same queue owner at the same
+    // moment it recovers in-flight claims, and fenced by the same identity.
+    // Bounded executions keep caller-owned task state outside this loop.
+    // Conversational task tracking is off unless the local config opts in
+    // (`threadTasksEnabled: true`). Null means disabled for this process.
+    const threadTasks = workerExecution || !isThreadTasksEnabled(config)
+        ? null
+        : ThreadTaskRuntime.start({
+            threadId: executionContext.threadId,
+            writerId: workerMode ? workerMode.relay.workerInstanceId : randomUUID(),
+            config,
+        });
+    setThreadTaskRuntime(threadTasks);
     const channelManager = new ChannelManager(config, messageQueue);
     const activityTracker = new ActivityTracker();
     const mainActivityController = workerMode
@@ -197,20 +208,20 @@ export async function startAgentLoop(config, options) {
     // --- Thread supervisor (multi-thread architecture) ---
     // Install before adapters start: connect/hello can immediately replay work.
     // Recover old queues after channels are available for replies.
-    // The host routes chats to in-process conversations and admitted Tasks to
-    // the independent worker pool. Execution workers never spawn nested hosts.
-    if (!workerMode) {
+    // Main process only. Spawns/routes worker processes for non-default threads
+    // via the ChannelManager threadRouter hook. Disabled in worker mode (workers
+    // never route to sub-workers) and when multiThread is turned off in config.
+    if (!workerMode && config.multiThread.enabled) {
         const { ThreadSupervisor } = await import("../threads/supervisor.js");
         // Foreman (#2805): the host owns General's background tasks, their
         // delivery obligations and fallback. Built before the supervisor so the
         // supervisor can route workers' commands and `general` events to it.
         let foremanHost = null;
-        let taskStore = null;
         const supervisor = new ThreadSupervisor({
             channelManager,
             messageQueue,
             deferRecovery: true,
-            maxConcurrentThreads: config.workers?.maxConcurrent ?? config.multiThread.maxConcurrentThreads,
+            maxConcurrentThreads: config.multiThread.maxConcurrentThreads,
             idleTimeoutMs: config.multiThread.idleTtlMs,
             config,
             desktopRuntimeResolution: options?.desktopRuntimeResolution,
@@ -232,24 +243,16 @@ export async function startAgentLoop(config, options) {
             // for the worker the supervisor actually talks to.
             handleForemanCommand: (threadId, command) => foremanHost?.handle(threadId, command)
                 ?? Promise.resolve({ ok: false, text: "Error: background tasks are not available in this conversation." }),
-            handleForemanBusinessRead: (executionId, command, workspace) => foremanHost?.readBusiness(executionId, command.tool, command.args, workspace)
-                ?? Promise.resolve({ ok: false, text: "Business reads are unavailable" }),
         });
         supervisor.onExecutionEvent((event, caller) => {
             if (caller.kind !== "tui")
                 return;
             channelManager.getAdapter("tui")?.publishExecutionEvent(event);
         });
-        const foremanExecutions = supervisor.executionService();
+        const foremanExecutions = isForemanRuntime(config) ? supervisor.executionService() : null;
         if (foremanExecutions) {
             const store = new ForemanStore();
-            taskStore = store;
             foremanHost = new ForemanHost({
-                canReadBusiness: (_threadId, target) => isWorkspaceEnabled(config) && target !== null
-                    && listBoundOwnerChannels(config, loadOwnerConfig()).some((owner) => owner.validationStatus === "verified"
-                        && owner.kind === "dm" && normalizeChannelName(owner.channel) === normalizeChannelName(target.channel) && owner.to === target.to),
-                readBusiness: runForemanBusinessRead,
-                allowDelegation: () => isForemanRuntime(config),
                 executions: foremanExecutions,
                 store,
                 enqueueToGeneral: (threadId, message) => {
@@ -258,15 +261,16 @@ export async function startAgentLoop(config, options) {
                         wakeGeneralLoop?.();
                         return;
                     }
-                    // The conversation's durable queue and application admission.
+                    // A thread's own durable queue; the supervisor starts its worker.
+                    // The thread's recorded application keeps strict admission satisfied.
                     const app = threadApplication(threadId, config);
                     if (!supervisor.tryRouteMessage({ ...message, threadId, ...(app ? { app } : {}) }, threadId)) {
                         throw new Error(`Thread ${threadId} did not accept a background-task update`);
                     }
                 },
                 deliver: (target, text, threadId) => channelManager.tryDeliver(target, text, {
-                    logContext: "background task delivery",
-                    context: { kind: "task_update", ...(threadId === DEFAULT_THREAD_ID ? {} : { businessThreadId: threadId }) },
+                    logContext: "background task fallback",
+                    context: threadId === DEFAULT_THREAD_ID ? {} : { businessThreadId: threadId },
                 }),
                 ownerTarget: () => {
                     const owner = resolveOwnerDefaultTarget(config, loadOwnerConfig());
@@ -275,16 +279,14 @@ export async function startAgentLoop(config, options) {
                 locale: () => resolveLocale(loadOwnerConfig().language),
             });
             const host = foremanHost;
-            installForemanClient(supportsTaskRuntime() ? { delegationEnabled: isForemanRuntime(config), request: (command) => host.handle(DEFAULT_THREAD_ID, command) } : null);
+            installForemanClient({ request: (command) => host.handle(DEFAULT_THREAD_ID, command) });
+            registerShutdownCallback(() => {
+                host.stop();
+                store.close();
+                return Promise.resolve();
+            });
         }
         activeForemanHost = foremanHost;
-        // Keep the Task ledger and delivery adapters alive until conversations and
-        // workers settle. Their final receipts may still arrive during shutdown.
-        registerShutdownCallback(async () => {
-            foremanHost?.stop();
-            await supervisor.shutdownAll();
-            taskStore?.close();
-        });
         channelManager.setThreadRouter((msg, threadId) => supervisor.routeMessage(msg, threadId));
         // Expose for the main-loop wake context to refresh its own awareness.
         threadSupervisor = supervisor;
@@ -321,6 +323,9 @@ export async function startAgentLoop(config, options) {
         catch (err) {
             logger.warn(`Graceful shutdown did not complete cleanly: ${err instanceof Error ? err.message : String(err)}`);
         }
+        // After the channels, so it never delays them. A short grace lets an
+        // in-flight sidecar call commit; unconsumed events wait for the next start.
+        await threadTasks?.close(2_000);
         messageQueue.close();
         logger.system("Graceful shutdown complete.");
     });
@@ -340,6 +345,11 @@ export async function startAgentLoop(config, options) {
         threadSupervisor.startExecutions();
         // Its first sweep sends fallbacks a restart left overdue.
         activeForemanHost?.start();
+        const supervisor = threadSupervisor;
+        registerShutdownCallback(async () => {
+            logger.system("Graceful shutdown: stopping thread workers...");
+            await supervisor.shutdownAll();
+        });
     }
     // --- Resume an interrupted channel binding ---
     // Runs BEFORE the onboarding gate on purpose. A binding whose completion tail
@@ -545,7 +555,7 @@ export async function startAgentLoop(config, options) {
     // Foreman's foreground limit, for conversational sessions that can delegate.
     // Thread-local: getConfigDir() is the thread's own directory in a worker.
     // Skill Learning drives this same session and is exempt.
-    const foregroundTasks = !workerExecution && canDelegateTasks()
+    const foregroundTasks = !workerExecution && getForemanClient()
         ? new ForegroundTaskTracker(getConfigDir(), () => new Date(), () => agentState.learning)
         : null;
     installForegroundTaskTracker(foregroundTasks);
@@ -677,7 +687,7 @@ export async function startAgentLoop(config, options) {
             browserSelection: runtimeSurface.browserSelection,
             credentialBacked: runtimeSurface.credentialBacked,
             conversation: { threadId: workerMode?.threadId },
-            foreman: canDelegateTasks(),
+            foreman: getForemanClient() !== null,
         });
     }, runtimeSurface, options?.workspaceCwd ? { workspaceCwd: options.workspaceCwd } : {});
     // Hand the engine-switch summary to the freshly created session (rotation
@@ -727,6 +737,26 @@ export async function startAgentLoop(config, options) {
     // Expose the wake function so out-of-loop components can trigger an
     // immediate wake without threading the closure through every call site.
     agentState.wakeMainLoop = wakeMainLoop;
+    // Thread task resumes (#1996 PR 5): after a wake the runtime queues the
+    // next runnable task as a system row and wakes the loop, so queued work
+    // continues without a new owner message, with proactive wakes off and in
+    // workers. It never queues while a wake runs or execution is gated; the
+    // row is still checked against the task when it is dequeued.
+    // TODO: a resume queued just before the service gate engages is discarded
+    // with the gated queue (main) or still runs (workers, which have no gate
+    // pass and whose system rows skip the gate reply). The window is tiny.
+    threadTasks?.enableResumes({
+        queue: messageQueue,
+        isBusy: () => agentState.busy || !messageQueue.isEmpty(),
+        isGated: () => readFundLeagueHold() !== null
+            // A worker's heartbeat holds the status from its start; the main
+            // process persists every change, so read that instead.
+            || (workerMode ? persistedServiceStopped(getConfigFile()) : shouldEnforceServiceGate(heartbeat.lastServiceStatus)),
+        wake: wakeMainLoop,
+    });
+    // Startup: work that was queued, or resumed and interrupted, before the
+    // previous process stopped continues now.
+    void threadTasks?.requestResume();
     const interruptHandler = new InterruptHandler({
         externalContextRegistry,
         session: session.activeSession,
@@ -883,7 +913,6 @@ export async function startAgentLoop(config, options) {
     else {
         registerShutdownCallback(() => {
             closeTranscriptMemoryDb();
-            closeUsageReportQueue();
             return Promise.resolve();
         });
     }
@@ -927,17 +956,10 @@ export async function startAgentLoop(config, options) {
                 dreamingRunner?.beginStep();
                 heartbeat.nudge();
                 return () => {
-                    // Maintenance holds the slot the way a foreground wake does. Release
-                    // it through Stopping so workers resume only after the slot is free.
-                    endForegroundWake({
-                        from: "Running",
-                        cleanup: () => { agentState.learning = false; },
-                        release: () => {
-                            executionOwner.setBusy(false, "maintenance_release");
-                            resumeWorkers?.();
-                            heartbeat.nudge();
-                        },
-                    });
+                    agentState.learning = false;
+                    executionOwner.setBusy(false, "maintenance_release");
+                    resumeWorkers?.();
+                    heartbeat.nudge();
                 };
             },
             hasPendingSkills: hasPendingSkillLearning,
@@ -981,12 +1003,6 @@ export async function startAgentLoop(config, options) {
     if (options?.onReady) {
         options.onReady({ agentState, sessionManager: session, messageQueue, ownerConfig });
     }
-    const wakeOnShutdown = () => { session.requestStop(); wakeMainLoop(); };
-    options?.signal?.addEventListener("abort", wakeOnShutdown, { once: true });
-    registerShutdownCallback(() => {
-        options?.signal?.removeEventListener("abort", wakeOnShutdown);
-        return Promise.resolve();
-    });
     logger.system(workerExecution
         ? "Single-shot worker loop started. Waiting for its execution dispatch..."
         : "Agent loop started. Waiting for messages or heartbeat...");
@@ -1006,21 +1022,10 @@ export async function startAgentLoop(config, options) {
     let lastWakeScreenshotMs = 0;
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- intentional infinite loop
     while (true) {
-        if (options?.signal?.aborted)
-            break;
         const leagueHold = readFundLeagueHold();
         if (leagueHold) {
-            // The durable marker already blocks the next wake. A slot that is still
-            // held stops first; an idle loop closes the entry directly. Neither
-            // confirms an engine barrier.
-            closeHostEntry({
-                busy: agentState.busy,
-                requestStop: () => { agentState.requestStop(); },
-                markClosed: () => {
-                    executionOwner.setBusy(false, "league_hold");
-                    agentState.gated = true;
-                },
-            });
+            executionOwner.setBusy(false, "league_hold");
+            agentState.gated = true;
             await new Promise((resolve) => { wakeResolver = resolve; });
             wakeResolver = null;
             continue;
@@ -1068,6 +1073,11 @@ export async function startAgentLoop(config, options) {
         });
         nextProactiveWakeAt = sleepMs === null ? null : nextProactiveWakeAt ?? Date.now() + sleepMs;
         const isFirstWake = firstIteration;
+        // Worker: report idle status before sleeping so the supervisor's
+        // cross-thread awareness snapshot reflects this thread as idle.
+        if (workerMode && !isFirstWake) {
+            workerMode.relay.relayStatus(false, "idle");
+        }
         // We are about to go idle, which is the only safe moment to move back
         // across a runtime boundary: that costs a restart and collapses the
         // session into a summary, so doing it mid-conversation would cut a live
@@ -1116,8 +1126,6 @@ export async function startAgentLoop(config, options) {
                 resolve();
             }
         });
-        if (options?.signal?.aborted)
-            break;
         if (proactiveWakeSchedule.changed && messageQueue.isEmpty()) {
             proactiveWakeSchedule.changed = false;
             nextProactiveWakeAt = null;
@@ -1227,23 +1235,21 @@ export async function startAgentLoop(config, options) {
                     stopRequested: agentState.stopRequested,
                     busy: agentState.busy,
                     recovering,
-                    // Pi confirms this with `agent_settled`. An abort is not a receipt,
-                    // so an engine that cannot prove it stopped stays unconfirmed.
-                    barrierConfirmed: session.executionBarrierConfirmed(),
+                    // No engine has a confirmed execution barrier yet. Pi settlement
+                    // only prevents a send collision; it does not prove the engine stopped.
+                    barrierConfirmed: false,
                 }),
                 legacy: {
                     busy: agentState.busy,
                     gated: agentState.gated,
                     stopRequested: agentState.stopRequested,
                 },
-                barrierConfirmed: session.executionBarrierConfirmed(),
+                barrierConfirmed: false,
             });
         };
         const releaseLifecycleRun = (reason) => {
             // Stopping is one beat when nothing is still in flight. The slot stays
             // busy until cleanup finishes, so busy=false is not what ends the wake.
-            // A worker thread is the same loop: its busy flag lives on the
-            // supervisor, and it is cleared only after this cleanup.
             endForegroundWake({
                 // A failed compaction is still this same foreground run. Phase 3 is
                 // what moves that path into Recovering before the wake ends.
@@ -1264,10 +1270,6 @@ export async function startAgentLoop(config, options) {
                     endLifecycleRun(lifecycleRunId);
                 },
                 release: () => {
-                    // The supervisor learns a worker is idle here, after cleanup, not
-                    // at the next sleep. The local slot is released for both loops.
-                    if (workerMode)
-                        workerMode.relay.relayStatus(false, "idle");
                     executionOwner.setBusy(false, reason, lifecycleRunId);
                 },
             });
@@ -1308,6 +1310,10 @@ export async function startAgentLoop(config, options) {
                     continue;
                 }
             }
+            // Re-check a queued task resume against the task itself: a cancel,
+            // change, wait or block since it was queued retires it unexecuted.
+            if (retireStaleResume(messageQueue, threadTasks, msg))
+                continue;
             const gateReply = msg.channel === "system" ? null : executionGateReply(heartbeat, resolveLocale(ownerConfig.language));
             if (gateReply !== null) {
                 await answerAndDrop(channelManager, messageQueue, msg, gateReply, tuiAdapter);
@@ -1320,6 +1326,9 @@ export async function startAgentLoop(config, options) {
         if (trigger === "message" && messages.length === 0) {
             releaseLifecycleRun("empty_message_batch");
             heartbeat.nudge();
+            // A retired stale resume ends here without a wake end; queue the next
+            // runnable task (or the same one at its new version) instead.
+            void threadTasks?.requestResume();
             continue;
         }
         const correlatedTuiMessage = messages.find((message) => typeof message.meta?.tuiRequestId === "string");
@@ -1335,10 +1344,16 @@ export async function startAgentLoop(config, options) {
             // other channels get the same cloud/local pipeline.
             if (trigger === "message" && !workerExecution) {
                 for (const msg of messages) {
+                    // A task resume is internal: no "typing…" for the owner.
+                    if (isTaskResumeMessage(msg))
+                        continue;
                     sendTypingToMessage(channelManager, msg).catch(() => { });
                 }
             }
             await transcribeVoiceMessages(messages, ownerTranscriptionContext(ownerConfig));
+            // Event first, sidecar second (#1996): after transcription so a voice
+            // request is stored with its text. Idempotent and fail-safe.
+            threadTasks?.recordMessages(messages.filter(isTaskRelevantMessage));
             for (const msg of messages) {
                 agentState.replyMap.set(buildReplyMapKeyFromMessage(msg), buildReplyTarget(msg));
             }
@@ -1485,18 +1500,8 @@ export async function startAgentLoop(config, options) {
             operation: "query",
             outcome: "started",
         });
-        let releaseConversationTurn;
-        agentState.currentDispatchId = createHash("sha256").update(JSON.stringify(messages.map((message) => message.id))).digest("hex");
         try {
-            if (!workerExecution) {
-                releaseConversationTurn = await (options?.acquireConversationTurn?.(options.signal)
-                    ?? threadSupervisor?.acquireConversationTurn(options?.signal));
-            }
-            if (options?.signal?.aborted) {
-                messageQueue.requeueOwnedClaims();
-                break;
-            }
-            // Accepted inputs are also replayed from the ledger on executor recovery.
+            // Execution inputs in this batch reach the model with this turn.
             noteMessagesHandedToModel(messages);
             const result = await cycleRunner.run(contentBlocks, trigger, messages, consecutiveErrors);
             traceLifecycle({
@@ -1507,10 +1512,6 @@ export async function startAgentLoop(config, options) {
                 evidence: { terminalState: result.terminalState },
             });
             consecutiveErrors = result.consecutiveErrors;
-            if (options?.signal?.aborted) {
-                messageQueue.requeueOwnedClaims();
-                break;
-            }
             // A queue claim is not terminal until the complete wake cycle returns.
             // If the worker dies during model/tool execution, the in-flight rows
             // remain durable and are replayed by the next queue owner.
@@ -1521,26 +1522,47 @@ export async function startAgentLoop(config, options) {
             // Foreman: the background-task updates this turn handled, read before
             // their claims are released (mid-turn interrupts included).
             const handledForemanEvents = failoverRestartPending ? [] : foremanEventsOf(messageQueue.currentCycleClaims());
-            // A completed foreground wake acknowledges its claims. Accepted background
-            // work already belongs to the canonical Task ledger.
-            if (!failoverRestartPending)
-                messageQueue.markAllInFlightHandled();
+            const foregroundRecord = foregroundTasks?.current;
+            const handedOffTaskId = foregroundRecord?.handedOff ? foregroundRecord.taskId : undefined;
+            // Claims become handled only once each message is a durable task event,
+            // so their follow-up survives the queue row (#1996). handled ≠ completed.
+            endWakeThreadTasks(messageQueue, threadTasks, { failoverRestartPending });
             if (!failoverRestartPending) {
                 // An accepted finish that is not waiting for the user ends the
                 // foreground task; the next one starts from zero. A wake that only
                 // ran out of recovery attempts or timed out keeps the count.
-                if (result.finished === true && result.terminalState === "completed")
+                if (result.finished === true && result.terminalState === "completed" && !handedOffTaskId)
                     foregroundTasks?.reset();
                 // Whatever the turn did not deliver to the user is due for the fallback now.
                 if (handledForemanEvents.length > 0) {
                     void getForemanClient()?.request({ type: "turn_ended", events: handledForemanEvents });
                 }
             }
+            if (result.finished === true && result.terminalState === "completed" && handedOffTaskId) {
+                if (workerMode)
+                    workerMode.relay.markActivityWaitingForBackground(handedOffTaskId);
+                else
+                    mainActivityController?.markWaitingForBackground(handedOffTaskId);
+                foregroundTasks?.reset();
+            }
+            for (const event of handledForemanEvents) {
+                if (event.kind !== "result")
+                    continue;
+                const state = event.status === "succeeded" ? "completed" : "failed";
+                if (workerMode)
+                    workerMode.relay.finishBackgroundActivity(event.taskId, state);
+                else
+                    mainActivityController?.finishBackgroundTask(event.taskId, state);
+            }
             if (workerMode) {
-                workerMode.relay.finishActivityRun(result.terminalState);
+                if (!(result.finished === true && result.terminalState === "completed" && handedOffTaskId)) {
+                    workerMode.relay.finishActivityRun(result.terminalState);
+                }
             }
             else {
-                mainActivityController?.finishRun(result.terminalState);
+                if (!(result.finished === true && result.terminalState === "completed" && handedOffTaskId)) {
+                    mainActivityController?.finishRun(result.terminalState);
+                }
             }
             tuiTerminalOutcome = resolveTuiTerminalOutcome(result.terminalState);
         }
@@ -1549,6 +1571,9 @@ export async function startAgentLoop(config, options) {
             // terminal boundary. A later wake must not inherit this turn's claims
             // and accidentally confirm them together with unrelated work.
             try {
+                // Released before the requeue: a replayed resume for an interrupted
+                // task must run when it comes back (#2664 review P1-B).
+                threadTasks?.releaseResume(messageQueue.currentCycleClaims());
                 messageQueue.requeueOwnedClaims();
             }
             catch (requeueErr) {
@@ -1570,7 +1595,6 @@ export async function startAgentLoop(config, options) {
             throw err;
         }
         finally {
-            releaseConversationTurn?.();
             // Cleanup must always run, even if the extracted cycle runner throws
             // unexpectedly, otherwise the reply watchdog timer can leak across
             // wake cycles. The runtime heartbeat loop runs independently and