@yu_robotics/remote-cli 1.6.139 → 1.6.145

package/dist/delegation/DelegationManager.js

@@ -21,11 +21,13 @@ const WorkerPolicy_1 = require("./WorkerPolicy");
 const DelegationNotice_1 = require("./DelegationNotice");
 const WorkingDirectory_1 = require("../utils/WorkingDirectory");
 const DelegatedWorkspaceManager_1 = require("./DelegatedWorkspaceManager");
+const ActivityProgress_1 = require("../utils/ActivityProgress");
+const Activity_1 = require("../executor/Activity");
 exports.DELEGATION_LIMITS = { launches: 12, concurrent: 5, closeoutRounds: 2,
     idleTimeoutMs: 15 * 60_000, toolIdleTimeoutMs: 45 * 60_000,
     queueTimeoutMs: 60 * 60_000,
     resultBytes: 32 * 1024, continuationBytes: 64 * 1024,
-    storageTimeoutMs: 10_000, calls: 500 };
+    storageTimeoutMs: 10_000, toolResponseWaitMs: 20_000, calls: 500 };
 /** Bounds and cadence for optional display-only delegated-worker text. */
 exports.DELEGATION_TEXT_PROGRESS = {
     flushMs: 2_500,
@@ -255,6 +257,7 @@ class DelegationManager {
                 if (task.record.state === 'running')
                     captureWorkerMetadata(task);
                 return parent.onProgress?.({ taskId: task.record.id, backend: task.record.backend, ...progress,
+                    ...(parent.onActivityProgress && task.activity ? { activity: { ...task.activity } } : {}),
                     ...(task.lane ? { workerContext: { laneId: task.lane.id, generation: task.lane.contextGeneration ?? 0 } } : {}),
                     ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}) }) === true;
             }
@@ -265,6 +268,8 @@ class DelegationManager {
         };
         const reportTextProgress = (task, latestText) => {
             try {
+                if (task.executor?.isWaitingInput?.())
+                    return false;
                 captureWorkerMetadata(task);
                 return parent.onTextProgress?.({
                     taskId: task.record.id,
@@ -272,6 +277,7 @@ class DelegationManager {
                     phase: 'text',
                     latestText,
                     startedAt: task.record.startedAt,
+                    ...(parent.onActivityProgress && task.executor?.isWaitingInput?.() === false ? { waitingForInput: false } : {}),
                     ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}),
                 }) === true;
             }
@@ -286,8 +292,28 @@ class DelegationManager {
             if (discardPending)
                 task.textBuffer = undefined;
         };
