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

package/dist/agent/loop.js

@@ -6,20 +6,19 @@
  *
  *  - HeartbeatManager:  runtime heartbeat lifecycle
  *  - ReplyWatchdog:     fast-responder fallback timer
- *  - WakeCycleRunner:   session switch loop, stream processing, error retry,
+ *  - WakeCycleRunner:   wake loop, stream processing, error retry,
  *                       transcript indexing
  *  - InterruptHandler:  mid-turn message injection
- *  - SessionManager:    dual-session management
+ *  - SessionManager:    conversation session management
  *  - ChannelManager:    messaging channel adapters
  */
 import { createDefaultExternalContextRegistry, ExternalContextRegistry } from "./external-context/registry.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { beginLifecycleRun, createLifecycleRunId, deriveShadowLifecycleState, endLifecycleRun, traceLifecycle, traceShadowLifecycle } from "./lifecycle-trace.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 { 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 { buildSystemPrompt } from "./system-prompt.js";
-import { buildLabRunSystemPrompt } from "./lab-run-system-prompt.js";
 import { SessionManager } from "./session-manager.js";
 import { buildWakeContext } from "./context.js";
 import { MessageQueue } from "../channels/queue.js";
@@ -28,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 { getConfigFile, loadOwnerConfig, consumePendingUpgrade, consumePendingRestart, writePendingRestart, getConfigDir, ownerConfigExists, saveOwnerConfig, deleteOnboardingSession, } from "../config/index.js";
+import { 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";
@@ -41,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, persistedServiceStopped, runServiceGate, serviceGateMessage, shouldEnforceServiceGate } from "./service-gate.js";
+import { answerAndDrop, executionGateReply, 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";
@@ -56,13 +55,14 @@ 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 } from "./owner-channel-resolver.js";
+import { hasUsableOwnerChannel, listBoundOwnerChannels, resolveOwnerDefaultTarget } from "./owner-channel-resolver.js";
+import { runForemanBusinessRead } from "../threads/foreman-business.js";
 import { buildRuntimeSurface, } from "./runtime-surface.js";
 import { getAgentEngine } from "./engines/engine-factory.js";
 import { prepareEngineSwitchBoundary } from "./engine-switch.js";
 import { getClaudeTranscriptDirForProfileDir } from "../utils/claude-transcripts.js";
-import { isLabRunThreadId } from "../threads/lab-run-thread.js";
-import { applyLabRuntimePolicyToSurface, loadWorkerLabRuntimePolicy } from "../threads/lab-runtime-policy.js";
+import { applyWorkerRuntimePolicyToSurface, isolateWorkerConfig } from "../threads/worker-runtime-policy.js";
+import { noteMessagesHandedToModel } from "../threads/worker-execution-runtime.js";
 import { closeTranscriptMemoryDb } from "./transcript/transcript-indexer.js";
 import { closeUsageReportQueue } from "./usage/usage-report-queue.js";
 import { maybeAutoBackfill, cancelAutoBackfill } from "./transcript/transcript-backfill.js";
@@ -83,17 +83,20 @@ import { normalizeAgentFeedback } from "./feedback.js";
 import { AgentFeedbackOutbox } from "./feedback-outbox.js";
 import { scheduleRestart, detectProcessManager, restartManagedProcess } from "../utils/restart.js";
 import { NightlyMaintenance, NIGHTLY_RESTART_MIN_UPTIME_MS } from "./nightly-maintenance/index.js";
-import { resolveDreamingTargets, runDreamingJob } from "./nightly-maintenance/memory-dreaming-sweep.js";
-import { readDeepNightDreamDay } from "./nightly-maintenance/memory-dreaming.js";
+import { DreamingPlanner } from "./nightly-maintenance/dreaming-planner.js";
+import { DreamingRunner } from "./nightly-maintenance/dreaming-runner.js";
 import { maintainGlossary } from "./vocabulary-glossary.js";
 import { isOwnerInitiatedMessage } from "./owner-initiated-eligibility.js";
 import { retireLegacyServices } from "../service/retired-services.js";
 import { backfillMissingThreadApplications, migrateLegacyThreadApplications, threadApplicationBackfillHealthEvent } from "../threads/application-migration.js";
-import { currentApplicationContext, inheritThreadApplication } from "../threads/application-context.js";
+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 { 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.
@@ -103,25 +106,38 @@ export { getAgentState } from "./state.js";
 // Track the current SIGUSR2 handler so we can swap it out without
 // removing listeners registered by other subsystems.
 let activeSigusr2Handler = null;
-/** Lab workers drain their local queue until it stays empty for this long. */
-const LAB_IDLE_GRACE_MS = 10_000;
+/** Bounded workers drain their local queue until it stays empty for this long. */
+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 labRuntimePolicy = workerMode && isLabRunThreadId(workerMode.threadId)
-        ? loadWorkerLabRuntimePolicy(workerMode.threadId)
-        : null;
+    const workerExecution = workerMode?.execution ?? null;
+    if (workerMode && workerExecution) {
+        // Enforce isolation at the shared entry point, before channels, context or
+        // model services are initialized. Callers need only supply the execution.
+        workerMode.relay.restrictToInternalExecution();
+        config = isolateWorkerConfig(config);
+    }
     // Thread supervisor (main process, multi-thread mode). Assigned during init
     // when enabled; used to refresh cross-thread awareness before each wake.
     let threadSupervisor = null;
+    // Foreman host, next to the supervisor in the main process (#2805).
+    let activeForemanHost = null;
+    // Set once agent state exists. Until then a background-task update is only
+    // queued; the loop's first iteration finds it.
+    let wakeGeneralLoop = null;
     // HeartbeatManager is constructed after the supervisor and several awaited
     // startup gates. Do not close over that later `const` — recovered workers
     // and live inbound messages can fire these callbacks while it is still in
     // the temporal dead zone.
     let heartbeatForSupervisor = null;
     let nightlyMaintenance = null;
+    // Dreaming batches run as maintenance executions on the thread supervisor.
+    let dreamingRunner = null;
     let maintenanceRequested = false;
     // =====================================================================
     // 1. Initialization
@@ -163,19 +179,6 @@ 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.
-    // Lab runs are single-shot and keep no task list. Off unless the local
-    // config opts in (`threadTasksEnabled: true`). Null means disabled for
-    // this process; everything else behaves exactly as before.
-    const threadTasks = labRuntimePolicy || !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
@@ -194,22 +197,93 @@ 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.
-    // 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) {
+    // The host routes chats to in-process conversations and admitted Tasks to
+    // the independent worker pool. Execution workers never spawn nested hosts.
+    if (!workerMode) {
         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.multiThread.maxConcurrentThreads,
+            maxConcurrentThreads: config.workers?.maxConcurrent ?? config.multiThread.maxConcurrentThreads,
             idleTimeoutMs: config.multiThread.idleTtlMs,
             config,
             desktopRuntimeResolution: options?.desktopRuntimeResolution,
             browserRuntimeResolution: options?.browserRuntimeResolution,
             onFeedback: (feedback) => heartbeatForSupervisor?.enqueueFeedback(feedback),
             onBusyChange: () => heartbeatForSupervisor?.nudge(),
+            onMaintenanceInput: () => dreamingRunner?.preempt(),
+            deliverExecutionEvent: (event, caller) => {
+                // Maintenance reads its executions from the store when they end.
+                if (caller.kind === "nightly")
+                    return Promise.resolve(true);
+                if (caller.kind === "general")
+                    return foremanHost?.deliverEvent(event, caller) ?? Promise.resolve(false);
+                if (caller.kind !== "tui")
+                    return Promise.resolve(false);
+                return Promise.resolve(channelManager.getAdapter("tui") !== undefined);
+            },
+            // Workers install a Foreman client only when Foreman is on; this answers
+            // 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();
+        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) => {
+                    if (threadId === DEFAULT_THREAD_ID) {
+                        messageQueue.enqueue(message);
+                        wakeGeneralLoop?.();
+                        return;
+                    }
+                    // The conversation's durable queue and application admission.
+                    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 }) },
+                }),
+                ownerTarget: () => {
+                    const owner = resolveOwnerDefaultTarget(config, loadOwnerConfig());
+                    return owner ? { channel: owner.channel, to: owner.to } : null;
+                },
+                locale: () => resolveLocale(loadOwnerConfig().language),
+            });
+            const host = foremanHost;
+            installForemanClient(supportsTaskRuntime() ? { delegationEnabled: isForemanRuntime(config), request: (command) => host.handle(DEFAULT_THREAD_ID, command) } : null);
+        }
+        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.
@@ -247,16 +321,14 @@ 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.");
     });
     // Runtime logs and active Claude/Pi transcripts share one provider-neutral
     // upload path. Each worker owns a thread-local spool, so worker crashes and
     // network outages cannot lose or corrupt the main process queue.
