@yu_robotics/remote-cli 1.6.128 → 1.6.133

package/dist/delegation/DelegationManager.js

@@ -8,7 +8,9 @@ exports.workspacesOverlap = workspacesOverlap;
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const DirectoryGuard_1 = require("../security/DirectoryGuard");
 const ThreadExecutorPool_1 = require("../thread/ThreadExecutorPool");
+const ExecutionMetadata_1 = require("../executor/ExecutionMetadata");
 const executor_1 = require("../executor");
 const BackendRegistry_1 = require("./BackendRegistry");
 const DelegationStore_1 = require("./DelegationStore");
@@ -18,8 +20,10 @@ const contract_1 = require("./contract");
 const WorkerPolicy_1 = require("./WorkerPolicy");
 const DelegationNotice_1 = require("./DelegationNotice");
 const WorkingDirectory_1 = require("../utils/WorkingDirectory");
-exports.DELEGATION_LIMITS = { launches: 12, concurrent: 3,
+const DelegatedWorkspaceManager_1 = require("./DelegatedWorkspaceManager");
+exports.DELEGATION_LIMITS = { launches: 12, concurrent: 5,
     idleTimeoutMs: 15 * 60_000, toolIdleTimeoutMs: 45 * 60_000,
+    queueTimeoutMs: 60 * 60_000,
     resultBytes: 32 * 1024, continuationBytes: 64 * 1024,
     storageTimeoutMs: 10_000, calls: 500 };
 /** Bounds and cadence for optional display-only delegated-worker text. */
@@ -34,11 +38,12 @@ function validDuration(value, fallback) {
 function timeoutPolicy(input) {
     if (typeof input === 'number') {
         const duration = validDuration(input, exports.DELEGATION_LIMITS.idleTimeoutMs);
-        return { idleTimeoutMs: duration, toolIdleTimeoutMs: duration };
+        return { idleTimeoutMs: duration, toolIdleTimeoutMs: duration, queueTimeoutMs: exports.DELEGATION_LIMITS.queueTimeoutMs };
     }
     return {
         idleTimeoutMs: validDuration(input.idleTimeoutMs, exports.DELEGATION_LIMITS.idleTimeoutMs),
         toolIdleTimeoutMs: validDuration(input.toolIdleTimeoutMs, exports.DELEGATION_LIMITS.toolIdleTimeoutMs),
+        queueTimeoutMs: validDuration(input.queueTimeoutMs, exports.DELEGATION_LIMITS.queueTimeoutMs),
     };
 }
 function formatDuration(milliseconds) {
@@ -122,17 +127,20 @@ class DelegationManager {
     registry;
     store;
     laneStore;
+    workspaceManager;
     running = 0;
     workspaces = new Map();
+    pumps = new Set();
     scopes = new Map();
     timeouts;
-    constructor(guard, factory = executor_1.createExecutor, registry = new BackendRegistry_1.BackendRegistry(), store = new DelegationStore_1.DelegationStore(), timeoutInput = exports.DELEGATION_LIMITS, cleanupMs = 10_000, laneStore = new DelegatedWorkerSessionStore_1.DelegatedWorkerSessionStore()) {
+    constructor(guard, factory = executor_1.createExecutor, registry = new BackendRegistry_1.BackendRegistry(), store = new DelegationStore_1.DelegationStore(), timeoutInput = exports.DELEGATION_LIMITS, cleanupMs = 10_000, laneStore = new DelegatedWorkerSessionStore_1.DelegatedWorkerSessionStore(), workspaceManager = new DelegatedWorkspaceManager_1.DelegatedWorkspaceManager()) {
         this.guard = guard;
         this.factory = factory;
         this.cleanupMs = cleanupMs;
         this.registry = registry;
         this.store = store;
         this.laneStore = laneStore;
+        this.workspaceManager = workspaceManager;
         this.timeouts = timeoutPolicy(timeoutInput);
     }
     begin(parent) {
@@ -147,12 +155,32 @@ class DelegationManager {
         let closed = false;
         let launches = 0;
         let launchRevision = 0;
-        let starting = false;
+        let admissions = 0;
+        let admissionTail = Promise.resolve();
+        const activeTasks = new Set();
+        let integrating = false;
+        let integrationPending;
+        let source;
+        let sourcePromise;
+        let baseline;
+        let maxChildren = 1;
+        const workspaceOwner = { id: (0, crypto_1.randomUUID)(), threadId: parent.thread.id, quarantined: false };
+        const workspaceGeneration = parent.thread.delegationWorkspaceGeneration ?? 0;
         let execution = 0;
         let acceptingResults = true;
         const stagedResults = new Set();
         const cwd = fs_1.default.realpathSync(this.guard.resolveWorkingDirectory(parent.cwd));
+        let leasePath = cwd;
         this.guard.resolveWorkingDirectory(cwd);
+        const discoverWorkspace = () => sourcePromise ??= this.workspaceManager.discover(cwd).then(found => {
+            if (found) {
+                // A full repository checkpoint must not read outside the directory-selection policy.
+                this.guard.resolveWorkingDirectory(found.root);
+                source = found;
+                leasePath = found.root;
+                maxChildren = exports.DELEGATION_LIMITS.concurrent;
+            }
+        });
         const getTask = (value) => {
             const task = typeof value === 'string' ? tasks.get(value) : undefined;
             if (!task)
@@ -160,12 +188,15 @@ class DelegationManager {
             return task;
         };
         const view = (task) => ({ taskId: task.record.id, backend: task.record.backend,
-            state: task.record.finishedAt ? task.record.state : 'running',
-            output: task.record.finishedAt ? task.record.output : undefined,
-            error: task.record.finishedAt ? task.record.error : undefined,
-            truncated: task.record.truncated ?? false });
+            state: task.record.finishedAt !== undefined ? task.record.state : task.record.startedAt === undefined ? 'queued' : 'running',
+            output: task.record.finishedAt !== undefined ? task.record.output : undefined,
+            error: task.record.finishedAt !== undefined ? task.record.error : undefined,
+            truncated: task.record.truncated ?? false,
+            ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}),
+            ...(task.artifact ? { artifact: { taskId: task.artifact.taskId,
+                    disposition: task.artifact.disposition, outputCommit: task.artifact.outputCommit } } : {}) });
         const receive = (task, requestedDuring) => {
-            if (task.record.finishedAt && acceptingResults && requestedDuring === execution)
+            if (task.record.finishedAt !== undefined && acceptingResults && requestedDuring === execution)
                 stagedResults.add(task.record.id);
             return view(task);
         };
@@ -180,9 +211,35 @@ class DelegationManager {
                 console.warn('[Delegation] Progress could not be delivered');
             }
         };
+        const releaseWorkspaceIfIdle = () => {
+            if (integrating || admissions || activeTasks.size || [...tasks.values()].some(task => !task.settled))
+                return;
+            // A new idle cohort must observe coordinator edits even if the last task was read-only.
+            baseline = undefined;
+            if (this.workspaces.get(leasePath) === workspaceOwner && !workspaceOwner.quarantined)
+                this.workspaces.delete(leasePath);
+        };
+        const assertWorkspace = () => {
+            (0, WorkingDirectory_1.assertWorkingDirectoryExists)(parent.cwd);
+            if (fs_1.default.realpathSync(this.guard.resolveWorkingDirectory(parent.cwd)) !== cwd
+                || (parent.thread.delegationWorkspaceGeneration ?? 0) !== workspaceGeneration) {
+                throw new Error('Delegated workspace changed before the task could start');
+            }
+            if (this.workspaces.get(leasePath) !== workspaceOwner || workspaceOwner.quarantined || parent.isWorkspaceBusy?.(leasePath)) {
+                throw new Error('Delegation capacity or workspace is busy; task was not started');
+            }
+        };
+        const captureWorkerMetadata = (task) => {
+            if (!task.executor || task.record.startedAt === undefined)
+                return;
+            task.executionMetadata = (0, ExecutionMetadata_1.mergeReportedExecutionMetadata)(task.executionMetadata, (0, ExecutionMetadata_1.captureExecutionMetadata)(task.executor, task.record.backend));
+        };
         const reportProgress = (task, progress) => {
             try {
-                return parent.onProgress?.({ taskId: task.record.id, backend: task.record.backend, ...progress }) === true;
+                if (task.record.state === 'running')
+                    captureWorkerMetadata(task);
+                return parent.onProgress?.({ taskId: task.record.id, backend: task.record.backend, ...progress,
+                    ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}) }) === true;
             }
             catch {
                 console.warn('[Delegation] Progress could not be delivered');
@@ -191,12 +248,14 @@ class DelegationManager {
         };
         const reportTextProgress = (task, latestText) => {
             try {
+                captureWorkerMetadata(task);
                 return parent.onTextProgress?.({
                     taskId: task.record.id,
                     backend: task.record.backend,
                     phase: 'text',
                     latestText,
                     startedAt: task.record.startedAt,
+                    ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}),
                 }) === true;
             }
             catch {
@@ -240,7 +299,7 @@ class DelegationManager {
             scheduleTextProgress(task);
         };
         const reportTerminalProgress = (task) => {
-            if (task.record.state === 'running')
+            if (!(0, DelegationStore_1.isTerminalTaskState)(task.record.state) || task.record.startedAt === undefined)
                 return false;
             return reportProgress(task, {
                 phase: task.record.state,
@@ -258,6 +317,8 @@ class DelegationManager {
         };
         const discardLane = async (lane) => {
             try {
+                if (source)
+                    await this.workspaceManager.preserveLane(lane.id);
                 await (0, DelegatedWorkerLaneCleanup_1.cleanupDelegatedWorkerLane)(lane);
                 await this.laneStore.remove(lane.id);
                 return true;
@@ -280,6 +341,7 @@ class DelegationManager {
                 return;
             }
             try {
+                captureWorkerMetadata(task);
                 try {
                     await deadline(() => task.executor.abort(), Math.min(2000, this.cleanupMs));
                 }
@@ -323,8 +385,45 @@ class DelegationManager {
             task.record.lastActivityKind = kind;
             armIdleTimer(task);
         };
+        const finishTask = async (task) => {
+            clearTimeout(task.queueTimer);
+            task.record.finishedAt = Date.now();
+            await deadline(async () => { await save(task); await this.store.prune(); }, this.cleanupMs)
+                .catch(() => console.warn('[Delegation] Final task metadata could not be saved or pruned'));
+            if (!reportTerminalProgress(task)) {
+                // A never-started task has no tool/progress card to close on older peers.
+                if (task.record.startedAt !== undefined) {
+                    notify(() => parent.onToolResult({ tool_use_id: task.record.id, content: JSON.stringify(view(task)), is_error: task.record.state !== 'succeeded' }));
+                }
+                notify(() => parent.onNotice((0, DelegationNotice_1.formatDelegationNotice)(task.record)));
+            }
+            task.settle();
+            activeTasks.delete(task);
+            releaseWorkspaceIfIdle();
+            for (const start of this.pumps)
+                start();
+        };
+        const completeUnstarted = (task, state, error) => {
+            if (task.finishUnstarted)
+                return task.finishUnstarted;
+            task.record.state = state;
+            task.record.error = error;
+            return task.finishUnstarted = finishTask(task);
+        };
+        const armQueueTimer = (task) => {
+            const remaining = Math.max(0, task.record.acceptedAt + this.timeouts.queueTimeoutMs - Date.now());
+            task.queueTimer = setTimeout(() => {
+                if (task.record.state !== 'queued' || task.ownsSlot)
+                    return;
+                void completeUnstarted(task, 'timed_out', `Task was not started within ${formatDuration(this.timeouts.queueTimeoutMs)} of admission.`);
+            }, remaining);
+        };
         const cancel = async (task) => {
-            if (task.record.state === 'running') {
+            if (task.record.state === 'queued' && !task.ownsSlot) {
+                await completeUnstarted(task, 'cancelled', 'Cancelled before the worker started.');
+            }
+            else if (!(0, DelegationStore_1.isTerminalTaskState)(task.record.state)) {
+                clearTimeout(task.queueTimer);
                 clearTaskTimer(task);
                 clearTextProgress(task, true);
                 task.record.state = 'cancelled';
@@ -334,27 +433,53 @@ class DelegationManager {
             await task.done;
             return view(task);
         };
-        const run = async (task, configuration, objective) => {
+        const run = async (task) => {
+            const { configuration, objective } = task;
+            let metadataCaptured = false;
             const backend = task.record.backend;
             const identity = {
                 threadId: parent.thread.id,
                 backend,
                 workingDirectory: cwd,
-                workspaceGeneration: parent.thread.delegationWorkspaceGeneration ?? 0,
+                workspaceGeneration,
+            };
+            const assertStartable = () => {
+                if (closed || (0, DelegationStore_1.isTerminalTaskState)(task.record.state) || task.quarantineWorkspace) {
+                    throw new Error('Delegated task ended before execution could start');
+                }
+                assertWorkspace();
             };
             const createWorker = async () => {
+                assertStartable();
                 if (!task.lane) {
-                    const acquired = await this.laneStore.acquire(identity);
+                    const acquired = await this.laneStore.acquire(identity, source
+                        ? { pooled: true, excluded: await this.workspaceManager.unavailableLanes() } : undefined);
                     task.lane = acquired.lane;
+                    if (task.settled || task.quarantineWorkspace) {
+                        // Setup can finish after its deadline, but must never start a late
+                        // worker or leave that acquisition resumable.
+                        await this.laneStore.markDirty(acquired.lane.id, 'Worker setup completed after its task ended.', true).catch(() => undefined);
+                    }
                 }
                 let worker;
                 try {
-                    worker = this.factory(this.guard, configuration, cwd, task.lane.executorThreadId, (0, ThreadExecutorPool_1.resolveThreadModel)(parent.thread, configuration), parent.thread.efforts?.[backend], { lifecycleHooks: false, delegationWorker: true });
+                    assertStartable();
+                    if (source && !task.workspace) {
+                        baseline ??= this.workspaceManager.baseline(source);
+                        const input = await baseline;
+                        assertStartable();
+                        task.workspace = await this.workspaceManager.prepare(task.lane, source, input, task.record.id);
+                        assertStartable();
+                    }
+                    const executionCwd = task.workspace?.cwd ?? cwd;
+                    const workerGuard = task.workspace ? new DirectoryGuard_1.DirectoryGuard([...this.guard.getAllowedDirectories(), executionCwd]) : this.guard;
+                    worker = this.factory(workerGuard, configuration, executionCwd, task.lane.executorThreadId, (0, ThreadExecutorPool_1.resolveThreadModel)(parent.thread, configuration), parent.thread.efforts?.[backend], { lifecycleHooks: false, delegationWorker: true });
                     task.executor = worker;
-                    if (fs_1.default.realpathSync(worker.getCurrentWorkingDirectory()) !== cwd) {
+                    if (fs_1.default.realpathSync(worker.getCurrentWorkingDirectory()) !== fs_1.default.realpathSync(executionCwd)) {
                         throw new Error('Worker refused the delegated workspace; refusing a fallback directory');
                     }
                     await this.laneStore.markRunning(task.lane.id);
+                    assertStartable();
                     return worker;
                 }
                 catch (error) {
@@ -386,17 +511,42 @@ class DelegationManager {
                 await this.laneStore.markDirty(lane.id, 'Native worker session was unavailable before the objective was dispatched.', true);
                 const discarded = await discardLane(lane);
                 task.lane = undefined;
+                task.workspace = undefined;
                 return discarded;
             };
             try {
-                if (task.record.state !== 'running')
+                if ((0, DelegationStore_1.isTerminalTaskState)(task.record.state))
                     return;
                 let result;
                 for (let attempt = 0; attempt < 2; attempt++) {
-                    const worker = await createWorker();
+                    let setupPending = true;
+                    const setup = createWorker().finally(() => { setupPending = false; });
+                    let worker;
+                    try {
+                        worker = await deadline(() => setup, exports.DELEGATION_LIMITS.storageTimeoutMs, 'Worker setup timed out');
+                    }
+                    catch (error) {
+                        if (setupPending)
+                            task.quarantineWorkspace = true;
+                        throw error;
+                    }
+                    assertStartable();
+                    task.executionMetadata = (0, ExecutionMetadata_1.captureExecutionMetadata)(worker, backend);
+                    metadataCaptured = false;
+                    if (task.record.startedAt === undefined) {
+                        task.record.state = 'running';
+                        task.record.startedAt = Date.now();
+                        void save(task);
+                        if (!reportProgress(task, { phase: 'started', objective: task.record.objective, startedAt: task.record.startedAt })) {
+                            notify(() => parent.onToolUse({ id: task.record.id, name: 'Task', input: {
+                                    description: `${backend}: ${objective.slice(0, 120)}`, prompt: objective.slice(0, 1000), subagent_type: backend,
+                                } }));
+                        }
+                    }
                     // Native session IDs are distinct; policy was resolved against the real
                     // parent thread before passing the synthetic worker identity to the factory.
-                    const execution = worker.execute(`You are executing one delegated task in an isolated worker session. This session may contain context from earlier delegated tasks in this thread and workspace. Complete only this objective and return a concise result with verification and remaining issues. Do not delegate to other agents.
+                    const execution = worker.execute(`You are executing one delegated task in an isolated worker session. This session may contain context from earlier delegated tasks in this thread and workspace. Complete only this objective and return a concise result with verification and remaining issues. Do not delegate to other agents.${task.workspace
+                        ? `\nThis task runs in an owned Git worktree at ${task.workspace.cwd}, with a fresh detached task checkout based on checkpoint ${task.workspace.input.commit}. Previous task changes are NOT implicitly present. Re-read current files; earlier conversation context may be stale. Stay within this checkout. Do not merge into or edit the delivery directory, push, change branches, or remove the worktree. Your file changes will be captured as an artifact for explicit coordinator integration. Ignored files and dependencies are not copied from the delivery directory. A worktree is not an OS sandbox.` : ''}
 
 ${objective}`, {
                         // The manager owns delegated-task liveness. Zero disables optional
@@ -462,8 +612,11 @@ ${prompt}`));
                     });
                     // Start the inactivity window only once the worker has accepted the
                     // objective and can emit its first real progress callback.
+                    task.signalDispatch();
                     armIdleTimer(task);
                     result = await Promise.race([task.interrupted, execution]);
+                    captureWorkerMetadata(task);
+                    metadataCaptured = true;
                     if (!result.success && attempt === 0 && worker.consumeSessionResumeFailure?.()) {
                         clearTaskTimer(task);
                         clearTextProgress(task, true);
@@ -484,70 +637,120 @@ ${prompt}`));
                 }
             }
             catch (error) {
-                if (task.record.state === 'running') {
+                if (!(0, DelegationStore_1.isTerminalTaskState)(task.record.state)) {
                     task.record.state = 'failed';
                     task.record.error = bounded(error instanceof Error ? error.message : 'Worker failed', 4000).text;
                 }
                 this.registry.invalidate();
             }
             finally {
+                if (!metadataCaptured)
+                    captureWorkerMetadata(task);
                 clearTaskTimer(task);
                 clearTextProgress(task, true);
+                if (task.record.startedAt === undefined)
+                    task.discardLane = true;
                 let released = !task.quarantineWorkspace;
                 try {
-                    if (task.stop)
-                        await task.stop;
-                    else if (task.executor)
-                        await deadline(() => destroyWorker(task.executor), this.cleanupMs);
-                    else if (task.lane) {
-                        // A scope can close after durable acquisition but before construction.
-                        // No backend process was started, so discard the lane rather than
-                        // reserving the workspace indefinitely.
-                        task.discardLane = true;
-                    }
-                    if (released && task.lane && task.discardLane) {
-                        const lane = task.lane;
-                        await this.laneStore.markDirty(lane.id, 'Delegated worker setup ended before a reusable context was established.', true).catch(() => undefined);
-                        await discardLane(lane);
-                        task.lane = undefined;
-                    }
-                    if (released && task.lane) {
-                        try {
-                            await this.laneStore.markReady(task.lane.id);
+                    await deadline(async () => {
+                        if (task.stop)
+                            await task.stop;
+                        else if (task.executor)
+                            await deadline(() => destroyWorker(task.executor), this.cleanupMs);
+                        else if (task.lane) {
+                            // A scope can close after durable acquisition but before construction.
+                            // No backend process was started, so discard the lane rather than
+                            // reserving the workspace indefinitely.
+                            task.discardLane = true;
                         }
-                        catch (error) {
-                            const detail = error instanceof Error ? error.message : 'Worker lane persistence failed';
-                            await this.laneStore.markDirty(task.lane.id, detail, true).catch(() => undefined);
-                            await discardLane(task.lane);
-                            console.warn('[Delegation] Worker lane could not be retained:', detail);
+                        if (released && task.lane && task.discardLane) {
+                            const lane = task.lane;
+                            await this.laneStore.markDirty(lane.id, 'Delegated worker setup ended before a reusable context was established.', true).catch(() => undefined);
+                            await discardLane(lane);
+                            task.lane = undefined;
                         }
-                    }
+                        if (released && task.lane) {
+                            try {
+                                if (task.workspace) {
+                                    task.artifact = await this.workspaceManager.collect(task.workspace, task.record.state === 'succeeded');
+                                }
+                                await this.laneStore.markReady(task.lane.id);
+                            }
+                            catch (error) {
+                                const detail = error instanceof Error ? error.message : 'Worker lane persistence failed';
+                                if (task.workspace) {
+                                    // Exit was confirmed. Preserve files and context for recovery without blocking unrelated lanes.
+                                    await this.workspaceManager.preserveLane(task.lane.id).catch(() => undefined);
+                                    await this.laneStore.markDirty(task.lane.id, detail).catch(() => undefined);
+                                    if (task.record.state === 'succeeded')
+                                        task.record.state = 'failed';
+                                    task.record.error = bounded(`Worker artifact could not be finalized: ${detail}. Files were retained for manual recovery.`, 4000).text;
+                                }
+                                else {
+                                    await this.laneStore.markDirty(task.lane.id, detail, true).catch(() => undefined);
+                                    await discardLane(task.lane);
+                                }
+                                console.warn('[Delegation] Worker lane could not be retained:', detail);
+                            }
+                        }
+                    }, this.cleanupMs);
                 }
                 catch (error) {
                     released = false;
                     task.quarantineWorkspace = true;
                     if (task.lane) {
                         const detail = error instanceof Error ? error.message : 'Worker cleanup could not be confirmed';
-                        await this.laneStore.markDirty(task.lane.id, detail).catch(() => undefined);
+                        await deadline(() => this.laneStore.markDirty(task.lane.id, detail), this.cleanupMs).catch(() => undefined);
                     }
                     task.record.state = 'interrupted';
                     task.record.error = 'Worker cleanup could not be confirmed. This workspace is blocked until the worker is stopped and the CLI restarts.';
                     console.warn('[Delegation] Worker cleanup failed:', error instanceof Error ? error.message : 'Cleanup failure');
                 }
-                if (released) {
+                if (released && task.ownsSlot) {
+                    task.ownsSlot = false;
                     this.running--;
-                    this.workspaces.delete(cwd);
                 }
-                else
-                    this.workspaces.set(cwd, `quarantined:${parent.thread.id}`);
-                task.record.finishedAt = Date.now();
-                await deadline(async () => { await save(task); await this.store.prune(); }, this.cleanupMs)
-                    .catch(() => console.warn('[Delegation] Final task metadata could not be saved or pruned'));
-                if (!reportTerminalProgress(task)) {
-                    notify(() => parent.onToolResult({ tool_use_id: task.record.id, content: JSON.stringify(view(task)), is_error: task.record.state !== 'succeeded' }));
-                    notify(() => parent.onNotice((0, DelegationNotice_1.formatDelegationNotice)(task.record)));
+                else if (!released) {
+                    workspaceOwner.quarantined = true;
+                    task.record.state = 'interrupted';
+                    task.record.error = 'Worker cleanup could not be confirmed. This workspace is blocked until the worker is stopped and the CLI restarts.';
                 }
-                task.settle();
+                await finishTask(task);
+            }
+        };
+        const startTask = (task) => {
+            clearTimeout(task.queueTimer);
+            activeTasks.add(task);
+            task.ownsSlot = true;
+            this.running++;
+            void run(task).catch(() => undefined);
+        };
+        const pump = () => {
+            if (closed || integrating || activeTasks.size >= maxChildren)
+                return;
+            const queued = [...tasks.values()].filter(task => task.record.state === 'queued' && !task.ownsSlot && !task.finishUnstarted);
+            if (workspaceOwner.quarantined) {
+                for (const task of queued)
+                    void completeUnstarted(task, 'interrupted', 'Task was not started because the previous worker exit could not be confirmed.');
+                return;
+            }
+            const task = queued[0];
+            if (!task)
+                return;
+            if (Date.now() >= task.record.acceptedAt + this.timeouts.queueTimeoutMs) {
+                void completeUnstarted(task, 'timed_out', `Task was not started within ${formatDuration(this.timeouts.queueTimeoutMs)} of admission.`);
+                return;
+            }
+            try {
+                assertWorkspace();
+            }
+            catch (error) {
+                void completeUnstarted(task, 'failed', bounded(error instanceof Error ? error.message : 'Workspace unavailable', 4000).text);
+                return;
+            }
+            if (this.running < exports.DELEGATION_LIMITS.concurrent) {
+                startTask(task);
+                pump();
             }
         };
         const invoke = async (name, args, callId) => {
@@ -567,6 +770,7 @@ ${prompt}`));
                 throw new Error('Delegation tool-call limit reached');
             const result = (async () => {
                 if (name === 'remote_cli_list_backends') {
+                    await discoverWorkspace();
                     const backends = await this.registry.list(parent.config);
                     return { backends: backends.map(item => {
                             const configure = (mode) => (0, WorkerPolicy_1.workerConfiguration)(parent.config, this.guard, parent.thread.id, parent.backend, item.backend, mode);
@@ -586,14 +790,16 @@ ${prompt}`));
                                 }
                             }
                             return { ...item, readOnly };
-                        }), workspace: cwd, maxConcurrentChildren: 1 };
+                        }), workspace: cwd, maxConcurrentChildren: maxChildren,
+                        maxTasksPerRequest: exports.DELEGATION_LIMITS.launches, scheduling: source ? 'isolated-worktrees' : 'serial',
+                        queueTimeoutSeconds: this.timeouts.queueTimeoutMs / 1000 };
                 }
                 if (name === 'remote_cli_result') {
                     const task = getTask(args.taskId);
                     const seconds = args.waitSeconds ?? 25;
                     if (typeof seconds !== 'number' || !Number.isFinite(seconds) || seconds < 0 || seconds > 25)
                         throw new Error('waitSeconds must be between 0 and 25');
-                    if (!task.record.finishedAt && seconds > 0) {
+                    if (task.record.finishedAt === undefined && seconds > 0) {
                         let timer;
                         try {
                             await Promise.race([task.done, new Promise(resolve => { timer = setTimeout(resolve, seconds * 1000); })]);
@@ -609,14 +815,42 @@ ${prompt}`));
                     await cancel(task);
                     return receive(task, requestedDuring);
                 }
+                if (name === 'remote_cli_integrate') {
+                    if (!acceptingResults)
+                        throw new Error('The coordinator execution has ended');
+                    await discoverWorkspace();
+                    if (!source)
+                        throw new Error('Non-Git delegation uses the shared workspace and has no worktree artifacts');
+                    if (integrating || admissions || activeTasks.size || [...tasks.values()].some(task => !task.settled)) {
+                        throw new Error('Wait for all accepted workers to finish before integrating artifacts');
+                    }
+                    if (workspaceOwner.quarantined || [...this.workspaces].some(([active, owner]) => owner !== workspaceOwner && workspacesOverlap(active, leasePath)) || parent.isWorkspaceBusy?.(leasePath)) {
+                        throw new Error('Delivery workspace is busy; integration was not started');
+                    }
+                    integrating = true;
+                    this.workspaces.set(leasePath, workspaceOwner);
+                    try {
+                        assertWorkspace();
+                        integrationPending = this.workspaceManager.integrate({ threadId: parent.thread.id, cwd, workspaceGeneration,
+                            checkActive: () => { if (closed)
+                                throw new Error('Integration was cancelled before delivery'); assertWorkspace(); } }, String(args.taskId ?? ''), args.action ?? 'inspect', args.expectedRevision);
+                        const result = await integrationPending;
+                        baseline = undefined;
+                        const task = tasks.get(String(args.taskId));
+                        if (task)
+                            task.artifact = await this.workspaceManager.describe(task.record.id);
+                        return result;
+                    }
+                    finally {
+                        integrationPending = undefined;
+                        integrating = false;
+                        releaseWorkspaceIfIdle();
+                    }
+                }
                 if (name !== 'remote_cli_delegate')
                     throw new Error('Unknown delegation tool');
                 if (!acceptingResults)
                     throw new Error('The coordinator execution has ended');
-                if (starting || [...tasks.values()].some(task => !task.record.finishedAt))
-                    throw new Error('Wait for the current delegated task before starting another');
-                if (launches >= exports.DELEGATION_LIMITS.launches)
-                    throw new Error('Delegated task limit reached');
                 if (!contract_1.DELEGATION_BACKENDS.includes(args.backend))
                     throw new Error('Unsupported worker backend');
                 if (typeof args.objective !== 'string' || !args.objective.trim() || args.objective.length > 24_000)
@@ -627,77 +861,107 @@ ${prompt}`));
                     throw new Error('Unsupported execution mode');
                 const backend = args.backend;
                 const configuration = (0, WorkerPolicy_1.workerConfiguration)(parent.config, this.guard, parent.thread.id, parent.backend, backend, mode);
+                if (integrating)
+                    throw new Error('Artifact integration is in progress; wait before delegating');
                 launchRevision++;
-                starting = true;
-                try {
-                    const available = await this.registry.get(backend, parent.config);
+                admissions++;
+                const discovery = this.registry.get(backend, parent.config);
+                void discovery.catch(() => undefined);
+                // Serialize admission, not worker execution. Replayed calls share the
+                // original promise; simultaneous new calls cannot overdraw the quota.
+                const admitted = admissionTail.then(async () => {
+                    if (closed)
+                        throw new Error('Delegation turn has ended');
+                    if (launches >= exports.DELEGATION_LIMITS.launches)
+                        throw new Error('Delegated task limit reached');
+                    const available = await discovery;
                     if (!available.installed)
                         throw new Error(`${backend}: ${available.reason}`);
+                    await discoverWorkspace();
+                    if (integrating)
+                        throw new Error('Artifact integration is in progress; wait before delegating');
                     await deadline(() => this.store.initialize(), exports.DELEGATION_LIMITS.storageTimeoutMs, 'Task record initialization timed out');
                     if (closed)
                         throw new Error('Delegation turn has ended');
-                    if (this.running >= exports.DELEGATION_LIMITS.concurrent
-                        || [...this.workspaces.keys()].some(active => workspacesOverlap(active, cwd))
-                        || parent.isWorkspaceBusy?.(cwd))
+                    const idle = !activeTasks.size && ![...tasks.values()].some(task => !task.settled);
+                    const first = activeTasks.size < maxChildren && this.running < exports.DELEGATION_LIMITS.concurrent
+                        && ![...tasks.values()].some(task => task.record.state === 'queued' && !task.ownsSlot && !task.finishUnstarted);
+                    if ((idle && this.running >= exports.DELEGATION_LIMITS.concurrent)
+                        || workspaceOwner.quarantined
+                        || [...this.workspaces].some(([active, owner]) => owner !== workspaceOwner && workspacesOverlap(active, leasePath))
+                        || parent.isWorkspaceBusy?.(leasePath))
                         throw new Error('Delegation capacity or workspace is busy; wait before retrying');
+                    this.workspaces.set(leasePath, workspaceOwner);
+                    assertWorkspace();
                     launches++;
-                    this.running++;
-                    this.workspaces.set(cwd, parent.thread.id);
-                    let settle;
+                    let resolveDone;
+                    let resolveDispatch;
                     let interrupt;
                     const interrupted = new Promise(resolve => { interrupt = () => resolve({ success: false }); });
                     const task = { record: { id: (0, crypto_1.randomUUID)(), threadId: parent.thread.id,
                             parentMessageId: parent.messageId, backend, objective: objective.slice(0, 1000),
-                            state: 'running', startedAt: Date.now() }, resultDelivered: false,
+                            state: 'queued', acceptedAt: Date.now() }, configuration, objective,
+                        resultDelivered: false, settled: false, ownsSlot: first,
                         textProgressEnabled: parent.onTextProgress !== undefined,
-                        activeToolIds: new Set(), done: new Promise(resolve => { settle = resolve; }), settle, interrupted, interrupt };
-                    tasks.set(task.record.id, task);
-                    try {
-                        await deadline(() => this.store.write(task.record), exports.DELEGATION_LIMITS.storageTimeoutMs, 'Initial task record write timed out');
-                    }
-                    catch (error) {
-                        tasks.delete(task.record.id);
-                        this.running--;
-                        this.workspaces.delete(cwd);
-                        launches--;
-                        task.settle();
-                        throw error;
+                        activeToolIds: new Set(), done: new Promise(resolve => { resolveDone = resolve; }),
+                        dispatched: new Promise(resolve => { resolveDispatch = resolve; }), signalDispatch: () => resolveDispatch(),
+                        settle: () => { if (task.settled)
+                            return; task.settled = true; resolveDone(); resolveDispatch(); }, interrupted, interrupt };
+                    if (first) {
+                        activeTasks.add(task);
+                        this.running++;
                     }
                     try {
-                        const lane = await this.laneStore.acquire({
-                            threadId: parent.thread.id,
-                            backend,
-                            workingDirectory: cwd,
-                            workspaceGeneration: parent.thread.delegationWorkspaceGeneration ?? 0,
-                        });
-                        task.lane = lane.lane;
+                        await deadline(() => this.store.write(task.record), exports.DELEGATION_LIMITS.storageTimeoutMs, 'Initial task record write timed out');
                     }
                     catch (error) {
-                        task.record.state = 'failed';
-                        task.record.error = bounded(error instanceof Error ? error.message : 'Worker lane storage failed', 4000).text;
-                        task.record.finishedAt = Date.now();
-                        await this.store.write(task.record).catch(() => undefined);
-                        tasks.delete(task.record.id);
-                        this.running--;
-                        this.workspaces.delete(cwd);
+                        if (task.ownsSlot) {
+                            this.running--;
+                            task.ownsSlot = false;
+                            activeTasks.delete(task);
+                        }
                         launches--;
                         task.settle();
                         throw error;
                     }
+                    // The durable queued record is the acceptance boundary. Every task
+                    // after it consumes quota, including setup failures and cancellation.
+                    tasks.set(task.record.id, task);
                     if (closed) {
-                        task.record.state = 'cancelled';
+                        if (task.ownsSlot) {
+                            this.running--;
+                            task.ownsSlot = false;
+                            activeTasks.delete(task);
+                        }
+                        await completeUnstarted(task, 'cancelled', 'Cancelled before the worker started.');
                     }
-                    if (!reportProgress(task, { phase: 'started', objective: task.record.objective, startedAt: task.record.startedAt })) {
-                        notify(() => parent.onToolUse({ id: task.record.id, name: 'Task', input: {
-                                description: `${backend}: ${objective.slice(0, 120)}`, prompt: objective.slice(0, 1000), subagent_type: backend,
-                            } }));
+                    else if (task.ownsSlot) {
+                        void run(task).catch(() => undefined);
                     }
-                    void run(task, configuration, objective).catch(() => undefined);
-                    return receive(task, requestedDuring);
+                    else {
+                        armQueueTimer(task);
+                        notify(() => parent.onNotice(`\n\n⏳ ${backend} delegated task ${task.record.id.slice(0, 8)} queued. It will start after earlier tasks finish; queue wait is limited to ${formatDuration(this.timeouts.queueTimeoutMs)}.\n\n`));
+                        pump();
+                    }
+                    return task;
+                });
+                admissionTail = admitted.catch(() => undefined);
+                let task;
+                try {
+                    task = await admitted;
                 }
                 finally {
-                    starting = false;
+                    admissions--;
+                    releaseWorkspaceIfIdle();
+                    for (const start of this.pumps)
+                        start();
                 }
+                if (task.ownsSlot) {
+                    // Preserve the existing first-task response after dispatch/setup,
+                    // without holding up admission of followers while setup is pending.
+                    await task.dispatched;
+                }
+                return receive(task, requestedDuring);
             })();
             calls.set(callId, { signature, result });
             return result;
@@ -705,7 +969,7 @@ ${prompt}`));
         const scope = {
             invoke,
             isClosed: () => closed,
-            hasTasks: () => starting || tasks.size > 0,
+            hasTasks: () => admissions > 0 || tasks.size > 0,
             getLaunchRevision: () => launchRevision,
             beginExecution: (taskIds = []) => {
                 if (closed)
@@ -714,7 +978,7 @@ ${prompt}`));
                 acceptingResults = true;
                 stagedResults.clear();
                 for (const id of taskIds) {
-                    if (tasks.get(id)?.record.finishedAt)
+                    if (tasks.get(id)?.record.finishedAt !== undefined)
                         stagedResults.add(id);
                 }
             },
@@ -726,9 +990,9 @@ ${prompt}`));
                 }
                 stagedResults.clear();
             },
-            hasPendingResults: () => starting || [...tasks.values()].some(task => !task.resultDelivered && !stagedResults.has(task.record.id)),
+            hasPendingResults: () => admissions > 0 || [...tasks.values()].some(task => !task.resultDelivered && !stagedResults.has(task.record.id)),
             getRetainedResults: () => boundedResults([...tasks.values()]
-                .filter(task => task.record.finishedAt && !task.resultDelivered).map(view)),
+                .filter(task => task.record.finishedAt !== undefined && !task.resultDelivered).map(view)),
             collectPendingResults: async () => {
                 if (closed)
                     throw new Error('Delegation was cancelled');
@@ -743,19 +1007,28 @@ ${prompt}`));
                     throw new Error('Delegation was cancelled');
                 return boundedResults(pending.map(view));
             },
-            waitingExecutor: () => [...tasks.values()].find(task => task.executor?.isWaitingInput?.())?.executor,
+            waitingExecutor: () => {
+                const waiting = [...activeTasks].filter(task => task.record.state === 'running' && task.executor?.isWaitingInput?.());
+                return !closed && waiting.length === 1 ? waiting[0].executor : undefined;
+            },
+            waitingInputCount: () => closed ? 0 : [...activeTasks].filter(task => task.record.state === 'running' && task.executor?.isWaitingInput?.()).length,
             close: async () => {
                 closed = true;
+                this.pumps.delete(pump);
                 await Promise.allSettled([...tasks.values()].map(cancel));
+                await integrationPending?.catch(() => undefined);
+                releaseWorkspaceIfIdle();
                 // A version probe may still be pending. Its closed check prevents launch.
                 if (this.scopes.get(parent.thread.id) === scope)
                     this.scopes.delete(parent.thread.id);
             },
         };
+        this.pumps.add(pump);
         this.scopes.set(parent.thread.id, scope);
         return scope;
     }
     waitingExecutor(threadId) { return this.scopes.get(threadId)?.waitingExecutor(); }
+    hasAmbiguousInput(threadId) { return (this.scopes.get(threadId)?.waitingInputCount() ?? 0) > 1; }
     hasActiveTasks(threadId) { return this.scopes.get(threadId)?.hasTasks() ?? false; }
     /** Retry previously confirmed cleanup requests without touching uncertain interrupted workers. */
     async reconcilePendingWorkerLanes() {
@@ -789,6 +1062,7 @@ ${prompt}`));
         let failed = 0;
         for (const lane of lanes) {
             try {
+                await this.workspaceManager.preserveLane(lane.id);
                 await (0, DelegatedWorkerLaneCleanup_1.cleanupDelegatedWorkerLane)(lane);
                 await this.laneStore.remove(lane.id);
                 removed++;
@@ -809,7 +1083,7 @@ ${prompt}`));
         if (this.workspaces.size === 0)
             return false;
         const canonical = fs_1.default.realpathSync(cwd);
-        return [...this.workspaces].some(([active, owner]) => owner !== threadId && workspacesOverlap(active, canonical));
+        return [...this.workspaces].some(([active, owner]) => (owner.quarantined || owner.threadId !== threadId) && workspacesOverlap(active, canonical));
     }
     async cancelThread(threadId) { await this.scopes.get(threadId)?.close(); }
     async destroy() { await Promise.allSettled([...this.scopes.values()].map(scope => scope.close())); }