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

package/dist/threads/supervisor.js

@@ -1,20 +1,10 @@
 /**
- * ThreadSupervisor: orchestrates worker processes for non-default business threads.
- *
- * Responsibilities:
- *  - Spawn worker processes on demand (child_process.fork)
- *  - Route messages to workers by threadId
- *  - Relay worker replies back to real channels
- *  - Enforce concurrency limits (maxConcurrentThreads)
- *  - Idle timeout & graceful worker shutdown
- *  - Crash detection & auto-restart
- *  - Force global commands (/restart, /upgrade, /subscribe, …) to the default thread
- *  - Engine switch (/engine): update thread.json + restart worker
- *  - Worker admission pause for the main process's nightly maintenance
- *  - Graceful supervisor shutdown: notify all workers
+ * Host for foreground conversations and the shared background execution pool.
+ * Chat queues run through ConversationScheduler. Only admitted executions and
+ * LabRuns fork processes; their ledger owns recovery and confirmed stops.
  */
 import { fork } from "node:child_process";
-import { randomBytes, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -22,17 +12,27 @@ import { PUBLIC_ACTIVITY_HISTORY_LIMIT } from "../agent/public-activity.js";
 import { isDeliveryTarget } from "../channels/delivery-target.js";
 import { DEFAULT_THREAD_ID, isEmailChannel, normalizeChannelName } from "../channels/interface.js";
 import { MessageQueue } from "../channels/queue.js";
-import { isThreadTasksEnabled } from "../config/types.js";
-import { taskStorePathForThread, threadHasRunnableTasks } from "./task-store.js";
 import { logger } from "../logger.js";
 import { isOwnerInitiatedMessage } from "../agent/owner-initiated-eligibility.js";
 import { getProfile, getSharedProfileDir, getThreadDir, loadOwnerConfig } from "../config/index.js";
-import { resolveDreamingTargets } from "../agent/nightly-maintenance/memory-dreaming-sweep.js";
 import { resolveFinAppCredentials } from "../finapp-credentials.js";
 import { isWorkerToMainMessage, } from "./ipc.js";
 import { setActiveThreadsSnapshot } from "./active-threads-store.js";
 import { isBundled } from "../utils/version-check.js";
-import { ensureThreadApplication, formatThreadEngineLabel, setThreadEngine } from "./thread-meta.js";
+import { ensureThreadApplication, formatThreadEngineLabel, readThreadMeta, setThreadEngine } from "./thread-meta.js";
+import { getLlmRouting } from "../agent/model-provider.js";
+import { ExecutionStore, isTerminalExecutionState } from "./execution-store.js";
+import { ExecutionScheduler } from "./execution-scheduler.js";
+import { ConversationScheduler } from "../conversations/scheduler.js";
+import { createLazyConversationRuntime } from "../conversations/lazy-runtime.js";
+import { bindRuntimeContext } from "../agent/runtime-context.js";
+import { EXECUTION_VERIFY_KEYS_ENV, createExecutionAuthority, verifyKeysOf, } from "./execution-authority.js";
+import { EXECUTOR_GROUP_REGISTRY_FILE, executorGroupStatus, killExecutorGroupAndWait, reapExitedExecutorGroup, signalExecutorGroup, stopRegisteredGroups, } from "./process-group.js";
+import { ExecutorRefusedError } from "./executor-exit.js";
+import { ExecutionThreadInputError } from "./execution-thread-error.js";
+import { applyExecutionReport } from "./execution-host.js";
+import { genericExecutionThreadId, isGenericExecutionThreadId } from "./generic-execution.js";
+import { DEFAULT_LAB_RUN_BUDGET, EXECUTION_SNAPSHOT_ENV, EXECUTION_SNAPSHOT_VERSION, freezeExecutionModel, readStoredExecutionSnapshot, signExecutionSnapshot, } from "./execution-snapshot.js";
 import { assertMessageApplication, threadApplication } from "./application-context.js";
 import { LAB_RUNTIME_POLICY_ENV, LAB_RUNTIME_POLICY_META_KEY, parseLabRuntimePolicy, signLabRuntimePolicy, verifyLabRuntimePolicyEnvelope, } from "./lab-runtime-policy.js";
 import { isLabRunThreadId } from "./lab-run-thread.js";
@@ -44,6 +44,8 @@ import { ThreadReplyEscalation, threadDeliveryAlert } from "./reply-escalation.j
 import { AgentFeedbackOutbox } from "../agent/feedback-outbox.js";
 import { serializeBrowserRuntimeResolution, serializeDesktopRuntimeResolution, WORKER_BROWSER_RUNTIME_ENV, WORKER_DESKTOP_RUNTIME_ENV, } from "./worker-runtime-resolution.js";
 import { isGlobalCommand } from "./global-commands.js";
+import { getClaudeTranscriptDirForProfileDir } from "../utils/claude-transcripts.js";
+import { isForemanRuntime, supportsTaskRuntime } from "./foreman-protocol.js";
 export { isGlobalCommand } from "./global-commands.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -78,6 +80,11 @@ export function resolveWorkerEntryPoint() {
     // Last resort: whatever entry script started this process.
     return process.argv[1] ?? candidate;
 }
+/** Maintenance executions are owned by the main process's nightly maintenance. */
+const MAINTENANCE_SCOPE = "owner";
+const MAINTENANCE_ENVELOPE = (commandId) => ({
+    commandId, caller: { kind: "nightly", ref: "dreaming" }, scope: MAINTENANCE_SCOPE,
+});
 /**
  * Parse a `/engine <name>` command. Returns the requested engine, or null when
  * the text is not an engine command. Recognized names: `claude`, `gpt`, `grok`, and `deepseek`.
@@ -101,6 +108,8 @@ export function parseEngineCommand(text) {
     return null;
 }
 export class ThreadSupervisor {
+    conversations;
+    foregroundDisabled;
     channelManager;
     messageQueue;
     maxConcurrentThreads;
@@ -111,13 +120,16 @@ export class ThreadSupervisor {
     workerEnv;
     desktopRuntimeResolution;
     browserRuntimeResolution;
-    crashRestartDelayMs;
     threadQueueFactory;
     onFeedback;
     onBusyChange;
     agentInstanceId = randomUUID();
-    /** Per-supervisor HMAC authority; deliberately unrelated to fin-app credentials. */
-    labRuntimePolicySecret = randomBytes(32).toString("base64url");
+    /** Host signing authority, in memory only; deliberately unrelated to fin-app credentials. */
+    executionAuthority;
+    workerStopGraceMs;
+    executorGroups;
+    /** Executor process groups still being emptied after their leader exited. */
+    pendingGroupReaps = new Set();
     latestActivities = new Map();
     replyEscalation = new ThreadReplyEscalation();
     feedbackOutbox = new AgentFeedbackOutbox();