-    const runtimeTelemetry = startRuntimeTelemetryShipper(config, {
+    // A private-content execution (Dreaming) never ships its transcripts or logs.
+    const runtimeTelemetry = workerExecution?.privateContent ? null : startRuntimeTelemetryShipper(config, {
         ...(workerMode ? { threadId: workerMode.threadId } : {}),
     });
     registerShutdownCallback(async () => {
@@ -264,11 +336,10 @@ export async function startAgentLoop(config, options) {
     });
     if (threadSupervisor) {
         threadSupervisor.recoverPendingThreads();
-        const supervisor = threadSupervisor;
-        registerShutdownCallback(async () => {
-            logger.system("Graceful shutdown: stopping thread workers...");
-            await supervisor.shutdownAll();
-        });
+        // After channels start, so delivered results reach their adapters.
+        threadSupervisor.startExecutions();
+        // Its first sweep sends fallbacks a restart left overdue.
+        activeForemanHost?.start();
     }
     // --- Resume an interrupted channel binding ---
     // Runs BEFORE the onboarding gate on purpose. A binding whose completion tail
@@ -304,6 +375,10 @@ export async function startAgentLoop(config, options) {
     const justRestarted = workerMode ? null : consumePendingRestart();
     const ownerConfig = loadOwnerConfig();
     if (!workerMode) {
+        channelManager.setOwnerDefaultTargetResolver(() => {
+            const owner = resolveOwnerDefaultTarget(config, loadOwnerConfig());
+            return owner ? { channel: owner.channel, to: owner.to } : undefined;
+        });
         await syncSystemTimezone(ownerConfig.timezone, config.systemPassword);
     }
     // Runtime config changes need to re-arm the current sleep without turning
@@ -317,8 +392,8 @@ export async function startAgentLoop(config, options) {
             wakeResolver = null;
         }
     }
-    /** Wait for LabRun queue work or for the worker's idle grace period to elapse. */
-    function waitForLabQueueOrIdle() {
+    /** Wait for execution queue work or for the worker's idle grace period to elapse. */
+    function waitForExecutionQueueOrIdle() {
         if (!messageQueue.isEmpty())
             return Promise.resolve(true);
         return new Promise((resolve) => {
@@ -341,7 +416,7 @@ export async function startAgentLoop(config, options) {
                 finish();
                 return;
             }
-            timer = setTimeout(finish, LAB_IDLE_GRACE_MS);
+            timer = setTimeout(finish, WORKER_EXECUTION_IDLE_GRACE_MS);
         });
     }
     // --- Heartbeat manager ---
@@ -441,7 +516,6 @@ export async function startAgentLoop(config, options) {
         hasRepliedInCycle: false,
         notifiedUserThisWake: false,
         liveAssistantTexts: new Set(),
-        codingCompletionTaskStartedAt: undefined,
         restartTunnel: options?.restartTunnel,
         commandDispatcher: heartbeat.commandDispatcher,
         compacting: false,
@@ -463,9 +537,18 @@ export async function startAgentLoop(config, options) {
         getActiveThreads: activeThreadSupervisor
             ? () => activeThreadSupervisor.getThreadsOverview()
             : undefined,
+        executions: activeThreadSupervisor?.executionService() ?? undefined,
     };
     initAgentState(agentState);
     const executionOwner = new ExecutionOwner(agentState);
+    wakeGeneralLoop = wakeMainLoop;
+    // 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()
+        ? new ForegroundTaskTracker(getConfigDir(), () => new Date(), () => agentState.learning)
+        : null;
+    installForegroundTaskTracker(foregroundTasks);
     // Arm the always-on runtime heartbeat loop now that `agentState` is
     // wired. Workers deliberately skip runtime heartbeat; `heartbeat.nudge()`
     // remains safe because it no-ops until startRuntime() is called.
@@ -526,8 +609,13 @@ export async function startAgentLoop(config, options) {
     }
     const builtRuntime = await buildRuntimeSurface(config, options?.desktopRuntimeResolution, options?.browserRuntimeResolution);
     const startupDynamicMcpServerCount = builtRuntime.startupDynamicMcpServerCount;
-    const runtimeSurface = labRuntimePolicy
-        ? applyLabRuntimePolicyToSurface(builtRuntime.runtimeSurface, labRuntimePolicy)
+    // The host applies the restriction last; an adapter supplies only its tool
+    // registrations, and the host-owned budget is attached after everything else.
+    const runtimeSurface = workerExecution
+        ? {
+            ...applyWorkerRuntimePolicyToSurface(builtRuntime.runtimeSurface, workerExecution.policy, workerExecution.adapterTools),
+            executionBudget: workerExecution.budget,
+        }
         : builtRuntime.runtimeSurface;
     const finAppCapabilityChangedDuringBuild = finAppCapabilityState.active !== null &&
         finAppCapabilityState.active !== runtimeSurface.credentialBacked.finApp;
@@ -564,11 +652,10 @@ export async function startAgentLoop(config, options) {
         logger.system(`Loaded ${startupDynamicMcpServerCount} dynamic MCP server(s) from disk`);
     }
     // --- Engine switch boundary -----------------------------------------
-    // If any prior transcript was written by a different engine than
-    // `config.json` currently selects, collapse general + coding into a
-    // single fresh general session with a combined summary. This must
-    // run BEFORE constructing SessionManager so the manager sees the
-    // post-collapse mailbox (no coding session to resume).
+    // If the prior transcript was written by a different engine than
+    // `config.json` currently selects, retire it into a fresh session with a
+    // summary. This must run BEFORE constructing SessionManager so the
+    // manager does not resume the retired session id.
     const currentEngine = getAgentEngine(config);
     let engineSwitchBoundary = null;
     try {
@@ -578,32 +665,42 @@ export async function startAgentLoop(config, options) {
         logger.warn(`[engine-switch] boundary handling failed; continuing with fresh sessions: ${err instanceof Error ? err.message : String(err)}`);
     }
     // One registry per agent process, shared by wake collection and both prompt paths.
-    const externalContextRegistry = labRuntimePolicy
+    const externalContextRegistry = workerExecution
         ? new ExternalContextRegistry([])
         : createDefaultExternalContextRegistry(config);
     const session = new SessionManager(config, () => {
-        if (runtimeSurface.labRuntimePolicy) {
-            return buildLabRunSystemPrompt(config, runtimeSurface.labRuntimePolicy);
-        }
+        if (workerExecution)
+            return workerExecution.buildSystemPrompt(config);
         return buildSystemPrompt(config, ownerConfig, externalContextRegistry, {
             hostCapabilities: runtimeSurface.hostCapabilities,
             desktopAvailable: runtimeSurface.desktop.available,
             browserSelection: runtimeSurface.browserSelection,
             credentialBacked: runtimeSurface.credentialBacked,
             conversation: { threadId: workerMode?.threadId },
+            foreman: canDelegateTasks(),
         });
-    }, runtimeSurface, {
-        dualSessionEnabled: ownerConfig.dualSessionEnabled,
-        ...(options?.workspaceCwd ? { workspaceCwd: options.workspaceCwd } : {}),
-    });
-    // Hand the combined engine-switch summary to the freshly created
-    // general session (rotation + mailbox clearing already happened
-    // before SessionManager construction).
+    }, runtimeSurface, options?.workspaceCwd ? { workspaceCwd: options.workspaceCwd } : {});
+    // Hand the engine-switch summary to the freshly created session (rotation
+    // already happened before SessionManager construction).
     if (engineSwitchBoundary) {
-        session.injectSummary("general", engineSwitchBoundary.combinedSummary);
+        session.injectSummary(engineSwitchBoundary.combinedSummary);
     }
-    logger.system(`Dual session: ${ownerConfig.dualSessionEnabled ? "enabled" : "disabled"}`);
     agentState.sessionManager = session;
+    if (workerExecution) {
+        // Exhausting the budget asks the active session to stop; the execution's
+        // usage, including the time already spent, survives this process.
+        const budget = workerExecution.budget;
+        budget.onStop((reason) => {
+            logger.warn(`[execution-budget] ${reason}; stopping run=${workerExecution.id}`);
+            session.requestStop();
+        });
+        const disarmDeadline = budget.armDeadline();
+        registerShutdownCallback(() => {
+            disarmDeadline();
+            budget.close();
+            return Promise.resolve();
+        });
+    }
     registerShutdownCallback(async () => {
         // Bound the whole release so it fits the supervisor budgets together with
         // the earlier callbacks (pm2 kill_timeout 30s); a child still closing
@@ -630,26 +727,6 @@ 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,
@@ -672,6 +749,10 @@ export async function startAgentLoop(config, options) {
         // Maintenance owns the session until the current skill/transcript settles.
         // Inbound messages are already durable; process them at the next boundary.
         if (nightlyMaintenance?.isRunning) {
+            // Owner input preempts a Dreaming batch; the step still ends only after
+            // its executor is confirmed stopped.
+            if (isOwnerInitiatedMessage(msg))
+                dreamingRunner?.preempt();
             void interruptHandler.acknowledgeMaintenance(msg);
             return;
         }
@@ -802,6 +883,7 @@ export async function startAgentLoop(config, options) {
     else {
         registerShutdownCallback(() => {
             closeTranscriptMemoryDb();
+            closeUsageReportQueue();
             return Promise.resolve();
         });
     }
@@ -819,9 +901,19 @@ export async function startAgentLoop(config, options) {
         messageQueue,
         engineFallback,
         agentState,
-        singleShot: labRuntimePolicy !== null,
+        singleShot: workerExecution !== null,
     });
     if (!workerMode) {
+        const supervisorForDreaming = threadSupervisor;
+        dreamingRunner = supervisorForDreaming
+            ? new DreamingRunner(new DreamingPlanner({
+                threadIds: () => supervisorForDreaming.getPersistedThreadIds(),
+                vocabularyLearning: () => config.vocabularyLearningEnabled !== false,
+                ownerPublicId: () => ownerConfig.ownerPublicId,
+            }), supervisorForDreaming)
+            : null;
+        if (!dreamingRunner)
+            logger.system("[nightly-maintenance] Dreaming needs the thread supervisor (multiThread); skipped on this profile");
         nightlyMaintenance = new NightlyMaintenance({
             tryAcquire: () => {
                 if (agentState.busy || agentState.learning || agentState.compacting || agentState.gated
@@ -832,12 +924,20 @@ export async function startAgentLoop(config, options) {
                 if (threadSupervisor && !resumeWorkers)
                     return null;
                 executionOwner.setBusy(true, "maintenance");
+                dreamingRunner?.beginStep();
                 heartbeat.nudge();
                 return () => {
-                    agentState.learning = false;
-                    executionOwner.setBusy(false, "maintenance_release");
-                    resumeWorkers?.();
-                    heartbeat.nudge();
+                    // 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();
+                        },
+                    });
                 };
             },
             hasPendingSkills: hasPendingSkillLearning,
@@ -855,18 +955,18 @@ export async function startAgentLoop(config, options) {
                     watchdog.cancel();
                 }
             },
-            dreamingTargets: () => {
+            startDreaming: () => {
                 if (config.vocabularyLearningEnabled !== false && ownerConfig.ownerPublicId) {
                     maintainGlossary(ownerConfig.ownerPublicId);
                 }
-                return threadSupervisor?.getDreamingTargets() ?? resolveDreamingTargets([]);
+                dreamingRunner?.startNight();
             },
-            dream: async (target) => {
-                await runDreamingJob(target.threadId, target.transcriptPath, config, {
-                    vocabularyLearningEnabled: config.vocabularyLearningEnabled,
-                });
+            dreamBatch: async (localDay) => {
+                if (!dreamingRunner)
+                    return "idle";
+                const step = await dreamingRunner.runBatch(localDay);
+                return step.kind;
             },
-            lastDreamedDay: readDeepNightDreamDay,
             canRestart: () => config.nightlyIdleRestartEnabled !== false
                 && process.uptime() * 1000 >= NIGHTLY_RESTART_MIN_UPTIME_MS
                 && detectProcessManager() !== null,
@@ -881,8 +981,14 @@ export async function startAgentLoop(config, options) {
     if (options?.onReady) {
         options.onReady({ agentState, sessionManager: session, messageQueue, ownerConfig });
     }
-    logger.system(labRuntimePolicy
-        ? "Single-shot LabRun loop started. Waiting for its execution dispatch..."
+    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...");
     // =====================================================================
     // 2. Main loop
@@ -900,16 +1006,29 @@ 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) {
-            executionOwner.setBusy(false, "league_hold");
-            agentState.gated = true;
+            // 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;
+                },
+            });
             await new Promise((resolve) => { wakeResolver = resolve; });
             wakeResolver = null;
             continue;
         }
         // --- Reset per-cycle state ---
         messageQueue.beginWakeCycle();
+        // A task handed off in an earlier wake no longer blocks new foreground work.
+        foregroundTasks?.beginWake();
         executionOwner.setBusy(false, "wake_reset");
         agentState.gated = false;
         agentState.stopRequested = false;
@@ -918,7 +1037,6 @@ export async function startAgentLoop(config, options) {
         agentState.notifiedUserThisWake = false;
         agentState.ownerEscalationsThisWake = 0;
         agentState.liveAssistantTexts = new Set();
-        agentState.codingCompletionTaskStartedAt = undefined;
         agentState.learning = false;
         agentState.replyMap.clear();
         session.clearStop();
@@ -950,11 +1068,6 @@ 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
@@ -1003,6 +1116,8 @@ export async function startAgentLoop(config, options) {
                 resolve();
             }
         });
+        if (options?.signal?.aborted)
+            break;
         if (proactiveWakeSchedule.changed && messageQueue.isEmpty()) {
             proactiveWakeSchedule.changed = false;
             nextProactiveWakeAt = null;
@@ -1112,21 +1227,23 @@ export async function startAgentLoop(config, options) {
                     stopRequested: agentState.stopRequested,
                     busy: agentState.busy,
                     recovering,
-                    // No engine has a confirmed execution barrier yet. Pi settlement
-                    // only prevents a send collision; it does not prove the engine stopped.
-                    barrierConfirmed: false,
+                    // 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(),
                 }),
                 legacy: {
                     busy: agentState.busy,
                     gated: agentState.gated,
                     stopRequested: agentState.stopRequested,
                 },
-                barrierConfirmed: false,
+                barrierConfirmed: session.executionBarrierConfirmed(),
             });
         };
         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.
@@ -1147,6 +1264,10 @@ 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);
                 },
             });
