@yu_robotics/remote-cli 1.6.102 → 1.6.106

package/dist/delegation/DelegationManager.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DelegationManager = exports.DELEGATION_LIMITS = void 0;
+exports.DelegationManager = exports.DELEGATION_TEXT_PROGRESS = exports.DELEGATION_LIMITS = void 0;
 exports.workspacesOverlap = workspacesOverlap;
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -12,6 +12,8 @@ const ThreadExecutorPool_1 = require("../thread/ThreadExecutorPool");
 const executor_1 = require("../executor");
 const BackendRegistry_1 = require("./BackendRegistry");
 const DelegationStore_1 = require("./DelegationStore");
+const DelegatedWorkerSessionStore_1 = require("./DelegatedWorkerSessionStore");
+const DelegatedWorkerLaneCleanup_1 = require("./DelegatedWorkerLaneCleanup");
 const contract_1 = require("./contract");
 const WorkerPolicy_1 = require("./WorkerPolicy");
 const DelegationNotice_1 = require("./DelegationNotice");
@@ -20,6 +22,12 @@ exports.DELEGATION_LIMITS = { launches: 12, concurrent: 3,
     idleTimeoutMs: 15 * 60_000, toolIdleTimeoutMs: 45 * 60_000,
     resultBytes: 32 * 1024, continuationBytes: 64 * 1024,
     storageTimeoutMs: 10_000, calls: 500 };
+/** Bounds and cadence for optional display-only delegated-worker text. */
+exports.DELEGATION_TEXT_PROGRESS = {
+    flushMs: 2_500,
+    bufferBytes: 4 * 1024,
+    latestTextBytes: 1_200,
+};
 function validDuration(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
 }
@@ -65,6 +73,28 @@ function bounded(text, limit, preserveEnd = false) {
         start++;
     return { text: buffer.subarray(0, end).toString('utf8') + marker + buffer.subarray(start).toString('utf8'), truncated: true };
 }