@@ -125,17 +137,18 @@ export class ThreadSupervisor {
     workers = new Map();
     /** Main-process handles for the durable queue.db owned by each thread. */
     threadQueues = new Map();
-    /** Crash counts must outlive WorkerState objects, which are replaced on respawn. */
-    crashCounts = new Map();
-    /** Threads waiting for their bounded crash-backoff timer. */
-    restartTimers = new Map();
-    /** Startup failures / exhausted crash budgets stay dormant until new work arrives. */
-    recoveryExhaustedThreads = new Set();
     /** True once shutdownAll() ran — no new workers may be spawned afterwards. */
     stopped = false;
     maintenancePaused = false;
-    maintenanceMessages = [];
+    /** The one execution the maintenance owner submitted under its pause. */
+    maintenanceExecutionId = null;
+    onMaintenanceInput;
+    handleForemanCommand;
+    handleForemanBusinessRead;
+    executionStore;
+    executionScheduler;
     constructor(options) {
+        this.foregroundDisabled = options.conversationFactory === null;
         this.channelManager = options.channelManager;
         this.messageQueue = options.messageQueue;
         this.maxConcurrentThreads = options.maxConcurrentThreads;
@@ -146,14 +159,71 @@ export class ThreadSupervisor {
         this.workerEnv = options.workerEnv;
         this.desktopRuntimeResolution = options.desktopRuntimeResolution;
         this.browserRuntimeResolution = options.browserRuntimeResolution;
-        this.crashRestartDelayMs = options.crashRestartDelayMs ?? 2000;
+        this.executionAuthority = options.executionAuthority ?? createExecutionAuthority();
+        this.workerStopGraceMs = options.workerStopGraceMs ?? 10_000;
+        this.executorGroups = options.executorGroups ?? {
+            reap: reapExitedExecutorGroup,
+            kill: (pgid) => { signalExecutorGroup(pgid, "SIGKILL"); },
+            status: executorGroupStatus,
+            killAndWait: killExecutorGroupAndWait,
+            stopRegistered: (threadId, timeoutMs) => stopRegisteredGroups(path.join(getThreadDir(threadId), EXECUTOR_GROUP_REGISTRY_FILE), timeoutMs),
+        };
         this.onFeedback = options.onFeedback;
         this.onBusyChange = options.onBusyChange;
+        this.onMaintenanceInput = options.onMaintenanceInput;
+        this.handleForemanCommand = options.handleForemanCommand;
+        this.handleForemanBusinessRead = options.handleForemanBusinessRead;
         this.threadQueueFactory = options.threadQueueFactory ?? ((threadId, recoverInFlight) => {
             const threadDir = getThreadDir(threadId);
             fs.mkdirSync(threadDir, { recursive: true });
             return new MessageQueue(path.join(threadDir, "queue.db"), { recoverInFlight });
         });
+        // Foreground conversation runtimes never use the background worker transport.
+        const conversationCommand = this.handleForemanCommand;
+        this.conversations = !this.foregroundDisabled
+            ? new ConversationScheduler({
+                create: options.conversationFactory ?? ((start) => createLazyConversationRuntime({
+                    ...start,
+                    config: this.config,
+                    foremanClient: conversationCommand && supportsTaskRuntime()
+                        ? { delegationEnabled: isForemanRuntime(this.config), request: bindRuntimeContext((command) => conversationCommand(start.conversationId, command)) }
+                        : null,
+                    desktopRuntimeResolution: this.desktopRuntimeResolution,
+                    browserRuntimeResolution: this.browserRuntimeResolution,
+                })),
+                queue: (id) => this.getThreadQueue(id, false),
+                emit: (id, event, reply) => this.handleConversationEvent(id, event, reply),
+                awareness: (id) => this.getConversationTaskSnapshot(id),
+                onBusyChange: this.onBusyChange,
+                maxConcurrentTurns: this.config.workers?.foregroundConcurrency ?? 2,
+                idleTtlMs: this.idleTimeoutMs,
+            })
+            : null;
+        this.executionStore = options.executionStore === undefined
+            ? new ExecutionStore()
+            : options.executionStore;
+        this.executionScheduler = this.executionStore
+            ? new ExecutionScheduler({
+                store: this.executionStore,
+                host: {
+                    availableSlots: (record) => this.admissionSlotsFor(record),
+                    spawn: (record) => this.spawnExecutionWorker(record),
+                    stop: (executionId, reason) => {
+                        this.shutdownWorker(genericExecutionThreadId(executionId), reason);
+                    },
+                    timeBudgetMs: (record) => this.timeBudgetOf(record.snapshot, record.executionId),
+                },
+                delivery: {
+                    deliverExecutionEvent: options.deliverExecutionEvent ?? (() => Promise.resolve(false)),
+                },
+                groupStatus: (pgid, processStart) => this.executorGroups.status(pgid, processStart),
+                killGroupAndWait: (pgid, processStart, timeoutMs) => this.executorGroups.killAndWait(pgid, processStart, timeoutMs),
+                stopRegisteredGroups: (executionId, timeoutMs) => {
+                    const threadId = isLabRunThreadId(executionId) ? executionId : genericExecutionThreadId(executionId);
+                    return this.executorGroups.stopRegistered(threadId, timeoutMs);
+                },
+            })
+            : null;
         // Rehydrate queues left by a previous daemon process before any worker is
         // spawned. A worker will wake itself from a non-empty queue on startup.
         if (!options.threadQueueFactory && !options.deferRecovery) {
@@ -185,37 +255,46 @@ export class ThreadSupervisor {
         return entries
             .filter((entry) => entry.isDirectory()
             && /^[a-z0-9][a-z0-9-]*$/.test(entry.name)
-            && !isLabRunThreadId(entry.name))
+            && !isLabRunThreadId(entry.name)
+            && !isGenericExecutionThreadId(entry.name))
             .map((entry) => entry.name)
             .sort();
     }
-    /** Maintenance owns execution; the supervisor only supplies persisted targets. */
-    getDreamingTargets() {
-        return resolveDreamingTargets(this.listPersistedThreadIds());
+    /** Persisted business threads whose transcripts Dreaming ingests; never Lab or execution threads. */
+    getPersistedThreadIds() {
+        return this.listPersistedThreadIds();
     }
-    /** Atomically check all worker work and hold admission for one maintenance step. */
+    /**
+     * Atomically check all worker work and hold admission for one maintenance
+     * step. Internal executions count too: maintenance never starts while any
+     * execution runs, is stopping, or waits in the queue.
+     */
     tryPauseForMaintenance() {
-        if (this.stopped || this.maintenancePaused || this.restartTimers.size > 0)
+        if (this.stopped || this.maintenancePaused)
+            return null;
+        if (this.conversations?.hasBusyConversations())
             return null;
         if ([...this.workers.values()].some((worker) => !worker.ready || worker.shuttingDown || this.isWorkerVisiblyBusy(worker)))
             return null;
         if ([...this.threadQueues.values()].some((queue) => queue.hasOutstandingWork()))
             return null;
+        if (this.executionScheduler?.hasOutstandingWork())
+            return null;
         this.maintenancePaused = true;
         return () => {
+            const maintenanceExecution = this.maintenanceExecutionId
+                ? this.executionStore?.get(this.maintenanceExecutionId) ?? null
+                : null;
+            if (maintenanceExecution && !isTerminalExecutionState(maintenanceExecution.state)) {
+                // The step owner always waits for a confirmed stop; keep the writer
+                // fenced rather than admitting others next to a live executor.
+                logger.err(`[supervisor] Maintenance released while execution=${maintenanceExecution.executionId} is ${maintenanceExecution.state}`);
+            }
+            this.maintenanceExecutionId = null;
             this.maintenancePaused = false;
-            const pending = this.maintenanceMessages;
-            this.maintenanceMessages = [];
             if (this.stopped)
-                return; // Accepted ordinary messages are already durable.
-            for (const { msg, threadId } of pending) {
-                try {
-                    this.routeMessage(msg, threadId);
-                }
-                catch (err) {
-                    logger.warn(`[supervisor] Could not resume queued thread=${threadId}: ${String(err)}`);
-                }
-            }
+                return;
+            this.executionScheduler?.requestAdmission();
             this.schedulePendingThreads();
         };
     }
@@ -226,58 +305,16 @@ export class ThreadSupervisor {
             if (queue.hasOutstandingWork()) {
                 logger.system(`[supervisor] Recovered pending work for thread=${threadId}`);
             }
-            else if (this.hasRunnableTasks(threadId)) {
-                logger.system(`[supervisor] Recovered runnable tasks for thread=${threadId}`);
-            }
         }
         this.schedulePendingThreads();
     }
-    /**
-     * Whether a thread without queued messages still has a task that may
-     * start (#1996 PR 5). Its worker queues the resume itself once it runs:
-     * the supervisor only starts it, it never writes the thread's task store.
-     * By design (owner 10-03): a task that is not due yet is not counted;
-     * its due or unblock wake comes from the existing calendar / event-trigger
-     * messages to the thread. Thread tasks never schedule wakes.
-     * TODO: a worker started this way whose first pass queues nothing (gated)
-     * has no idle timer until its first turn, so it holds a slot until evicted.
-     */
-    hasRunnableTasks(threadId) {
-        if (!isThreadTasksEnabled(this.config))
-            return false;
-        return threadHasRunnableTasks(taskStorePathForThread(threadId), threadId);
-    }
-    /**
-     * Start persisted threads whenever a worker slot is available. Work remains
-     * in its queue.db when all slots are busy and is retried after a worker turn
-     * or exit, rather than being rejected or routed to the default thread.
-     */
+    /** Resume durable foreground messages without allocating a worker process. */
     schedulePendingThreads() {
-        if (this.stopped || this.maintenancePaused)
+        if (this.stopped || this.foregroundDisabled)
             return;
-        for (const threadId of this.threadQueues.keys()) {
-            if (this.workers.has(threadId))
-                continue;
-            if (this.restartTimers.has(threadId))
-                continue;
-            if (this.recoveryExhaustedThreads.has(threadId))
-                continue;
-            const queue = this.threadQueues.get(threadId);
-            if (!queue?.hasOutstandingWork() && !this.hasRunnableTasks(threadId))
-                continue;
-            if (this.getActiveWorkerCount() >= this.maxConcurrentThreads) {
-                const evicted = this.evictLeastRecentlyActiveIdleWorker(threadId);
-                if (!evicted && this.getActiveWorkerCount() >= this.maxConcurrentThreads)
-                    break;
-            }
-            try {
-                this.spawnWorker(threadId);
-            }
-            catch (error) {
-                logger.warn(`[supervisor] Failed to recover thread=${threadId}: ${error instanceof Error ? error.message : String(error)}`);
-                this.recoveryExhaustedThreads.add(threadId);
-                this.notifyPendingSendersOfFailure(threadId, this.outstandingMessages(threadId, []));
-            }
+        for (const [id, queue] of this.threadQueues) {
+            if (!isLabRunThreadId(id) && !isGenericExecutionThreadId(id) && queue.hasOutstandingWork())
+                this.conversations?.accept(id);
         }
     }
     /**
@@ -312,6 +349,14 @@ export class ThreadSupervisor {
             logger.system(`[supervisor] Global command "${msg.text.trim().split(/\s+/, 1)[0]}" forced to default thread`);
             return false;
         }
+        // An execution's worker takes input only through its protocol, so every
+        // input is in the ledger. A chat message must not reach it, or start one.
+        if (isGenericExecutionThreadId(threadId)) {
+            logger.warn(`[supervisor] Refusing a chat message for execution thread=${threadId}`);
+            if (!claimRejected)
+                return false;
+            throw new ExecutionThreadInputError();
+        }
         // During shutdown, preserve known app work in its original queue.
         if (this.stopped) {
             // Known application work keeps its original durable queue on shutdown.
@@ -338,7 +383,7 @@ export class ThreadSupervisor {
         }
         // Thread-scoped engine switch: handled by the supervisor (write thread.json
         // + restart worker), NOT forwarded to the worker.
-        const engine = parseEngineCommand(msg.text);
+        const engine = isLabRunThreadId(threadId) ? null : parseEngineCommand(msg.text);
         if (engine !== null) {
             this.switchThreadEngine(threadId, engine, msg);
             return true;
@@ -350,74 +395,46 @@ export class ThreadSupervisor {
         const labRun = isLabRunThreadId(threadId);
         if (labRun && this.maintenancePaused) {
             // Lab owns its retry/lease protocol; do not acknowledge work we cannot
-            // persist. The caller retries admission after this bounded step.
+            // persist. The caller retries admission after this bounded step, which
+            // is preempted so the retry does not wait for a whole Dreaming batch.
+            this.onMaintenanceInput?.();
             if (claimRejected)
                 throw new Error("Nightly maintenance is holding worker admission; retry this delivery");
             return false;
         }
-        let durableInserted = false;
+        if (labRun && !this.workers.has(threadId) && this.labWriterBlocksAdmission(threadId, msg)) {
+            // One writer per Lab workspace: a previous run of this Lab is still
+            // stopping. Reject explicitly; the caller retries once it has stopped.
+            if (claimRejected)
+                throw new Error("A previous run of this Lab is still stopping; retry this delivery");
+            return false;
+        }
         if (!labRun) {
-            durableInserted = this.getThreadQueue(threadId, true).enqueue(msg);
-            // A new provider/request id is an explicit retry after an exhausted
-            // startup/crash budget. Re-enable this thread without letting unrelated
-            // scheduler ticks revive it forever.
-            if (durableInserted && this.recoveryExhaustedThreads.delete(threadId)) {
-                this.crashCounts.delete(threadId);
+            this.getThreadQueue(threadId, true).enqueue(msg);
+            if (this.maintenancePaused && isOwnerInitiatedMessage(msg))
+                this.onMaintenanceInput?.();
+            if (!this.foregroundDisabled) {
+                this.conversations?.accept(threadId, msg);
             }
-        }
-        if (this.maintenancePaused) {
-            this.maintenanceMessages.push({ msg, threadId });
             return true;
         }
         let state = this.workers.get(threadId);
         if (state?.shuttingDown) {
-            logger.debug(`[supervisor] Worker shutting down, buffering message for thread=${threadId}`);
-            const wasVisibleBusy = this.isWorkerVisiblyBusy(state);
-            state.pendingMessages.push(msg);
-            this.emitBusyChangeIfNeeded(wasVisibleBusy, state);
-            return true;
-        }
-        if (!labRun && this.restartTimers.has(threadId)) {
-            logger.debug(`[supervisor] Worker restart already scheduled for thread=${threadId}`);
-            return true;
-        }
-        if (!labRun && this.recoveryExhaustedThreads.has(threadId) && !durableInserted) {
-            logger.debug(`[supervisor] Duplicate work remains dormant after recovery exhaustion: thread=${threadId}`);
-            return true;
+            if (claimRejected)
+                throw new Error("The Lab executor is stopping; retry this delivery");
+            return false;
         }
         if (!state) {
-            // Check concurrency limit before spawning. Idle workers are only a
-            // keep-warm optimization: they must not block a new logical thread from
-            // making progress. If the process pool is full, evict the least-recently
-            // active idle worker first, and reject only when every slot is busy (or
-            // still spawning/shutting down).
             if (this.getActiveWorkerCount() >= this.maxConcurrentThreads) {
-                const evicted = this.evictLeastRecentlyActiveIdleWorker(threadId);
-                if (!evicted && this.getActiveWorkerCount() >= this.maxConcurrentThreads) {
-                    if (labRun) {
-                        // LabRun has its own Fin-app lease and is intentionally not stored
-                        // in the ordinary thread queue. Preserve the pre-existing explicit
-                        // failure contract instead of claiming work that was never saved.
-                        logger.warn(`[supervisor] Concurrency limit reached (${this.maxConcurrentThreads}), rejecting LabRun thread=${threadId}`);
-                        deliverReplyToMessage(this.channelManager, msg, `⚠️ Thread concurrency limit reached (${this.maxConcurrentThreads} active). Please try again later.`).catch(() => { });
-                        return claimRejected;
-                    }
-                    logger.info(`[supervisor] Concurrency limit reached (${this.maxConcurrentThreads}); keeping thread=${threadId} queued`);
-                    this.publishSyntheticActivity(threadId, "queued", "Waiting for a worker slot", [msg]);
-                    // The message is already durably accepted in queue.db. Do not leak
-                    // it into the default thread or ask the provider to retry.
-                    return true;
-                }
+                deliverReplyToMessage(this.channelManager, msg, `⚠️ Worker capacity reached (${this.maxConcurrentThreads} active). Please try again later.`)
+                    .catch(() => { });
+                return claimRejected;
             }
             state = this.spawnWorker(threadId, { bootstrapMessage: msg });
         }
-        // Worker still spawning: buffer the message; flushed on `ready`.
         if (!state.ready) {
-            logger.debug(`[supervisor] Worker spawning, buffering message for thread=${threadId}`);
             const wasVisibleBusy = this.isWorkerVisiblyBusy(state);
             state.pendingMessages.push(msg);
-            // Check all pending messages: only publish status if at least one is owner-initiated
-            this.publishSyntheticActivity(threadId, "queued", "Starting thread worker", state.pendingMessages);
             this.emitBusyChangeIfNeeded(wasVisibleBusy, state);
             return true;
         }
@@ -425,27 +442,11 @@ export class ThreadSupervisor {
         return true;
     }
     getActiveWorkerCount() {
-        let count = 0;
-        for (const state of this.workers.values()) {
-            if (!state.shuttingDown)
-                count += 1;
-        }
-        return count;
-    }
-    evictLeastRecentlyActiveIdleWorker(requestedThreadId) {
-        let candidate = null;
-        for (const state of this.workers.values()) {
-            if (!state.ready || state.busy || state.shuttingDown)
-                continue;
-            if (!candidate || Date.parse(state.lastActivityAt) < Date.parse(candidate.lastActivityAt)) {
-                candidate = state;
-            }
-        }
-        if (!candidate)
-            return false;
-        logger.system(`[supervisor] Evicting idle worker thread=${candidate.threadId} to make room for thread=${requestedThreadId}`);
-        this.shutdownWorker(candidate.threadId, "idle-evicted");
-        return true;
+        // Persisted process records include groups whose leader exited but whose
+        // stop has not been proved. Neither they nor stopping workers free a slot.
+        const untracked = this.executionStore?.liveExecutions()
+            .filter((record) => !this.workers.has(record.executionId)).length ?? this.pendingGroupReaps.size;
+        return this.workers.size + untracked;
     }
     /**
      * Switch a thread's engine: persist the model/provider into thread.json, then
@@ -464,6 +465,7 @@ export class ThreadSupervisor {
             return;
         }
         // Restart the running worker so it re-reads thread.json on next spawn.
+        void this.conversations?.stop(threadId);
         const state = this.workers.get(threadId);
         if (state) {
             this.shutdownWorker(threadId, "engine-switch");
@@ -472,10 +474,370 @@ export class ThreadSupervisor {
         deliverReplyToMessage(this.channelManager, msg, `✅ Thread engine switched to ${engine}. The next message will start a fresh session with a summary of your previous work.`)
             .catch(() => { });
     }
+    /** Start admitting and delivering internal executions (#2805 1c). */
+    startExecutions() {
+        this.executionScheduler?.start();
+    }
+    /** Foreground turns have their own admission pool; execution slots are unrelated. */
+    acquireConversationTurn(signal) {
+        return this.conversations?.acquireTurn(signal) ?? Promise.resolve(() => undefined);
+    }
+    handleConversationEvent(conversationId, event, reply) {
+        if (event.type === "reply") {
+            if (!isDeliveryTarget(event.target)
+                || (event.ownerEscalation === true && !this.isOwnerEscalationTarget(event.target))) {
+                if (event.replyId)
+                    reply({ type: "reply-result", replyId: event.replyId, ok: false, errorMessage: "Invalid conversation reply target" });
+                return;
+            }
+            void this.channelManager.deliver(event.target, event.message, event.attachments, {
+                businessThreadId: event.ownerEscalation ? DEFAULT_THREAD_ID : conversationId,
+                ...(event.kind ? { kind: event.kind } : {}),
+            }).then(() => {
+                this.replyEscalation.success(conversationId);
+                if (event.replyId)
+                    reply({ type: "reply-result", replyId: event.replyId, ok: true });
+            }).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                if (event.replyId)
+                    reply({ type: "reply-result", replyId: event.replyId, ok: false, errorMessage: message });
+                if (this.replyEscalation.failure(conversationId))
+                    void this.alertOwnerOfThreadDeliveryFailure(conversationId, event.target, message);
+            });
+        }
+        else if (event.type === "typing") {
+            if (isDeliveryTarget(event.target))
+                void this.channelManager.sendTyping(event.target).catch(() => { });
+        }
+        else if (event.type === "status" && event.activity) {
+            this.latestActivities.set(conversationId, event.activity);
+            this.channelManager.publishThreadActivity(conversationId, event.activity, this.agentInstanceId);
+        }
+        else if (event.type === "feedback") {
+            const persisted = this.feedbackOutbox.enqueue(event.feedback) ?? this.feedbackOutbox.getPersisted(event.feedback.id);
+            if (persisted)
+                this.onFeedback?.(persisted);
+        }
+    }
+    /**
+     * The execution API for trusted in-process callers. Submissions are
+     * accepted only after the command, record and snapshot are durable.
+     */
+    executionService() {
+        const store = this.executionStore;
+        if (!store)
+            return null;
+        return {
+            atomic: (operation) => store.atomic(operation),
+            attemptsForTask: (taskId, scope) => store.attemptsForTask(taskId, scope),
+            submit: (envelope, input) => {
+                const executionId = `exec-${randomUUID()}`;
+                const outcome = store.submit(envelope, {
+                    ...input,
+                    executionId,
+                    snapshot: this.signExecutionSnapshotFor(executionId, input.budget, envelope.caller),
+                });
+                if (outcome.kind === "ok" && !outcome.replay) {
+                    if (this.maintenancePaused)
+                        this.onMaintenanceInput?.();
+                    this.executionScheduler?.requestAdmission();
+                }
+                return outcome;
+            },
+            sendInput: (envelope, input) => {
+                const outcome = store.sendInput(envelope, input);
+                if (outcome.kind === "ok" && !outcome.replay) {
+                    const record = store.get(input.executionId);
+                    if (record)
+                        this.notifyExecutionChanged(record);
+                    this.forwardExecutionInput(input.executionId);
+                }
+                return outcome;
+            },
+            cancel: (envelope, input) => {
+                const outcome = store.cancel(envelope, input);
+                if (outcome.kind === "ok") {
+                    const record = store.get(input.executionId);
+                    if (record)
+                        this.notifyExecutionChanged(record);
+                }
+                return outcome;
+            },
+            get: (executionId) => store.get(executionId),
+            latestForTask: (taskId, scope) => store.latestForTask(taskId, scope),
+            eventsAfter: (executionId, afterSeq) => store.eventsAfter(executionId, afterSeq),
+        };
+    }
+    /**
+     * The trusted maintenance entry (#2805 stage 2). Only the maintenance owner,
+     * while holding the pause it acquired, may submit; that one execution is the
+     * only work admitted until the hold is released. The caller and scope are
+     * fixed here, never taken from the payload.
+     */
+    submitMaintenanceExecution(input) {
+        const store = this.executionStore;
+        if (!store || !this.executionScheduler)
+            throw new Error("Internal executions are unavailable");
+        if (!this.maintenancePaused)
+            throw new Error("Maintenance does not hold worker admission");
+        if (this.maintenanceExecutionId)
+            throw new Error("A maintenance execution is already registered");
+        const executionId = `exec-${randomUUID()}`;
+        const outcome = store.submit(MAINTENANCE_ENVELOPE(`maintenance-${input.taskId}`), {
+            taskId: input.taskId,
+            payload: input.payload,
+            executionId,
+            snapshot: this.signExecutionSnapshotFor(executionId, input.budget),
+        });
+        if (outcome.kind !== "ok")
+            throw new Error(`Maintenance execution was not accepted: ${outcome.reason}`);
+        this.maintenanceExecutionId = outcome.value.executionId;
+        this.executionScheduler.requestAdmission();
+        const record = store.get(outcome.value.executionId);
+        if (!record)
+            throw new Error("Maintenance execution disappeared after submit");
+        return record;
+    }
+    /** Preempt the maintenance execution: cancel it; it ends only after its executor stops. */
+    cancelMaintenanceExecution(reason) {
+        const store = this.executionStore;
+        const executionId = this.maintenanceExecutionId;
+        if (!store || !executionId)
+            return;
+        const outcome = store.cancel(MAINTENANCE_ENVELOPE(`maintenance-cancel-${randomUUID()}`), { executionId, reason });
+        const record = store.get(executionId);
+        if (outcome.kind === "ok" && record)
+            this.notifyExecutionChanged(record);
+    }
+    /**
+     * While maintenance holds admission only its registered execution starts.
+     * A maintenance execution starts only under that hold, never on its own.
+     */
+    admissionSlotsFor(record) {
+        if (this.stopped)
+            return 0;
+        const maintenance = record.caller.kind === "nightly";
+        const admitted = maintenance
+            ? this.maintenancePaused && record.executionId === this.maintenanceExecutionId
+            : !this.maintenancePaused;
+        if (!admitted)
+            return 0;
+        const parent = record.payload.parentTaskId ?? record.taskId;
+        const perTask = this.config.workers?.maxConcurrentPerTask ?? this.maxConcurrentThreads;
+        const live = this.executionStore?.liveExecutions() ?? [];
+        if (live.filter((item) => (item.payload.parentTaskId ?? item.taskId) === parent).length >= perTask)
+            return 0;
+        return this.maxConcurrentThreads - this.getActiveWorkerCount();
+    }
+    /**
+     * After its outcome is applied, remove what a finished maintenance
+     * execution holds of memory and conversation text: its worker directory,
+     * its transcripts, and the report content in the execution ledger. The
+     * Dreaming edit log and backups are the record that is kept.
+     */
+    discardMaintenanceExecutionContent(executionId) {
+        const record = this.executionStore?.get(executionId);
+        if (record?.caller.kind !== "nightly" || !isTerminalExecutionState(record.state))
+            return;
+        this.executionStore?.redactResultContent(executionId);
+        const threadDir = getThreadDir(genericExecutionThreadId(executionId));
+        try {
+            fs.rmSync(getClaudeTranscriptDirForProfileDir(threadDir), { recursive: true, force: true });
+            fs.rmSync(threadDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            logger.warn(`[supervisor] Could not remove files of maintenance execution ${executionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /** Cancel a maintenance execution left queued by a previous host; nothing else. */
+    cancelStaleMaintenanceExecution(executionId) {
+        const store = this.executionStore;
+        const record = store?.get(executionId) ?? null;
+        if (!store || record?.caller.kind !== "nightly" || record.state !== "queued")
+            return record;
+        store.cancel(MAINTENANCE_ENVELOPE(`maintenance-cancel-${randomUUID()}`), { executionId, reason: "left by a previous host" });
+        return store.get(executionId);
+    }
+    getExecutionRecord(executionId) {
+        return this.executionStore?.get(executionId) ?? null;
+    }
+    latestExecutionForTask(taskId) {
+        return this.executionStore?.latestForTask(taskId, MAINTENANCE_SCOPE) ?? null;
+    }
+    /** Observe every committed execution event (live streams such as TUI SSE). */
+    onExecutionEvent(listener) {
+        return this.executionStore?.onEvent(listener) ?? (() => undefined);
+    }
+    /** The time budget frozen in an execution's stored snapshot. */
+    timeBudgetOf(rawSnapshot, executionId) {
+        try {
+            return readStoredExecutionSnapshot(rawSnapshot, executionId).budget.maxDurationMs;
+        }
+        catch (error) {
+            logger.warn(`[supervisor] No host deadline for execution=${executionId}: ${error instanceof Error ? error.message : String(error)}`);
+            return null;
+        }
+    }
+    /** A command changed an execution: admit queued work and stop cancelled executors. */
+    notifyExecutionChanged(record) {
+        if (!this.executionScheduler)
+            return;
+        if (record.state === "cancel_requested")
+            this.executionScheduler.requestStop(record.executionId, "cancel_requested");
+        if (record.state === "queued")
+            this.executionScheduler.requestAdmission();
+    }
+    /**
+     * Give a LabRun the same host execution record as other executions
+     * (#2805 1d). LabRun keeps its own Fin-App lease and explicit-rejection
+     * capacity contract, so it is admitted and started here in one step rather
+     * than queued. A crash-free restart of the host finds the record and its
+     * executor pid, and can prove that executor stopped before any retry runs.
+     */
+    recordLabExecution(state, envelope, snapshot) {
+        const store = this.executionStore;
+        const pid = state.process.pid;
+        if (!store || pid === undefined)
+            return;
+        const { policy } = verifyLabRuntimePolicyEnvelope(envelope, this.labPolicyVerifyKey(), state.threadId);
+        try {
+            const record = store.admitAndStart({
+                executionId: state.threadId,
+                taskId: `lab-run-${policy.runId}`,
+                scope: policy.tenantId,
+                caller: { kind: "lab", ref: policy.runId },
+                payload: { goal: `LabRun ${policy.runId} for Lab ${policy.labId}`, workspaceRef: `lab:${policy.labId}` },
+                snapshot: JSON.stringify(snapshot),
+                process: { pid, processStart: new Date().toISOString() },
+            });
+            state.labExecution = { executionId: record.executionId, generation: record.workerInstanceId };
+        }
+        catch (error) {
+            // The Lab lease protocol remains authoritative; a ledger failure is logged, not fatal.
+            logger.warn(`[supervisor] Could not record LabRun execution ${state.threadId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * The LabRun executor exited. Its terminal facts already went to Fin-App
+     * through lab_run_control; the ledger records that the writer is gone so the
+     * shared Lab workspace may admit the next run. Lab never auto-resumes: a
+     * retry is a new LabRun.
+     */
+    confirmLabExecutionStopped(execution, code) {
+        const store = this.executionStore;
+        if (!store)
+            return;
+        const record = store.get(execution.executionId);
+        if (record?.state === "running" && record.result === null) {
+            store.completeExecution(execution.executionId, execution.generation, code === 0
+                ? { status: "succeeded", processedInputSeq: record.inputSeq, summary: "LabRun executor finished; terminal facts were reported to Fin-App" }
+                : { status: "failed", processedInputSeq: record.inputSeq, error: { code: "executor_exit", message: `LabRun executor exited with code ${String(code)}` } });
+        }
+        store.confirmStopped(execution.executionId, execution.generation, {
+            status: "failed",
+            error: { code: "executor_exit", message: "LabRun executor stopped" },
+        });
+    }
+    /**
+     * Fin-App cancelled a LabRun, or its lease is gone. Record the request and
+     * stop the executor; the record turns `cancelled` only after the process exits.
+     */
+    cancelLabRun(runId, reason) {
+        const threadId = `fin-lab-run-${runId}`;
+        const record = this.executionStore?.requestHostCancel(threadId, reason);
+        const running = this.workers.has(threadId);
+        if (running)
+            this.shutdownWorker(threadId, `lab-cancel: ${reason}`.slice(0, 200));
+        return record !== null || running;
+    }
+    /** A new LabRun may not start while another run of the same Lab still has a live executor. */
+    labWriterBlocksAdmission(threadId, msg) {
+        let labId;
+        let runId;
+        try {
+            const envelope = this.authorizeLabRuntimePolicy(threadId, msg.meta?.[LAB_RUNTIME_POLICY_META_KEY]);
+            ({ labId, runId } = verifyLabRuntimePolicyEnvelope(envelope, this.labPolicyVerifyKey(), threadId).policy);
+        }
+        catch {
+            return false; // Policy errors are reported by the normal spawn path.
+        }
+        return this.hasLiveLabWriter(labId, runId);
+    }
+    /**
+     * Whether a Lab workspace may admit a new writer. Both this host's live
+     * workers and the ledger count: a LabRun that is running or stopping, or
+     * whose executor (including survivors in its process group) is not yet
+     * confirmed stopped, is still a writer, also across a host restart.
+     */
+    hasLiveLabWriter(labId, exceptRunId) {
+        for (const state of this.workers.values()) {
+            if (!isLabRunThreadId(state.threadId) || !state.labRuntimePolicy)
+                continue;
+            const { policy } = verifyLabRuntimePolicyEnvelope(state.labRuntimePolicy, this.labPolicyVerifyKey(), state.threadId);
+            if (policy.labId === labId && policy.runId !== exceptRunId)
+                return true;
+        }
+        return this.executionStore?.hasLiveWriter(`lab:${labId}`, exceptRunId === undefined ? undefined : `fin-lab-run-${exceptRunId}`) ?? false;
+    }
+    /**
+     * Forward accepted input to a running executor; a stopped one reads it on
+     * resume. An executor that is stopping gets nothing: it would consume the
+     * input and exit before its model could see it.
+     */
+    forwardExecutionInput(executionId) {
+        const store = this.executionStore;
+        const state = this.workers.get(genericExecutionThreadId(executionId));
+        if (!store || state?.execution?.executionId !== executionId || !state.ready || state.shuttingDown || !state.process.connected)
+            return;
+        const record = store.get(executionId);
+        if (!record)
+            return;
+        for (const input of store.pendingInputs(executionId, record.processedInputSeq)) {
+            state.process.send({
+                type: "execution-input",
+                executionId,
+                inputSeq: input.inputSeq,
+                questionId: input.questionId,
+                text: input.text,
+            });
+        }
+    }
+    /**
+     * Fork the executor for an admitted generic execution. It shares the
+     * ordinary worker pool and its restrictions; its snapshot is frozen here.
+     */
+    spawnExecutionWorker(record) {
+        const threadId = genericExecutionThreadId(record.executionId);
+        // The ledger records what was admitted. Re-sign it with this host's key:
+        // the stored signature may be from a host process that no longer exists.
+        let snapshot;
+        try {
+            snapshot = JSON.stringify(signExecutionSnapshot(readStoredExecutionSnapshot(record.snapshot, record.executionId), this.authority().snapshot));
+        }
+        catch (error) {
+            throw new ExecutorRefusedError(`Execution ${record.executionId} has an unusable snapshot: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        ensureThreadApplication(threadId, "gru");
+        const state = this.spawnWorker(threadId, {
+            execution: { executionId: record.executionId, snapshot },
+        });
+        const pid = state.process.pid;
+        if (pid === undefined)
+            throw new Error(`Execution worker for ${record.executionId} did not start`);
+        state.execution = { executionId: record.executionId, generation: record.workerInstanceId + 1 };
+        if (record.caller.kind === "nightly")
+            state.privateActivity = true;
+        if (record.caller.kind === "general")
+            state.foreman = true;
+        return { pid, processStart: new Date().toISOString() };
+    }
     /**
      * Spawn a worker process for the given threadId.
      */
     spawnWorker(threadId, options = {}) {
+        if (!options.execution && !isLabRunThreadId(threadId)) {
+            throw new Error("Only admitted Tasks and LabRuns may start worker processes");
+        }
         logger.system(`[supervisor] Spawning worker for thread=${threadId}`);
         const threadMeta = ensureThreadApplication(threadId, options.bootstrapMessage?.app);
         threadApplication(threadId, this.config);
@@ -492,9 +854,26 @@ export class ThreadSupervisor {
         if (labRuntimePolicy) {
             // Resolve the trusted tenant/Lab identity before fork. This catches a
             // symlink or tenant-marker collision even if the worker entry never runs.
-            ensureLabWorkspace(verifyLabRuntimePolicyEnvelope(labRuntimePolicy, this.labPolicySecret(), threadId), getSharedProfileDir());
+            ensureLabWorkspace(verifyLabRuntimePolicyEnvelope(labRuntimePolicy, this.labPolicyVerifyKey(), threadId), getSharedProfileDir());
             workerEnv[LAB_RUNTIME_POLICY_ENV] = JSON.stringify(labRuntimePolicy);
-            workerEnv.VISIONCLAW_LAB_POLICY_SECRET = this.labPolicySecret();
+        }
+        // Workers verify with public keys only; no signing key leaves this host.
+        // (fork skips undefined values, so an inherited copy is never passed on.)
+        delete workerEnv.VISIONCLAW_LAB_POLICY_SECRET;
+        const internalExecution = labRuntimePolicy !== undefined || options.execution !== undefined;
+        workerEnv[EXECUTION_VERIFY_KEYS_ENV] = internalExecution
+            ? JSON.stringify(verifyKeysOf(this.authority()))
+            : undefined;
+        // Freeze the execution snapshot once, at admission. Respawns of the same
+        // run reuse it, so editable thread.json or routing changes cannot alter it.
+        const executionSnapshot = labRuntimePolicy
+            ? options.trustedExecutionSnapshot ?? this.admitExecutionSnapshot(threadId)
+            : undefined;
+        if (executionSnapshot)
+            workerEnv[EXECUTION_SNAPSHOT_ENV] = JSON.stringify(executionSnapshot);
+        if (options.execution) {
+            workerEnv[EXECUTION_SNAPSHOT_ENV] = options.execution.snapshot;
+            workerEnv.VISIONCLAW_EXECUTION_ID = options.execution.executionId;
         }
         if (this.desktopRuntimeResolution) {
             workerEnv[WORKER_DESKTOP_RUNTIME_ENV] = serializeDesktopRuntimeResolution(this.desktopRuntimeResolution);
@@ -506,6 +885,9 @@ export class ThreadSupervisor {
             stdio: ["inherit", "inherit", "inherit", "ipc"],
             cwd: process.cwd(),
             env: workerEnv,
+            // An internal executor leads its own process group, and its commands
+            // stay in it, so a stop can reach every process it started.
+            ...(internalExecution && process.platform !== "win32" ? { detached: true } : {}),
             ...(this.workerExecPath ? { execPath: this.workerExecPath } : {}),
         });
         const state = {
@@ -516,11 +898,14 @@ export class ThreadSupervisor {
             busy: false,
             taskDescription: "spawning",
             lastActivityAt: new Date().toISOString(),
-            idleTimer: null,
             shuttingDown: false,
             pendingMessages: [],
+            internalExecution,
             ...(labRuntimePolicy ? { labRuntimePolicy: this.freezeLabRuntimePolicy(labRuntimePolicy) } : {}),
+            ...(executionSnapshot ? { executionSnapshot: Object.freeze({ ...executionSnapshot }) } : {}),
         };
+        if (labRuntimePolicy && executionSnapshot)
+            this.recordLabExecution(state, labRuntimePolicy, executionSnapshot);
         this.workers.set(threadId, state);
         child.on("message", (data) => {
             this.handleWorkerMessage(threadId, data);
@@ -547,6 +932,13 @@ export class ThreadSupervisor {
             case "lab-runtime-bootstrap-failed":
                 this.handleLabRuntimeBootstrapFailed(state, data);
                 break;
+            case "lab-runtime-lease-lost":
+                if (!isLabRunThreadId(state.threadId) || data.threadId !== state.threadId)
+                    break;
+                logger.warn(`[supervisor] LabRun lease lost: thread=${state.threadId} reason=${data.errorMessage}`);
+                this.executionStore?.requestHostCancel(state.threadId, `lease lost: ${data.errorMessage}`);
+                this.shutdownWorker(state.threadId, "lab-lease-lost");
+                break;
             case "ready":
                 this.handleReady(state, data);
                 break;
@@ -554,28 +946,101 @@ export class ThreadSupervisor {
                 this.handleReply(state, data);
                 break;
             case "typing":
-                this.handleTyping(state, data);
                 break;
             case "status":
                 this.handleStatus(state, data);
                 break;
             case "feedback":
-                this.handleFeedback(state, data);
                 break;
             case "turn-complete":
-                this.handleTurnComplete(state, data);
+                break;
+            case "execution-bootstrap-ready":
+                this.handleExecutionBootstrap(state);
+                break;
+            case "execution-result":
+            case "execution-progress":
+            case "execution-question":
+            case "execution-input-applied":
+            case "execution-tool":
+            case "execution-usage":
+                if (!state.execution || !this.executionStore || !this.executionScheduler) {
+                    logger.warn(`[supervisor] Ignoring execution report from non-execution thread=${threadId}`);
+                    break;
+                }
+                applyExecutionReport(this.executionStore, this.executionScheduler, state.execution, data);
+                break;
+            case "foreman-request":
+                this.handleForemanRequest(state, data);
                 break;
         }
     }
-    handleFeedback(state, msg) {
-        logger.debug(`[supervisor] Feedback received from thread=${state.threadId}: ${msg.feedback.id}`);
-        const persisted = this.feedbackOutbox.enqueue(msg.feedback)
-            ?? this.feedbackOutbox.getPersisted(msg.feedback.id);
-        if (!persisted)
+    /**
+     * A conversational worker's background-task command. The thread is the
+     * worker this supervisor started for it, never a value from the message;
+     * internal executions (Lab, Dreaming, Foreman workers) cannot delegate.
+     */
+    handleForemanRequest(state, msg) {
+        const answer = (result) => {
+            if (state.shuttingDown || !state.process.connected)
+                return;
+            try {
+                state.process.send({ type: "foreman-response", requestId: msg.requestId, result });
+            }
+            catch (error) {
+                logger.warn(`[supervisor] Could not answer a background-task command from thread=${state.threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        };
+        if (typeof msg.requestId !== "string")
             return;
-        this.onFeedback?.(persisted);
-        // Main HeartbeatManager will discover this durable item on its next tick.
-        logger.debug(`[supervisor] Persisted feedback from thread=${state.threadId}: ${persisted.id}`);
+        if (state.internalExecution && msg.command.type === "business_read") {
+            const expected = state.execution;
+            const record = expected ? this.executionStore?.get(expected.executionId) : null;
+            if (!record || state.shuttingDown || record.state !== "running" || record.caller.kind !== "general"
+                || record.workerInstanceId !== expected?.generation || !record.payload.businessRead || !this.handleForemanBusinessRead) {
+                answer({ ok: false, text: "Business reads require a live authorized Foreman execution" });
+                return;
+            }
+            const workspace = record.payload.workspaceRef ?? path.join(getThreadDir(state.threadId), "workspace");
+            this.handleForemanBusinessRead(record.executionId, msg.command, workspace).then((result) => {
+                const current = this.executionStore?.get(record.executionId);
+                if (current?.state === "running" && current.workerInstanceId === expected.generation)
+                    answer(result);
+                else
+                    answer({ ok: false, text: "The execution stopped before the business read completed" });
+            }).catch((error) => answer({ ok: false, text: `Business read failed: ${error instanceof Error ? error.message : String(error)}` }));
+            return;
+        }
+        answer({ ok: false, text: "Internal executions cannot delegate or control other Tasks" });
+    }
+    /**
+     * The executor is listening: hand it the admitted record from the ledger.
+     * Workers never open the ledger themselves.
+     */
+    handleExecutionBootstrap(state) {
+        const store = this.executionStore;
+        const execution = state.execution;
+        if (!store || !execution) {
+            logger.warn(`[supervisor] Refusing execution bootstrap for non-execution thread=${state.threadId}`);
+            return;
+        }
+        const record = store.get(execution.executionId);
+        if (record?.workerInstanceId !== execution.generation) {
+            logger.warn(`[supervisor] Execution ${execution.executionId} has no record for generation ${execution.generation}; stopping its executor`);
+            this.shutdownWorker(state.threadId, "no_admitted_record");
+            return;
+        }
+        state.process.send({
+            type: "execution-start",
+            record,
+            unfinishedTools: store.unfinishedToolCalls(record.executionId),
+            // input_applied is a session handoff cursor, not a durable provider
+            // receipt. A crash between that cursor and the SDK's transcript write
+            // must not erase an accepted answer. Replay the authoritative history.
+            pendingInputs: store.pendingInputs(record.executionId, 0),
+        }, (error) => {
+            if (error)
+                logger.debug(`[supervisor] Execution start IPC unavailable for ${state.threadId}: ${error.message}`);
+        });
     }
     handleLabRuntimeBootstrapReady(state) {
         if (!state.labRuntimePolicy || !isLabRunThreadId(state.threadId)) {
@@ -602,7 +1067,7 @@ export class ThreadSupervisor {
         }
         let policy;
         try {
-            policy = verifyLabRuntimePolicyEnvelope(state.labRuntimePolicy, this.labPolicySecret(), state.threadId).policy;
+            policy = verifyLabRuntimePolicyEnvelope(state.labRuntimePolicy, this.labPolicyVerifyKey(), state.threadId).policy;
         }
         catch (error) {
             logger.warn(`[supervisor] Refusing invalid Lab bootstrap failure policy: ${error instanceof Error ? error.message : String(error)}`);
@@ -640,6 +1105,9 @@ export class ThreadSupervisor {
             logger.debug(`[supervisor] Worker became ready while shutting down: thread=${state.threadId}`);
             return;
         }
+        // Input accepted after the executor's start record was read: hand it over now.
+        if (state.execution)
+            this.forwardExecutionInput(state.execution.executionId);
         // Flush any messages buffered while the worker was spawning, in order.
         if (state.pendingMessages.length > 0) {
             const pending = state.pendingMessages;
@@ -651,43 +1119,7 @@ export class ThreadSupervisor {
         }
     }
     handleReply(state, msg) {
-        if (!isDeliveryTarget(msg.target)) {
-            const errorMessage = "worker reply contained an invalid target";
-            logger.warn(`[supervisor] ${errorMessage}`);
-            this.sendReplyResult(state, msg.replyId, false, errorMessage);
-            return;
-        }
-        // A worker's sends belong to its thread, so mail adapters record provider
-        // replies against it. An owner escalation must not: the owner's answer is
-        // private to the owner's own (default) conversation. The marker is only
-        // honored for a real owner target resolved here, in the main process.
-        let businessThreadId = state.threadId;
-        if (msg.ownerEscalation === true) {
-            if (!this.isOwnerEscalationTarget(msg.target)) {
-                const errorMessage = "owner escalation target is not a bound owner target";
-                logger.warn(`[supervisor] Refused reply from thread=${state.threadId}: ${errorMessage}`);
-                this.sendReplyResult(state, msg.replyId, false, errorMessage);
-                return;
-            }
-            businessThreadId = DEFAULT_THREAD_ID;
-        }
-        logger.debug(`[supervisor] Relaying reply from channel=${msg.target.channel}`);
-        this.channelManager.deliver(msg.target, msg.message, msg.attachments, {
-            businessThreadId,
-            ...(msg.kind ? { kind: msg.kind } : {}),
-        })
-            .then(() => {
-            this.replyEscalation.success(state.threadId);
-            this.sendReplyResult(state, msg.replyId, true);
-        })
-            .catch((err) => {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            logger.warn(`[supervisor] Failed to relay reply: ${errorMessage}`);
-            this.sendReplyResult(state, msg.replyId, false, errorMessage);
-            if (this.replyEscalation.failure(state.threadId)) {
-                void this.alertOwnerOfThreadDeliveryFailure(state.threadId, msg.target, errorMessage);
-            }
-        });
+        this.sendReplyResult(state, msg.replyId, false, "Internal worker executions cannot deliver external messages");
     }
     /** True when `target` is one of the owner's usable bound targets (no reply context). */
     isOwnerEscalationTarget(target) {
@@ -743,17 +1175,8 @@ export class ThreadSupervisor {
             logger.debug(`[supervisor] Could not ack reply ${replyId}: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
-    handleTyping(_state, msg) {
-        if (!isDeliveryTarget(msg.target)) {
-            logger.warn("[supervisor] Worker typing contained an invalid target");
-            return;
-        }
-        this.channelManager.sendTyping(msg.target).catch(() => {
-            // best-effort
-        });
-    }
     handleStatus(state, msg) {
-        if (msg.activity) {
+        if (msg.activity && !state.privateActivity) {
             const current = state.activity;
             const known = this.latestActivities.get(state.threadId);
             const wrongWorker = state.workerInstanceId !== undefined
@@ -774,38 +1197,13 @@ export class ThreadSupervisor {
         // fenced projection still proves whether this worker is busy or idle.
         const wasVisibleBusy = this.isWorkerVisiblyBusy(state);
         state.busy = msg.busy;
-        state.taskDescription = msg.taskDescription;
+        state.taskDescription = state.privateActivity ? "nightly maintenance" : msg.taskDescription;
         state.lastActivityAt = msg.lastActivityAt;
         this.emitBusyChangeIfNeeded(wasVisibleBusy, state);
-        if (!msg.busy)
+        if (!msg.busy) {
             this.schedulePendingThreads();
-    }
-    handleTurnComplete(state, _msg) {
-        logger.system(`[supervisor] Turn complete from thread=${state.threadId}`);
-        // A completed turn proves the worker is healthy — reset its crash budget so
-        // sporadic crashes spread over a long lifetime don't exhaust the cap.
-        this.crashCounts.delete(state.threadId);
-        this.recoveryExhaustedThreads.delete(state.threadId);
-        // Billing is NOT handled here: the worker's own WakeCycleRunner already
-        // wrote the wake-cycle row into the shared transcript-memory.db (WAL-safe).
-        // Memory dreaming is not triggered here either: it rewrites and deletes
-        // files in the shared memories/ tree, so it runs on the deep-night sweep
-        // only (owned by NightlyMaintenance), not once per wake cycle.
-        this.armIdleTimer(state);
-        this.schedulePendingThreads();
-    }
-    armIdleTimer(state) {
-        if (state.idleTimer !== null) {
-            clearTimeout(state.idleTimer);
+            this.executionScheduler?.requestAdmission();
         }
-        state.idleTimer = setTimeout(() => {
-            if (state.busy) {
-                logger.debug(`[supervisor] Worker still busy at idle timeout, extending: thread=${state.threadId}`);
-                this.armIdleTimer(state);
-                return;
-            }
-            this.shutdownWorker(state.threadId, "idle-timeout");
-        }, this.idleTimeoutMs);
     }
     handleWorkerExit(threadId, code, signal) {
         const state = this.workers.get(threadId);
@@ -814,11 +1212,6 @@ export class ThreadSupervisor {
         const wasReady = state.ready;
         logger.system(`[supervisor] Worker exited: thread=${threadId} code=${code} signal=${signal} wasReady=${wasReady}`);
         // Clear idle timer.
-        if (state.idleTimer !== null) {
-            clearTimeout(state.idleTimer);
-            state.idleTimer = null;
-        }
-        const pendingMessages = state.pendingMessages;
         if (state.busy && state.activity && !state.shuttingDown) {
             const now = new Date().toISOString();
             const failedActivity = {
@@ -840,113 +1233,51 @@ export class ThreadSupervisor {
         this.workers.delete(threadId);
         if (wasVisibleBusy)
             this.onBusyChange?.();
-        // LabRun workers are single-shot executors. A retry is a new durable run
-        // with a new `fin-lab-run-<runId>` thread; never revive the old session.
-        if (isLabRunThreadId(threadId)) {
-            this.crashCounts.delete(threadId);
-            this.schedulePendingThreads();
-            return;
-        }
-        // Clean exit, or any exit during a requested shutdown (a graceful stop that
-        // ends non-zero is not a crash): don't count towards the crash cap. Respawn
-        // only when messages arrived during the shutdown window — but never after
-        // the supervisor itself has been stopped.
-        if (code === 0 || state.shuttingDown) {
-            if (code === 0)
-                this.crashCounts.delete(threadId);
-            if (pendingMessages.length > 0 && !this.stopped) {
-                this.spawnWorkerForPendingMessages(threadId, pendingMessages, "shutdown-respawn", state.labRuntimePolicy);
-            }
-            this.schedulePendingThreads();
-            return;
-        }
-        // Crash recovery: restart if crashed unexpectedly and under threshold.
-        const MAX_CRASH_COUNT = 3;
-        const nextCrashCount = wasReady ? (this.crashCounts.get(threadId) ?? 0) + 1 : this.crashCounts.get(threadId) ?? 0;
-        if (wasReady) {
-            this.crashCounts.set(threadId, nextCrashCount);
-        }
-        if (wasReady && nextCrashCount <= MAX_CRASH_COUNT && !this.stopped) {
-            logger.warn(`[supervisor] Worker crashed, restarting (attempt ${nextCrashCount}/${MAX_CRASH_COUNT}): thread=${threadId}`);
-            // Re-spawn after a brief delay.
-            const trustedLabRuntimePolicy = state.labRuntimePolicy;
-            const timer = setTimeout(() => {
-                this.restartTimers.delete(threadId);
-                if (this.stopped || this.maintenancePaused || this.workers.has(threadId))
-                    return;
-                try {
-                    const next = this.spawnWorker(threadId, {
-                        bootstrapMessage: pendingMessages[0],
-                        trustedLabRuntimePolicy,
-                    });
-                    this.enqueuePendingWork(next, pendingMessages);
-                }
-                catch (error) {
-                    this.handleWorkerRespawnFailure(threadId, pendingMessages, "crash-restart", error);
-                }
-            }, this.crashRestartDelayMs);
-            this.restartTimers.set(threadId, timer);
+        // Any exit frees a slot that queued executions may take.
+        this.executionScheduler?.requestAdmission();
+        // An internal executor's stop is confirmed only once its whole process
+        // group is gone, so background jobs it started cannot outlive it.
+        if (state.execution || state.labExecution) {
+            this.confirmExecutorGroupStopped(state, code, signal);
             this.schedulePendingThreads();
             return;
         }
-        // Not restarting: either the worker died before ever becoming ready
-        // (startup failure — restarting would loop) or the crash cap is exhausted.
-        // Tell the senders of any buffered messages instead of dropping silently.
-        if (nextCrashCount > MAX_CRASH_COUNT) {
-            logger.err(`[supervisor] Worker crash limit exceeded, not restarting: thread=${threadId}`);
-        }
-        else {
-            logger.err(`[supervisor] Worker failed during startup, not restarting: thread=${threadId}`);
-        }
-        this.recoveryExhaustedThreads.add(threadId);
-        this.notifyPendingSendersOfFailure(threadId, this.outstandingMessages(threadId, pendingMessages));
+        // A refused Lab bootstrap may exit before registering an execution.
+        // Its service owns retries; there are no conversational process respawns.
         this.schedulePendingThreads();
     }
-    spawnWorkerForPendingMessages(threadId, pending, reason, trustedLabRuntimePolicy) {
-        if (pending.length === 0)
-            return;
-        if (this.getActiveWorkerCount() >= this.maxConcurrentThreads) {
-            const evicted = this.evictLeastRecentlyActiveIdleWorker(threadId);
-            if (!evicted && this.getActiveWorkerCount() >= this.maxConcurrentThreads) {
-                logger.warn(`[supervisor] Cannot respawn worker for thread=${threadId} after ${reason}: concurrency limit reached`);
-                if (isLabRunThreadId(threadId)) {
-                    this.notifyPendingSendersOfFailure(threadId, pending);
+    /**
+     * The executor's leader exited. Empty its process group (the forked
+     * process leads it), then resolve the execution. A group that cannot be
+     * emptied keeps the execution, and a Lab's workspace, blocked.
+     */
+    confirmExecutorGroupStopped(state, code, signal) {
+        const pgid = state.process.pid;
+        const hostStopping = this.stopped;
+        const reap = (pgid === undefined || process.platform === "win32"
+            ? Promise.resolve(true)
+            : Promise.all([
+                this.executorGroups.reap(pgid, this.workerStopGraceMs),
+                this.executorGroups.stopRegistered(state.threadId, this.workerStopGraceMs),
+            ]).then((results) => results.every(Boolean)))
+            .catch(() => false)
+            .then((groupStopped) => {
+            if (state.execution) {
+                this.executionScheduler?.handleWorkerExit(state.execution.executionId, code, signal, { hostStopping, groupStopped });
+            }
+            else if (state.labExecution) {
+                if (groupStopped) {
+                    this.confirmLabExecutionStopped(state.labExecution, code);
+                }
+                else {
+                    logger.err(`[supervisor] LabRun executor group survived its stop: thread=${state.threadId}; its Lab stays blocked`);
+                    if (!hostStopping)
+                        this.executionScheduler?.blockUntilStopped(state.labExecution.executionId);
                 }
-                this.schedulePendingThreads();
-                return;
             }
-        }
-        try {
-            const next = this.spawnWorker(threadId, {
-                bootstrapMessage: pending[0],
-                trustedLabRuntimePolicy,
-            });
-            this.enqueuePendingWork(next, pending);
-        }
-        catch (error) {
-            this.handleWorkerRespawnFailure(threadId, pending, reason, error);
-        }
-    }
-    handleWorkerRespawnFailure(threadId, pending, reason, error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.err(`[supervisor] Failed to respawn worker thread=${threadId} after ${reason}: ${message}`);
-        this.publishSyntheticActivity(threadId, "failed", "Worker restart failed");
-        this.recoveryExhaustedThreads.add(threadId);
-        this.notifyPendingSendersOfFailure(threadId, this.outstandingMessages(threadId, pending));
-    }
-    outstandingMessages(threadId, pending) {
-        const combined = [
-            ...pending,
-            ...(this.threadQueues.get(threadId)?.outstandingSnapshot() ?? []),
-        ];
-        const seen = new Set();
-        return combined.filter((message) => {
-            const key = `${message.channel}:${message.sender}:${message.id}`;
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
+        })
+            .finally(() => { this.pendingGroupReaps.delete(reap); });
+        this.pendingGroupReaps.add(reap);
     }
     freezeLabRuntimePolicy(envelope) {
         return Object.freeze({
@@ -954,43 +1285,6 @@ export class ThreadSupervisor {
             signature: envelope.signature,
         });
     }
-    publishSyntheticActivity(threadId, state, label, messages) {
-        if (!threadId.startsWith("fin-") || threadId.startsWith("fin-lab-"))
-            return;
-        // Suppress owner-facing status for passive-only wakes (email/external-wake).
-        // Only publish when at least one message is owner-initiated (Telegram/Discord/etc.).
-        if (messages && messages.length > 0 && !messages.some(isOwnerInitiatedMessage)) {
-            logger.debug(`[supervisor] Suppressing synthetic activity for thread=${threadId}: all messages are passive ingress`);
-            return;
-        }
-        const now = new Date().toISOString();
-        const previous = this.latestActivities.get(threadId);
-        const activity = {
-            runId: randomUUID(),
-            sequence: 1,
-            state,
-            currentStep: label,
-            todos: [],
-            updatedAt: now,
-            ...(state === "queued" ? { heartbeatAt: now } : { completedAt: now }),
-            activities: [{ state, label, at: now }],
-            workerInstanceId: previous?.workerInstanceId ?? randomUUID(),
-        };
-        this.latestActivities.set(threadId, activity);
-        this.channelManager.publishThreadActivity(threadId, activity, this.agentInstanceId);
-    }
-    /** Best-effort failure notice to the sender(s) of messages we could not process. */
-    notifyPendingSendersOfFailure(threadId, pending) {
-        const notified = new Set();
-        for (const m of pending) {
-            const key = `${m.channel}:${m.sender}`;
-            if (notified.has(key))
-                continue;
-            notified.add(key);
-            deliverReplyToMessage(this.channelManager, m, `⚠️ Thread "${threadId}" failed to start and your message could not be processed. Please try again later or contact the owner.`)
-                .catch(() => { });
-        }
-    }
     /**
      * Deliver a message to the worker via IPC.
      */
@@ -1036,10 +1330,42 @@ export class ThreadSupervisor {
             ...(snapshot.length > 0 ? { activeThreadsSnapshot: snapshot } : {}),
         };
         state.process.send(ipcMsg);
-        this.armIdleTimer(state);
     }
-    labPolicySecret() {
-        return this.labRuntimePolicySecret;
+    authority() {
+        return this.executionAuthority;
+    }
+    labPolicyVerifyKey() {
+        return this.authority().labPolicy.publicKey;
+    }
+    /** Freeze and sign a new generic execution's snapshot with this host's authority. */
+    signExecutionSnapshotFor(executionId, budget = DEFAULT_LAB_RUN_BUDGET, caller) {
+        const meta = caller?.kind === "general" ? readThreadMeta(caller.ref) : null;
+        const selection = meta?.engineOverride
+            ? { engineOverride: meta.engineOverride, pinnedModel: meta.pinnedModel }
+            : { engineOverride: this.config.engineOverride, pinnedModel: this.config.pinnedModel };
+        return JSON.stringify(signExecutionSnapshot({
+            version: EXECUTION_SNAPSHOT_VERSION,
+            executionId,
+            model: freezeExecutionModel(selection, getLlmRouting(), this.config.provider),
+            budget,
+        }, this.authority().snapshot));
+    }
+    /**
+     * Resolve and sign a new execution's snapshot: the thread's engine choice
+     * (else the profile's), the matching route from the current routing
+     * snapshot, and the default task budget. Failover state is not consulted.
+     */
+    admitExecutionSnapshot(threadId) {
+        const meta = readThreadMeta(threadId);
+        const selection = meta?.engineOverride
+            ? { engineOverride: meta.engineOverride, pinnedModel: meta.pinnedModel }
+            : { engineOverride: this.config.engineOverride, pinnedModel: this.config.pinnedModel };
+        return signExecutionSnapshot({
+            version: EXECUTION_SNAPSHOT_VERSION,
+            executionId: threadId,
+            model: freezeExecutionModel(selection, getLlmRouting(), this.config.provider),
+            budget: DEFAULT_LAB_RUN_BUDGET,
+        }, this.authority().snapshot);
     }
     authorizeLabRuntimePolicy(threadId, raw) {
         if (raw && typeof raw === "object") {
@@ -1049,8 +1375,8 @@ export class ThreadSupervisor {
             }
             // A preserved envelope is trusted only after full HMAC + thread/run
             // verification. Re-signing canonicalizes it and prevents object aliasing.
-            const verified = verifyLabRuntimePolicyEnvelope({ payload: envelope.payload, signature: envelope.signature }, this.labPolicySecret(), threadId);
-            return signLabRuntimePolicy(verified.policy, this.labPolicySecret());
+            const verified = verifyLabRuntimePolicyEnvelope({ payload: envelope.payload, signature: envelope.signature }, this.labPolicyVerifyKey(), threadId);
+            return signLabRuntimePolicy(verified.policy, this.authority().labPolicy);
         }
         if (typeof raw !== "string")
             throw new Error(`Lab worker ${threadId} has no runtime policy payload`);
@@ -1061,7 +1387,7 @@ export class ThreadSupervisor {
         catch {
             throw new Error("Lab runtime policy payload is invalid");
         }
-        return signLabRuntimePolicy(parseLabRuntimePolicy(decoded, threadId), this.labPolicySecret());
+        return signLabRuntimePolicy(parseLabRuntimePolicy(decoded, threadId), this.authority().labPolicy);
     }
     /**
      * Gracefully shutdown a worker.
@@ -1074,10 +1400,6 @@ export class ThreadSupervisor {
             return;
         state.shuttingDown = true;
         logger.system(`[supervisor] Shutting down worker: thread=${threadId} reason=${reason}`);
-        if (state.idleTimer !== null) {
-            clearTimeout(state.idleTimer);
-            state.idleTimer = null;
-        }
         const shutdownMsg = {
             type: "shutdown",
             reason,
@@ -1088,13 +1410,20 @@ export class ThreadSupervisor {
             if (error)
                 logger.debug(`[supervisor] Shutdown IPC unavailable for ${threadId}: ${error.message}`);
         });
-        // Wait a grace period, then force-kill if still alive.
-        setTimeout(() => {
-            if (!state.process.killed) {
-                logger.warn(`[supervisor] Force-killing worker: thread=${threadId}`);
+        // Wait a grace period, then force-kill if still alive. An internal
+        // executor is killed with its whole process group.
+        const grace = setTimeout(() => {
+            // Its exit handler already removed it: nothing left to kill.
+            if (this.workers.get(threadId) !== state)
+                return;
+            logger.warn(`[supervisor] Force-killing worker: thread=${threadId}`);
+            const pgid = state.process.pid;
+            if (state.internalExecution && pgid !== undefined && process.platform !== "win32")
+                this.executorGroups.kill(pgid);
+            else
                 state.process.kill("SIGKILL");
-            }
-        }, 10_000); // 10s grace period
+        }, this.workerStopGraceMs);
+        grace.unref();
     }
     /**
      * Shutdown all workers gracefully and wait for them to exit.
@@ -1104,14 +1433,15 @@ export class ThreadSupervisor {
     async shutdownAll() {
         logger.system(`[supervisor] Shutting down all workers (${this.workers.size} active)`);
         this.stopped = true;
-        for (const timer of this.restartTimers.values())
-            clearTimeout(timer);
-        this.restartTimers.clear();
+        this.executionScheduler?.stop();
+        const foregroundShutdown = this.conversations?.shutdown();
         // Initiate graceful shutdown for all workers
         for (const [threadId] of this.workers) {
             this.shutdownWorker(threadId, "supervisor-shutdown");
         }
-        // Wait for all workers to exit (each has its own 10s force-kill timer)
+        // Wait for all workers to exit (each has its own 10s force-kill timer).
+        // The supervisor's own exit handler runs first (it was registered at
+        // fork), so an executor's group reap is already pending when this resolves.
         const exitPromises = [];
         for (const [threadId, state] of this.workers) {
             const exitPromise = new Promise((resolve) => {
@@ -1126,11 +1456,14 @@ export class ThreadSupervisor {
             });
             exitPromises.push(exitPromise);
         }
-        await Promise.all(exitPromises);
+        await Promise.all([foregroundShutdown, ...exitPromises]);
+        // Executor groups are confirmed empty (or left for the next host) before the ledger closes.
+        await Promise.all([...this.pendingGroupReaps]);
         for (const queue of this.threadQueues.values()) {
             queue.close();
         }
         this.threadQueues.clear();
+        this.executionStore?.close();
         logger.system(`[supervisor] All workers shut down`);
     }
     /** Matches {@link getThreadsOverview}: in-flight turn or buffered work. */
@@ -1142,23 +1475,18 @@ export class ThreadSupervisor {
             this.onBusyChange?.();
         }
     }
-    enqueuePendingWork(state, pending) {
-        if (pending.length === 0)
-            return;
-        const wasVisibleBusy = this.isWorkerVisiblyBusy(state);
-        state.pendingMessages.push(...pending);
-        this.emitBusyChangeIfNeeded(wasVisibleBusy, state);
-    }
     /**
      * Get a snapshot of all active (ready) worker threads for cross-thread
      * awareness. Does not include the main "default" thread.
      */
     getActiveThreadsSnapshot() {
-        const result = [];
+        const result = this.conversations?.overview() ?? [];
         for (const [threadId, state] of this.workers) {
             if (state.ready && !state.shuttingDown) {
                 result.push({
                     threadId,
+                    kind: state.internalExecution ? "execution" : "conversation",
+                    ...(state.execution ? { taskId: this.executionStore?.get(state.execution.executionId)?.taskId } : {}),
                     busy: state.busy,
                     taskDescription: state.taskDescription,
                     lastActivityAt: state.lastActivityAt,
@@ -1176,7 +1504,14 @@ export class ThreadSupervisor {
      * contains worker threads.
      */
     refreshMainProcessAwareness() {
-        setActiveThreadsSnapshot(this.getActiveThreadsSnapshot());
+        setActiveThreadsSnapshot(this.getConversationTaskSnapshot(DEFAULT_THREAD_ID));
+    }
+    /** A chat must never receive another chat's task descriptions or inputs. */
+    getConversationTaskSnapshot(conversationId) {
+        return this.getActiveThreadsSnapshot().filter((item) => {
+            const record = this.executionStore?.get(item.threadId);
+            return record?.caller.kind === "general" && record.caller.ref === conversationId;
+        });
     }
     /**
      * Obs-facing overview of all worker threads (including still-spawning ones),
@@ -1184,10 +1519,14 @@ export class ThreadSupervisor {
      * which is the lightweight cross-thread awareness feed (ready workers only).
      */
     getThreadsOverview() {
-        const result = [];
+        const result = (this.conversations?.overview() ?? []).map((item) => ({
+            ...item, engine: formatThreadEngineLabel(item.threadId, this.config),
+        }));
         for (const [threadId, state] of this.workers) {
             result.push({
                 threadId,
+                kind: state.internalExecution ? "execution" : "conversation",
+                ...(state.execution ? { taskId: this.executionStore?.get(state.execution.executionId)?.taskId } : {}),
                 // A spawning worker with buffered work is already active even before
                 // its first busy status IPC arrives.
                 busy: this.isWorkerVisiblyBusy(state),