@@ -1187,10 +1308,6 @@ 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);
@@ -1203,9 +1320,6 @@ 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");
@@ -1219,18 +1333,12 @@ export async function startAgentLoop(config, options) {
             // batch. Telegram and fin-app may already have enriched their messages at
             // ingress; the shared helper skips those, while QQ, Discord, and
             // other channels get the same cloud/local pipeline.
-            if (trigger === "message" && !labRuntimePolicy) {
+            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));
             }
@@ -1264,9 +1372,6 @@ export async function startAgentLoop(config, options) {
             activityTracker.recordUserMessage(formatMessageSummary(msg));
         }
         logger.wake(trigger, messages.length);
-        if (session.dualSessionEnabled) {
-            logger.system(`Active session: ${session.activeMode}`);
-        }
         if (trigger === "heartbeat") {
             try {
                 await session.activeSession.maybeCompact();
@@ -1320,7 +1425,7 @@ export async function startAgentLoop(config, options) {
             logger.debug(`Pre-warm kick-off failed: ${err instanceof Error ? err.message : String(err)}`);
         });
         // --- Gather context ---
-        const doVersionCheck = !labRuntimePolicy
+        const doVersionCheck = !workerExecution
             && shouldRunProactiveUpgradeCheck(config, trigger)
             && shouldNotifyUpdate();
         // Throttle the wake screenshot: skip on errors, and skip if one was
@@ -1334,7 +1439,7 @@ export async function startAgentLoop(config, options) {
         if (screenshotThrottled) {
             logger.debug(`Skipping wake screenshot (captured ${Math.round((nowMs - lastWakeScreenshotMs) / 1000)}s ago, throttle ${WAKE_SCREENSHOT_MIN_INTERVAL_MS / 1000}s)`);
         }
-        const gathered = labRuntimePolicy
+        const gathered = workerExecution
             ? { calendarSummary: "" }
             : await gatherWakeContext(config, doVersionCheck, skipScreenshot, ownerConfig.heartbeatIntervalMs);
         const { screenshot, calendarSummary, versionUpdate } = gathered;
@@ -1344,25 +1449,26 @@ export async function startAgentLoop(config, options) {
         // Refresh cross-thread awareness so the default thread's wake context lists
         // concurrently-running worker threads. No-op when multiThread is disabled.
         threadSupervisor?.refreshMainProcessAwareness();
-        const contentBlocks = labRuntimePolicy
+        // Foreman: this conversation's open background tasks, from the host's records.
+        const foremanClient = workerExecution ? null : getForemanClient();
+        const backgroundTasks = foremanClient ? await foremanClient.request({ type: "summary" }) : null;
+        const contentBlocks = workerExecution
             ? [{ type: "text", text: messages.map((message) => message.text).join("\n\n") }]
             : await buildWakeContext({
+                ...(backgroundTasks?.ok && backgroundTasks.text ? { backgroundTasksBlock: backgroundTasks.text } : {}),
                 config,
                 trigger,
                 messages,
                 calendarSummary,
                 screenshot,
                 versionUpdate,
-                activeSession: session.dualSessionEnabled ? session.activeMode : undefined,
-                sessionMemos: session.consumeMemosForActive(),
-                codingSessionStatus: session.getCodingSessionStatus(),
                 justUpgraded: isFirstWake ? justUpgraded : null,
                 justRestarted: isFirstWake ? justRestarted : null,
                 ownerReachable: hasUsableOwnerChannel(config, ownerConfig),
             });
         logger.sendMultimodal(contentBlocks);
         // --- Arm watchdog + run cycle ---
-        if (!labRuntimePolicy)
+        if (!workerExecution)
             watchdog.arm(trigger, messages);
         let tuiTerminalOutcome = {
             state: "failed",
@@ -1379,8 +1485,20 @@ 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 {
-            const result = await cycleRunner.run(contentBlocks, trigger, messages, calendarSummary, consecutiveErrors);
+            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.
+            noteMessagesHandedToModel(messages);
+            const result = await cycleRunner.run(contentBlocks, trigger, messages, consecutiveErrors);
             traceLifecycle({
                 runId: lifecycleRunId,
                 stage: "model",
@@ -1389,6 +1507,10 @@ 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.
@@ -1396,9 +1518,24 @@ export async function startAgentLoop(config, options) {
             // done its work: leave the claims in flight so the replacement process
             // replays them on the new engine (issue #2519).
             failoverRestartPending = !restartArmedBeforeWake && engineFallback.isRestartPending();
-            // 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 });
+            // 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();
+            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")
+                    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 (workerMode) {
                 workerMode.relay.finishActivityRun(result.terminalState);
             }
@@ -1412,9 +1549,6 @@ 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) {
@@ -1436,6 +1570,7 @@ 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
@@ -1467,21 +1602,21 @@ export async function startAgentLoop(config, options) {
             // in the shared memories/ tree, so it runs only on the deep-night sweep
             // (`nightly-maintenance.ts`) — once a day, while the agent is idle —
             // rather than after every wake cycle.
-            if (workerMode && !labRuntimePolicy) {
+            if (workerMode && !workerExecution) {
                 workerMode.relay.relayTurnComplete();
             }
         }
-        if (labRuntimePolicy) {
+        if (workerExecution) {
             if (!messageQueue.isEmpty()) {
-                logger.system(`LabRun turn ended with queued work; continuing run=${labRuntimePolicy.policy.runId}`);
+                logger.system(`Worker execution turn ended with queued work; continuing run=${workerExecution.id}`);
                 continue;
             }
-            logger.system(`Single-shot LabRun turn ended; waiting ${LAB_IDLE_GRACE_MS / 1000}s for more messages: run=${labRuntimePolicy.policy.runId}`);
-            if (await waitForLabQueueOrIdle()) {
-                logger.system(`LabRun received more work during idle grace; continuing run=${labRuntimePolicy.policy.runId}`);
+            logger.system(`Single-shot worker turn ended; waiting ${WORKER_EXECUTION_IDLE_GRACE_MS / 1000}s for more messages: run=${workerExecution.id}`);
+            if (await waitForExecutionQueueOrIdle()) {
+                logger.system(`Worker execution received more work during idle grace; continuing run=${workerExecution.id}`);
                 continue;
             }
-            logger.system(`LabRun queue idle for ${LAB_IDLE_GRACE_MS / 1000}s; ending worker run=${labRuntimePolicy.policy.runId}`);
+            logger.system(`Worker execution queue idle for ${WORKER_EXECUTION_IDLE_GRACE_MS / 1000}s; ending worker run=${workerExecution.id}`);
             break;
         }
     }