+        const recordActivity = (task, value) => {
+            if (!parent.onActivityProgress || closed || task.record.state !== 'running' || task.executor?.isWaitingInput?.())
+                return;
+            const activity = (0, Activity_1.normalizeActivity)(value);
+            if (!activity)
+                return;
+            if (task.executor?.isWaitingInput?.() === false)
+                task.waitingInputText = undefined;
+            task.activity = activity;
+            task.activityProgress ??= new ActivityProgress_1.ActivityProgress(snapshot => {
+                if (closed || task.record.state !== 'running' || task.executor?.isWaitingInput?.())
+                    return false;
+                captureWorkerMetadata(task);
+                return parent.onActivityProgress?.({ taskId: task.record.id, backend: task.record.backend,
+                    phase: 'text', activity: snapshot, startedAt: task.record.startedAt,
+                    ...(task.executor?.isWaitingInput?.() === false ? { waitingForInput: false } : {}),
+                    ...(task.executionMetadata ? { executionMetadata: { ...task.executionMetadata } } : {}) }) === true;
+            });
+            task.activityProgress.offer(activity);
+        };
         const flushTextProgress = (task) => {
-            if (closed || task.record.state !== 'running' || !task.textProgressEnabled)
+            if (closed || task.record.state !== 'running' || !task.textProgressEnabled || task.executor?.isWaitingInput?.())
                 return;
             const latestText = task.textBuffer ? latestDisplayText(task.textBuffer) : undefined;
             if (!latestText || latestText === task.lastReportedText)
@@ -312,6 +338,8 @@ class DelegationManager {
         const recordDisplayText = (task, text) => {
             if (!task.textProgressEnabled || !text)
                 return;
+            if (task.executor?.isWaitingInput?.() === false)
+                task.waitingInputText = undefined;
             task.textBuffer = tailText(`${task.textBuffer ?? ''}${text}`, exports.DELEGATION_TEXT_PROGRESS.bufferBytes);
             scheduleTextProgress(task);
         };
@@ -349,6 +377,7 @@ class DelegationManager {
         };
         const stop = (task) => task.stop ??= (async () => {
             clearTextProgress(task, true);
+            task.activityProgress?.dispose();
             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
@@ -404,6 +433,7 @@ class DelegationManager {
         };
         const finishTask = async (task) => {
             clearTimeout(task.queueTimer);
+            task.activityProgress?.dispose();
             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'));
@@ -466,7 +496,7 @@ class DelegationManager {
                 }
                 assertWorkspace();
             };
-            const createWorker = async () => {
+            const prepareWorkerWorkspace = async () => {
                 assertStartable();
                 if (!task.lane) {
                     const acquired = await this.laneStore.acquire(identity, source
@@ -480,17 +510,25 @@ class DelegationManager {
                         await this.laneStore.markDirty(acquired.lane.id, 'Worker setup completed after its task ended.', true).catch(() => undefined);
                     }
                 }
+                assertStartable();
+                if (source && !task.workspace) {
+                    baseline ??= this.workspaceManager.baseline(source);
+                    const input = await baseline;
+                    assertStartable();
+                    task.workspacePreparationStarted = true;
+                    task.workspace = await this.workspaceManager.prepare(task.lane, source, input, task.record.id);
+                    assertStartable();
+                }
+            };
+            const createWorker = async () => {
                 let worker;
                 try {
+                    // Shared-directory acquisition keeps its existing startup deadline.
+                    if (!source)
+                        await prepareWorkerWorkspace();
                     assertStartable();
-                    if (source && !task.workspace) {
-                        baseline ??= this.workspaceManager.baseline(source);
-                        const input = await baseline;
-                        assertStartable();
-                        task.workspacePreparationStarted = true;
-                        task.workspace = await this.workspaceManager.prepare(task.lane, source, input, task.record.id);
-                        assertStartable();
-                    }
+                    if (!task.lane)
+                        throw new Error('Worker lane is unavailable before native startup');
                     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 });
@@ -546,6 +584,11 @@ class DelegationManager {
                 }
                 let result;
                 for (let attempt = 0; attempt < 2; attempt++) {
+                    // Owned Git work and repository-lock waits are not native startup.
+                    // Await them even on cancellation: no mutation may outlive its slot
+                    // or source lease, and the final startable check prevents late launch.
+                    if (source)
+                        await prepareWorkerWorkspace();
                     let setupPending = true;
                     const setup = createWorker().finally(() => { setupPending = false; });
                     let worker;
@@ -572,6 +615,7 @@ class DelegationManager {
                     }
                     // Native session IDs are distinct; policy was resolved against the real
                     // parent thread before passing the synthetic worker identity to the factory.
+                    let acceptingActivity = true;
                     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.` : ''}
 
@@ -580,6 +624,10 @@ ${objective}`, {
                         // backend-local limits that would otherwise ignore tool callbacks.
                         timeout: 0,
                         inactivityTimeout: 0,
+                        onActivity: parent.onActivityProgress ? value => {
+                            if (acceptingActivity && task.executor === worker)
+                                recordActivity(task, value);
+                        } : undefined,
                         onStream: text => {
                             // Generic streams may include reasoning or backend notices. Use
                             // this channel only to detect interactive input requests.
@@ -588,6 +636,7 @@ ${objective}`, {
                                     return;
                                 if (task.executor?.isWaitingInput?.()) {
                                     clearTextProgress(task, true);
+                                    task.activityProgress?.clear();
                                     const prompt = bounded(text, 4000).text;
                                     if (task.waitingInputText === prompt)
                                         return;
@@ -633,20 +682,41 @@ ${prompt}`));
                                     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,
+                        onApprovalRequest: request => {
+                            if (closed || task.record.state !== 'running')
+                                return false;
+                            task.activityProgress?.clear();
+                            if (parent.onActivityProgress)
+                                reportProgress(task, { phase: 'waiting_input', summary: 'Approval required', startedAt: task.record.startedAt });
+                            return parent.onApproval({ ...request,
+                                description: `[${backend} delegated task] ${request.description}`, canRemember: false }, task.executor);
+                        },
+                        onApprovalResolved: (id, status) => {
+                            parent.onApprovalResolved(id, status);
+                            if (acceptingActivity && task.executor === worker && worker.isWaitingInput?.() === false) {
+                                task.waitingInputText = undefined;
+                                recordActivity(task, { source: 'state', text: 'Working' });
+                            }
+                        },
                     });
                     // 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]);
+                    try {
+                        result = await Promise.race([task.interrupted, execution]);
+                    }
+                    finally {
+                        acceptingActivity = false;
+                    }
                     captureWorkerMetadata(task);
                     metadataCaptured = true;
                     if (!result.success && attempt === 0 && worker.consumeSessionResumeFailure?.()) {
                         clearTaskTimer(task);
                         clearTextProgress(task, true);
+                        task.activityProgress?.dispose();
+                        task.activityProgress = undefined;
+                        task.activity = undefined;
                         task.lastReportedText = undefined;
                         if (await discardMissingSessionLane())
                             continue;
@@ -675,76 +745,97 @@ ${prompt}`));
                     captureWorkerMetadata(task);
                 clearTaskTimer(task);
                 clearTextProgress(task, true);
+                task.activityProgress?.dispose();
                 if (task.record.startedAt === undefined)
                     task.discardLane = !task.preserveUnstartedLane;
                 let released = !task.quarantineWorkspace;
+                let nativeExitConfirmed = false;
                 let readyWorkspaceLane;
-                try {
-                    await deadline(async () => {
-                        if (task.stop)
-                            await task.stop;
-                        else if (task.executor)
-                            await deadline(() => destroyWorker(task.executor), this.cleanupMs);
-                        else if (task.lane && !task.preserveUnstartedLane) {
-                            // 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;
+                const finalizeLane = async () => {
+                    if (task.stop)
+                        await deadline(() => task.stop, this.cleanupMs);
+                    else if (task.executor)
+                        await deadline(() => destroyWorker(task.executor), this.cleanupMs);
+                    else if (task.lane && !task.preserveUnstartedLane) {
+                        // 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;
+                    }
+                    nativeExitConfirmed = true;
+                    if (released && task.lane && task.preserveUnstartedLane) {
+                        if (!task.workspacePreparationStarted) {
+                            // Only acquisition changed: no checkout or executor was touched.
+                            await this.laneStore.markReady(task.lane.id);
                         }
-                        if (released && task.lane && task.preserveUnstartedLane) {
-                            if (!task.workspacePreparationStarted) {
-                                // Only acquisition changed: no checkout or executor was touched.
-                                await this.laneStore.markReady(task.lane.id);
+                        else {
+                            await this.workspaceManager.preserveLane(task.lane.id);
+                            await this.laneStore.markDirty(task.lane.id, `${task.workspace ? 'Worker process setup did not complete' : 'Worker checkout preparation failed'}; existing context and files were retained for manual recovery.`);
+                        }
+                    }
+                    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 && !task.preserveUnstartedLane) {
+                        try {
+                            if (task.workspace) {
+                                task.artifact = await this.workspaceManager.collect(task.workspace, task.record.state === 'succeeded');
+                                readyWorkspaceLane = task.lane;
                             }
                             else {
-                                await this.workspaceManager.preserveLane(task.lane.id);
-                                await this.laneStore.markDirty(task.lane.id, `${task.workspace ? 'Worker process setup did not complete' : 'Worker checkout preparation failed'}; existing context and files were retained for manual recovery.`);
+                                await this.laneStore.markReady(task.lane.id);
                             }
                         }
-                        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 && !task.preserveUnstartedLane) {
-                            try {
-                                if (task.workspace) {
-                                    task.artifact = await this.workspaceManager.collect(task.workspace, task.record.state === 'succeeded');
-                                    readyWorkspaceLane = task.lane;
-                                }
-                                else {
-                                    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;
                             }
-                            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);
+                            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);
+                    }
+                };
+                try {
+                    // Collection owns Git mutations and must settle before releasing the
+                    // lane, slot, or source lease. Individual Git commands remain bounded.
+                    if (source)
+                        await finalizeLane();
+                    else
+                        await deadline(finalizeLane, 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 deadline(() => this.laneStore.markDirty(task.lane.id, detail), this.cleanupMs).catch(() => undefined);
+                    const detail = error instanceof Error ? error.message : 'Worker cleanup could not be confirmed';
+                    if (source && released && nativeExitConfirmed) {
+                        readyWorkspaceLane = undefined;
+                        if (task.lane) {
+                            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 lane could not be finalized: ${detail}. Files were retained for manual recovery.`, 4000).text;
+                    }
+                    else {
+                        released = false;
+                        task.quarantineWorkspace = true;
+                        if (task.lane) {
+                            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.';
                     }
-                    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 && readyWorkspaceLane) {
@@ -815,6 +906,18 @@ ${prompt}`));
             if (closed)
                 throw new Error('Delegation turn has ended');
             const requestedDuring = execution;
+            const responseDeadline = Date.now() + exports.DELEGATION_LIMITS.toolResponseWaitMs;
+            const waitForResponse = async (pending) => {
+                let timer;
+                try {
+                    await Promise.race([pending, new Promise(resolve => {
+                            timer = setTimeout(resolve, Math.max(0, responseDeadline - Date.now()));
+                        })]);
+                }
+                finally {
+                    clearTimeout(timer);
+                }
+            };
             if (!callId || callId.length > 200)
                 throw new Error('Invalid tool call ID');
             const signature = JSON.stringify({ name, args });
@@ -830,25 +933,8 @@ ${prompt}`));
                 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);
-                            try {
-                                configure('inherit');
-                            }
-                            catch (error) {
-                                return { ...item, worker: false, readOnly: false, reason: error.message };
-                            }
-                            let readOnly = item.readOnly;
-                            if (readOnly) {
-                                try {
-                                    configure('read_only');
-                                }
-                                catch {
-                                    readOnly = false;
-                                }
-                            }
-                            return { ...item, readOnly };
-                        }), workspace: cwd, maxConcurrentChildren: maxChildren,
+                    return { backends: backends.map(item => (0, WorkerPolicy_1.workerAvailability)(parent.config, this.guard, parent.thread.id, parent.backend, item)),
+                        workspace: cwd, maxConcurrentChildren: maxChildren,
                         maxTasksPerRequest: exports.DELEGATION_LIMITS.launches, scheduling: source ? 'isolated-worktrees' : 'serial',
                         queueTimeoutSeconds: this.timeouts.queueTimeoutMs / 1000 };
                 }