+/** Keep the most recent UTF-8-safe tail without retaining a worker transcript. */
+function tailText(text, limit) {
+    const buffer = Buffer.from(text);
+    if (buffer.length <= limit)
+        return text;
+    let start = Math.max(0, buffer.length - Math.max(0, limit - Buffer.byteLength('…')));
+    while (start < buffer.length && (buffer[start] & 0xc0) === 0x80)
+        start++;
+    return `…${buffer.subarray(start).toString('utf8')}`;
+}
+/** Prefer a completed sentence or paragraph, but always provide a bounded recent tail. */
+function latestDisplayText(text) {
+    const normalized = text.replace(/\r\n?/g, '\n').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g, '').trim();
+    if (!normalized)
+        return undefined;
+    let end = 0;
+    for (const match of normalized.matchAll(/[.!?。！？](?:\s|$)|\n+/g)) {
+        end = match.index + match[0].length;
+    }
+    const complete = end > 0 ? normalized.slice(0, end).trimEnd() : normalized;
+    return tailText(complete, exports.DELEGATION_TEXT_PROGRESS.latestTextBytes);
+}
 function boundedResults(terminal) {
     let results = terminal;
     // Keep every task's identity and terminal status, reducing only text.
@@ -96,16 +126,18 @@ class DelegationManager {
     cleanupMs;
     registry;
     store;
+    laneStore;
     running = 0;
     workspaces = new Map();
     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) {
+    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()) {
         this.guard = guard;
         this.factory = factory;
         this.cleanupMs = cleanupMs;
         this.registry = registry;
         this.store = store;
+        this.laneStore = laneStore;
         this.timeouts = timeoutPolicy(timeoutInput);
     }
     begin(parent) {
@@ -153,15 +185,111 @@ class DelegationManager {
                 console.warn('[Delegation] Progress could not be delivered');
             }
         };
+        const reportProgress = (task, progress) => {
+            try {
+                return parent.onProgress?.({ taskId: task.record.id, backend: task.record.backend, ...progress }) === true;
+            }
+            catch {
+                console.warn('[Delegation] Progress could not be delivered');
+                return false;
+            }
+        };
+        const reportTextProgress = (task, latestText) => {
+            try {
+                return parent.onTextProgress?.({
+                    taskId: task.record.id,
+                    backend: task.record.backend,
+                    phase: 'text',
+                    latestText,
+                    startedAt: task.record.startedAt,
+                }) === true;
+            }
+            catch {
+                console.warn('[Delegation] Display text could not be delivered');
+                return false;
+            }
+        };
+        const clearTextProgress = (task, discardPending = false) => {
+            clearTimeout(task.textTimer);
+            task.textTimer = undefined;
+            if (discardPending)
+                task.textBuffer = undefined;
+        };
+        const flushTextProgress = (task) => {
+            if (closed || task.record.state !== 'running' || !task.textProgressEnabled)
+                return;
+            const latestText = task.textBuffer ? latestDisplayText(task.textBuffer) : undefined;
+            if (!latestText || latestText === task.lastReportedText)
+                return;
+            if (!reportTextProgress(task, latestText)) {
+                return;
+            }
+            task.lastReportedText = latestText;
+        };
+        const scheduleTextProgress = (task) => {
+            if (closed || task.record.state !== 'running' || !task.textProgressEnabled || task.textTimer)
+                return;
+            const timer = setTimeout(() => {
+                if (task.textTimer !== timer)
+                    return;
+                task.textTimer = undefined;
+                flushTextProgress(task);
+            }, exports.DELEGATION_TEXT_PROGRESS.flushMs);
+            timer.unref?.();
+            task.textTimer = timer;
+        };
+        const recordDisplayText = (task, text) => {
+            if (!task.textProgressEnabled || !text)
+                return;
+            task.textBuffer = tailText(`${task.textBuffer ?? ''}${text}`, exports.DELEGATION_TEXT_PROGRESS.bufferBytes);
+            scheduleTextProgress(task);
+        };
+        const reportTerminalProgress = (task) => {
+            if (task.record.state === 'running')
+                return false;
+            return reportProgress(task, {
+                phase: task.record.state,
+                summary: task.record.output ? bounded(task.record.output, 1000, true).text : undefined,
+                error: task.record.error ? bounded(task.record.error, 1000).text : undefined,
+                startedAt: task.record.startedAt,
+            });
+        };
+        const destroyWorker = async (worker) => {
+            await worker.destroy();
+            if (!worker.waitForExit) {
+                throw new Error('Worker backend cannot confirm process exit');
+            }
+            await worker.waitForExit();
+        };
+        const discardLane = async (lane) => {
+            try {
+                await (0, DelegatedWorkerLaneCleanup_1.cleanupDelegatedWorkerLane)(lane);
+                await this.laneStore.remove(lane.id);
+                return true;
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : 'Local worker lane cleanup failed';
+                await this.laneStore.markCleanupFailure(lane.id, detail).catch(() => undefined);
+                console.warn('[Delegation] Worker lane cleanup failed:', detail);
+                return false;
+            }
+        };
         const stop = (task) => task.stop ??= (async () => {
-            if (!task.executor)
+            clearTextProgress(task, true);
+            if (!task.executor) {
+                // A cancellation can race with durable lane acquisition. No worker
+                // process owns this lane yet, so it must not become a reusable empty
+                // session after the task finishes.
+                task.discardLane = true;
+                task.interrupt();
                 return;
+            }
             try {
                 try {
                     await deadline(() => task.executor.abort(), Math.min(2000, this.cleanupMs));
                 }
                 catch { /* Force cleanup still runs. */ }
-                await deadline(async () => { await task.executor.destroy(); await task.executor.waitForExit?.(); }, this.cleanupMs);
+                await deadline(() => destroyWorker(task.executor), this.cleanupMs);
             }
             finally {
                 task.interrupt();
@@ -175,6 +303,7 @@ class DelegationManager {
             if (task.record.state !== 'running')
                 return;
             clearTaskTimer(task);
+            clearTextProgress(task, true);
             task.record.state = 'timed_out';
             task.record.error = `Delegated task stopped after ${formatDuration(duration)} without tool activity`;
             void stop(task).catch(() => undefined);
@@ -202,6 +331,7 @@ class DelegationManager {
         const cancel = async (task) => {
             if (task.record.state === 'running') {
                 clearTaskTimer(task);
+                clearTextProgress(task, true);
                 task.record.state = 'cancelled';
                 task.record.error = 'Cancelled; edits already made were not undone.';
                 await stop(task).catch(() => undefined);
@@ -211,47 +341,140 @@ class DelegationManager {
         };
         const run = async (task, configuration, objective) => {
             const backend = task.record.backend;
+            const identity = {
+                threadId: parent.thread.id,
+                backend,
+                workingDirectory: cwd,
+                workspaceGeneration: parent.thread.delegationWorkspaceGeneration ?? 0,
+            };
+            const createWorker = async () => {
+                if (!task.lane) {
+                    const acquired = await this.laneStore.acquire(identity);
+                    task.lane = acquired.lane;
+                }
+                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 });
+                    task.executor = worker;
+                    if (fs_1.default.realpathSync(worker.getCurrentWorkingDirectory()) !== cwd) {
+                        throw new Error('Worker refused the delegated workspace; refusing a fallback directory');
+                    }
+                    await this.laneStore.markRunning(task.lane.id);
+                    return worker;
+                }
+                catch (error) {
+                    // The factory either supplied an executor that final cleanup can stop,
+                    // or failed before any worker process became manager-owned. Neither
+                    // case warrants a workspace quarantine by itself. Do not reuse a lane
+                    // whose setup did not reach a completed delegated turn.
+                    task.discardLane = true;
+                    if (!worker)
+                        task.executor = undefined;
+                    throw error;
+                }
+            };
+            const discardMissingSessionLane = async () => {
+                const lane = task.lane;
+                const worker = task.executor;
+                if (!lane || !worker)
+                    return false;
+                try {
+                    await deadline(() => destroyWorker(worker), this.cleanupMs);
+                }
+                catch (error) {
+                    task.quarantineWorkspace = true;
+                    const detail = error instanceof Error ? error.message : 'Worker exit could not be confirmed';
+                    await this.laneStore.markDirty(lane.id, detail).catch(() => undefined);
+                    return false;
+                }
+                task.executor = undefined;
+                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;
+                return discarded;
+            };
             try {
                 if (task.record.state !== 'running')
                     return;
-                const childId = `delegate-${task.record.id}`;
-                task.executor = this.factory(this.guard, configuration, cwd, childId, (0, ThreadExecutorPool_1.resolveThreadModel)(parent.thread, configuration), parent.thread.efforts?.[backend], { lifecycleHooks: false, delegationWorker: true });
-                if (fs_1.default.realpathSync(task.executor.getCurrentWorkingDirectory()) !== cwd) {
-                    throw new Error('Worker refused the delegated workspace; refusing a fallback directory');
-                }
-                // Native session IDs are distinct; policy was resolved against the real
-                // parent thread before passing the synthetic child identity to the factory.
-                armIdleTimer(task);
-                const result = await Promise.race([task.interrupted, task.executor.execute(`You are executing one delegated task in an independent session. Complete only this objective and return a concise result with verification and remaining issues. Do not delegate to other agents.\n\n${objective}`, {
+                let result;
+                for (let attempt = 0; attempt < 2; attempt++) {
+                    const worker = await createWorker();
+                    // 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.
+
+${objective}`, {
                         // The manager owns delegated-task liveness. Zero disables optional
                         // backend-local limits that would otherwise ignore tool callbacks.
                         timeout: 0,
                         inactivityTimeout: 0,
                         onStream: text => {
-                            // Text streaming is intentionally not liveness activity; it can be
-                            // frequent without a tool making measurable progress.
-                            // Intermediate output is not retained here; only relay input prompts.
+                            // Generic streams may include reasoning or backend notices. Use
+                            // this channel only to detect interactive input requests.
                             queueMicrotask(() => {
-                                if (!closed && task.record.state === 'running' && task.executor?.isWaitingInput?.()) {
-                                    notify(() => parent.onNotice(`\n[${backend} delegated task]\n${bounded(text, 4000).text}`));
+                                if (closed || task.record.state !== 'running')
+                                    return;
+                                if (task.executor?.isWaitingInput?.()) {
+                                    clearTextProgress(task, true);
+                                    const prompt = bounded(text, 4000).text;
+                                    if (task.waitingInputText === prompt)
+                                        return;
+                                    task.waitingInputText = prompt;
+                                    if (!reportProgress(task, { phase: 'waiting_input', summary: prompt, startedAt: task.record.startedAt })) {
+                                        notify(() => parent.onNotice(`
+[${backend} delegated task]
+${prompt}`));
+                                    }
+                                    return;
                                 }
                             });
                         },
+                        onDisplayText: text => {
+                            if (!closed && task.record.state === 'running' && !task.executor?.isWaitingInput?.()) {
+                                recordDisplayText(task, text);
+                            }
+                        },
                         onToolUse: tool => {
+                            if (task.record.state !== 'running')
+                                return;
+                            clearTextProgress(task, true);
+                            task.waitingInputText = undefined;
                             if (tool.id)
                                 task.activeToolIds.add(tool.id);
                             noteToolActivity(task, 'tool_use');
+                            reportProgress(task, { phase: 'tool_use', toolUse: { id: tool.id, name: tool.name, input: {} }, startedAt: task.record.startedAt });
                         },
-                        onToolResult: result => {
-                            if (result.tool_use_id)
-                                task.activeToolIds.delete(result.tool_use_id);
+                        onToolResult: toolResult => {
+                            if (task.record.state !== 'running')
+                                return;
+                            clearTextProgress(task, true);
+                            task.waitingInputText = undefined;
+                            if (toolResult.tool_use_id)
+                                task.activeToolIds.delete(toolResult.tool_use_id);
                             noteToolActivity(task, 'tool_result');
+                            reportProgress(task, { phase: 'tool_result', toolResult: {
+                                    tool_use_id: toolResult.tool_use_id, content: '', is_error: toolResult.is_error,
+                                }, startedAt: task.record.startedAt });
                         },
                         onApprovalRequest: request => !closed && task.record.state === 'running' && parent.onApproval({ ...request,
                             description: `[${backend} delegated task] ${request.description}`, canRemember: false }, task.executor),
                         onApprovalResolved: parent.onApprovalResolved,
-                    })]);
-                if (task.record.state === 'running') {
+                    });
+                    // Start the inactivity window only once the worker has accepted the
+                    // objective and can emit its first real progress callback.
+                    armIdleTimer(task);
+                    result = await Promise.race([task.interrupted, execution]);
+                    if (!result.success && attempt === 0 && worker.consumeSessionResumeFailure?.()) {
+                        clearTaskTimer(task);
+                        clearTextProgress(task, true);
+                        task.lastReportedText = undefined;
+                        if (await discardMissingSessionLane())
+                            continue;
+                        throw new Error('The worker session was unavailable and its process could not be safely reset.');
+                    }
+                    break;
+                }
+                if (task.record.state === 'running' && result) {
                     const output = bounded(result.output ?? '', exports.DELEGATION_LIMITS.resultBytes, true);
                     task.record.state = result.success ? 'succeeded' : 'failed';
                     task.record.output = output.text;
@@ -269,22 +492,49 @@ class DelegationManager {
             }
             finally {
                 clearTaskTimer(task);
-                let cleaned = false;
+                clearTextProgress(task, true);
+                let released = !task.quarantineWorkspace;
                 try {
                     if (task.stop)
                         await task.stop;
                     else if (task.executor)
-                        await deadline(async () => { await task.executor.destroy(); await task.executor.waitForExit?.(); }, this.cleanupMs);
-                    cleaned = true;
+                        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);
+                        }
+                        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);
+                        }
+                    }
                 }
                 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);
+                    }
                     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 (cleaned) {
-                    await deadline(() => task.executor?.deleteThreadData?.(`delegate-${task.record.id}`), this.cleanupMs)
-                        .catch(() => console.warn('[Delegation] Worker session cleanup did not finish'));
+                if (released) {
                     this.running--;
                     this.workspaces.delete(cwd);
                 }
@@ -293,8 +543,10 @@ class DelegationManager {
                 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'));
-                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)));
+                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)));
+                }
                 task.settle();
             }
         };
@@ -397,6 +649,7 @@ class DelegationManager {
                     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,
+                        textProgressEnabled: parent.onTextProgress !== undefined,
                         activeToolIds: new Set(), done: new Promise(resolve => { settle = resolve; }), settle, interrupted, interrupt };
                     tasks.set(task.record.id, task);
                     try {
@@ -410,12 +663,35 @@ class DelegationManager {
                         task.settle();
                         throw error;
                     }
+                    try {
+                        const lane = await this.laneStore.acquire({
+                            threadId: parent.thread.id,
+                            backend,
+                            workingDirectory: cwd,
+                            workspaceGeneration: parent.thread.delegationWorkspaceGeneration ?? 0,
+                        });
+                        task.lane = lane.lane;
+                    }
+                    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);
+                        launches--;
+                        task.settle();
+                        throw error;
+                    }
                     if (closed) {
                         task.record.state = 'cancelled';
                     }
-                    notify(() => parent.onToolUse({ id: task.record.id, name: 'Task', input: {
-                            description: `${backend}: ${objective.slice(0, 120)}`, prompt: objective.slice(0, 1000), subagent_type: backend,
-                        } }));
+                    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,
+                            } }));
+                    }
                     void run(task, configuration, objective).catch(() => undefined);
                     return receive(task, requestedDuring);
                 }
@@ -480,6 +756,55 @@ class DelegationManager {
         return scope;
     }
     waitingExecutor(threadId) { return this.scopes.get(threadId)?.waitingExecutor(); }
+    hasActiveTasks(threadId) { return this.scopes.get(threadId)?.hasTasks() ?? false; }
+    /** Retry previously confirmed cleanup requests without touching uncertain interrupted workers. */
+    async reconcilePendingWorkerLanes() {
+        return this.removeWorkerLanes(await this.laneStore.cleanupCandidates(), true);
+    }
+    /** Remove all lanes older than the new workspace generation after a successful `/cd`. */
+    async invalidateWorkspaceGeneration(threadId, currentGeneration) {
+        if (this.hasActiveTasks(threadId)) {
+            throw new Error('Cannot change working directory while a delegated worker is running. Wait for it to finish or send /abort first.');
+        }
+        return this.removeWorkerLanes(await this.laneStore.invalidateGeneration(threadId, currentGeneration), true);
+    }
+    /** Forget one backend lane or all lanes for an idle parent thread. */
+    async resetWorkerLanes(threadId, backend) {
+        if (this.hasActiveTasks(threadId)) {
+            throw new Error('Cannot reset delegated worker context while a delegated worker is running. Wait for it to finish or send /abort first.');
+        }
+        const result = await this.removeWorkerLanes(await this.laneStore.markForReset(threadId, backend));
+        return result.removed;
+    }
+    /** Thread deletion is executor-free so it works whether delegation is currently enabled or not. */
+    async deleteWorkerLanes(threadId) {
+        if (this.hasActiveTasks(threadId)) {
+            throw new Error('Cannot delete delegated worker context while a delegated worker is running.');
+        }
+        const result = await this.removeWorkerLanes(await this.laneStore.markForReset(threadId));
+        return result.removed;
+    }
+    async removeWorkerLanes(lanes, tolerateFailures = false) {
+        let removed = 0;
+        let failed = 0;
+        for (const lane of lanes) {
+            try {
+                await (0, DelegatedWorkerLaneCleanup_1.cleanupDelegatedWorkerLane)(lane);
+                await this.laneStore.remove(lane.id);
+                removed++;
+            }
+            catch (error) {
+                failed++;
+                const detail = error instanceof Error ? error.message : 'Local worker lane cleanup failed';
+                await this.laneStore.markCleanupFailure(lane.id, detail).catch(() => undefined);
+                console.warn('[Delegation] Worker lane cleanup failed:', detail);
+            }
+        }
+        if (failed && !tolerateFailures) {
+            throw new Error(`Delegated worker cleanup failed for ${failed} of ${lanes.length} lane(s). ${removed} lane(s) were removed; retry after checking filesystem permissions.`);
+        }
+        return { removed, failed };
+    }
     blocksWorkspace(cwd, threadId) {
         if (this.workspaces.size === 0)
             return false;