@@ -870,7 +956,16 @@ ${prompt}`));
                 }
                 if (name === 'remote_cli_cancel') {
                     const task = getTask(args.taskId);
-                    await cancel(task);
+                    const cancelling = cancel(task);
+                    if (source)
+                        await waitForResponse(cancelling);
+                    else
+                        await cancelling;
+                    if (source && task.record.finishedAt === undefined) {
+                        return { ...receive(task, requestedDuring), statusDetail: task.record.state === 'cancelled'
+                                ? 'Cancellation requested; owned operations are still settling. Poll this taskId with remote_cli_result. The workspace remains reserved until cleanup completes.'
+                                : 'Task finalization is still in progress. Poll this taskId with remote_cli_result. The workspace remains reserved until cleanup completes.' };
+                    }
                     return receive(task, requestedDuring);
                 }
                 if (name === 'remote_cli_integrate') {
@@ -1015,9 +1110,16 @@ ${prompt}`));
                         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;
+                    // Preserve prompt dispatch responses, but do not let slow managed Git
+                    // work outlive the tool adapter's HTTP timeout. Returning an accepted
+                    // task ID never cancels its work or releases its lease/execution slot.
+                    if (source)
+                        await waitForResponse(task.dispatched);
+                    else
+                        await task.dispatched;
+                    if (source && task.record.finishedAt === undefined && task.record.startedAt === undefined) {
+                        return { ...receive(task, requestedDuring), statusDetail: 'Task accepted; workspace preparation is still in progress. Poll this taskId with remote_cli_result instead of submitting the task again.' };
+                    }
                 }
                 return receive(task, requestedDuring);
             })();