@xingular/harness 1.3.1-unstable.2 → 1.3.1-unstable.4

package/dist/sdk/sessions/workSlice.js

@@ -1,8 +1,3 @@
-// A reply's work slice (PROP-0041): a bounded amount of work, then a handoff checkpoint, then a
-// continuation. The guard here refuses the call that would run past the budget, once with a
-// request for the checkpoint, and ends the reply if the model keeps calling tools. It also names
-// repeated work before it becomes a loop. All decisions are deterministic; no model is consulted.
-import { createHash } from 'node:crypto';
 import { findRun } from "./runStore.js";
 export const WORK_SLICE_EXTENSION = 'work-slice';
 /** The foundation defaults: enough for one meaningful step of work, short enough to report. */
@@ -99,34 +94,6 @@ export function sliceLimitReached(policy, state, now = Date.now()) {
 }
 /** Tools a reply may still call while it writes its handoff. A plan update waits for the next slice. */
 const HANDOFF_TOOLS = new Set(['checkpoint_write', 'session_name']);
-/** Tools whose repetition is how waiting works, not a loop. */
-const POLLING_TOOLS = new Set(['wait_subagents', 'subagents.list', 'subagents.status']);
-/** Commands that read as a check for the repeated-failure rule. */
-export function looksLikeCheck(command) {
-    return /\b(test|tests|typecheck|tsc|vitest|jest|cargo|check:|prove|lint|ci|build)\b/u.test(command);
-}
-/**
- * A stable rendering of a value: object keys sorted, so argument order never changes the result.
- * Depth is bounded so a cyclic or absurdly nested input cannot recurse forever.
- */
-function canonical(value, depth = 0) {
-    if (depth > 8)
-        return '…';
-    if (value === null || typeof value !== 'object')
-        return JSON.stringify(value) ?? 'null';
-    if (Array.isArray(value))
-        return `[${value.map((item) => canonical(item, depth + 1)).join(',')}]`;
-    const entries = Object.entries(value).filter(([, item]) => item !== undefined);
-    entries.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
-    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonical(item, depth + 1)}`).join(',')}}`;
-}
-/**
- * A call's identity: its name and every argument, hashed so the key stays small even when an
- * argument is a whole file. A changed argument is a different call; only an identical one repeats.
- * Reading a fixed handful of fields made every `todo_write` look identical, so a reply that
- * reported its progress was told it was repeating work.
- */
-const signature = (name, input) => `${name}\u0000${createHash('sha256').update(canonical(input ?? null)).digest('hex')}`;
 const clip = (value, limit) => (value.length <= limit ? value : `${value.slice(0, limit - 1)}…`);
 function handoffRequest(limit, state, checkpointAvailable = true) {
     const handoff = checkpointAvailable
@@ -134,87 +101,28 @@ function handoffRequest(limit, state, checkpointAvailable = true) {
         : 'Stop using tools and return a concise partial research report with findings, blockers and the next useful research step. The Harness records an evidence-derived checkpoint.';
     return clip(`This reply reached its work-slice limit (${limit}; step ${state.steps}). ${handoff} Do not call other tools.`, 600);
 }
-function stalledNote(reason, checkpointAvailable = true) {
-    const handoff = checkpointAvailable
-        ? 'Choose a different approach, read what the earlier attempt returned, or call checkpoint_write with the blocker so the next slice can decide.'
-        : 'Do not use more tools. Return concise findings and blockers in your final response; the Harness records an evidence-derived checkpoint.';
-    return clip(`You are repeating work: ${reason}. Do not repeat it. ${handoff}`, 600);
-}
 /**
- * Bounds one reply and names repeated work. Refusals request a checkpoint when available; without
- * one, they ask for a partial report and prohibit further tools. A repeated call or failing command
- * is named once, then ends the reply.
+ * Bounds one reply. A call past the budget is refused, with one wrap-up request when a checkpoint
+ * is available, and an ended reply lets only a handoff call through. Three compactions in one reply
+ * end it too. Every other call is allowed, however often it is made.
  */
 export function workSliceGuard(options) {
     const { policy, state } = options;
-    const calls = new Map();
-    const checkCalls = new Set();
-    const edits = new Map();
-    const failures = new Map();
-    let nudged = false;
     const checkpointAvailable = () => typeof options.checkpointAvailable === 'function'
         ? options.checkpointAvailable()
         : options.checkpointAvailable !== false;
-    /** Repetition is judged inside one reply; the next reply starts from a clean count. */
-    const resetRepetition = () => {
-        calls.clear();
-        checkCalls.clear();
-        edits.clear();
-        failures.clear();
-        nudged = false;
-    };
     const end = (kind, limit) => {
         state.endedBy = kind;
         state.endedByLimit = limit;
         options.onEnd?.(kind, limit);
         const canCheckpoint = checkpointAvailable();
-        const reason = kind === 'stuck'
-            ? stalledNote(limit, canCheckpoint)
-            : kind === 'compaction-thrash'
-                ? handoffRequest('three context compactions in one reply', state, canCheckpoint)
-                : handoffRequest(limit, state, canCheckpoint);
+        const reason = kind === 'compaction-thrash'
+            ? handoffRequest('three context compactions in one reply', state, canCheckpoint)
+            : handoffRequest(limit, state, canCheckpoint);
         return { block: true, terminate: true, reason };
     };
-    const nudge = (reason) => {
-        if (nudged)
-            return end('stuck', reason);
-        nudged = true;
-        const canCheckpoint = checkpointAvailable();
-        if (!canCheckpoint) {
-            state.endedBy = 'stuck';
-            state.endedByLimit = reason;
-        }
-        return { block: true, reason: stalledNote(reason, canCheckpoint) };
-    };
-    const repeated = (name, input) => {
-        if (POLLING_TOOLS.has(name))
-            return null;
-        const key = signature(name, input);
-        if (name === 'bash') {
-            const command = input && typeof input === 'object' ? String(input.command ?? '') : '';
-            if (command && looksLikeCheck(command))
-                checkCalls.add(key);
-        }
-        const count = (calls.get(key) ?? 0) + 1;
-        calls.set(key, count);
-        if (count < 3)
-            return null;
-        return name === 'bash' ? `the same Bash command ${count} times (steps ending at ${state.steps})` : `the same ${name} call ${count} times (steps ending at ${state.steps})`;
-    };
-    const failing = (name, input) => {
-        if (name !== 'bash')
-            return null;
-        const command = input && typeof input === 'object' ? String(input.command ?? '') : '';
-        if (!command || !looksLikeCheck(command))
-            return null;
-        const count = failures.get(command) ?? 0;
-        return count >= 2 ? `the check ${command} failed ${count} times` : null;
-    };
     return (pi) => {
-        pi.on('agent_start', () => {
-            resetSliceState(state);
-            resetRepetition();
-        });
+        pi.on('agent_start', () => resetSliceState(state));
         pi.on('message_end', (event) => {
             const usage = event.message.usage;
             if (event.message.role !== 'assistant' || !usage)
@@ -223,36 +131,8 @@ export function workSliceGuard(options) {
             state.tokens += (usage.input ?? 0) + (usage.cacheWrite ?? 0) + (usage.output ?? 0);
         });
         pi.on('tool_result', (event) => {
-            if (event.toolName === 'checkpoint_write' && !event.isError) {
+            if (event.toolName === 'checkpoint_write' && !event.isError)
                 state.checkpointWritten = true;
-                nudged = false;
-            }
-            if ((event.toolName === 'edit' || event.toolName === 'write') && event.isError === false) {
-                const path = event.input && typeof event.input === 'object' ? String(event.input.path ?? '') : '';
-                if (path) {
-                    edits.set(path, (edits.get(path) ?? 0) + 1);
-                    failures.clear();
-                    for (const key of checkCalls)
-                        calls.delete(key);
-                    checkCalls.clear();
-                    nudged = false;
-                }
-            }
-            if (event.toolName !== 'bash')
-                return;
-            const command = event.input && typeof event.input === 'object' ? String(event.input.command ?? '') : '';
-            if (!command || !looksLikeCheck(command))
-                return;
-            if (event.isError) {
-                failures.set(command, (failures.get(command) ?? 0) + 1);
-                return;
-            }
-            // A passing check is progress: the repetition rules start over.
-            failures.delete(command);
-            edits.clear();
-            calls.clear();
-            checkCalls.clear();
-            nudged = false;
         });
         pi.on('tool_call', (event) => {
             const name = event.toolName;
@@ -284,27 +164,6 @@ export function workSliceGuard(options) {
                 state.refusedAt ??= state.steps;
                 return handoff ? undefined : { block: true, reason: handoffRequest(limit, state, canCheckpoint) };
             }
-            if (handoff)
-                return undefined;
-            // Todo updates are bookkeeping, not evidence of progress or a stall. They still count above
-            // toward the reply's overall tool-call budget.
-            if (name === 'todo_write')
-                return undefined;
-            const edit = name === 'edit' || name === 'write';
-            const path = edit && event.input && typeof event.input === 'object' ? String(event.input.path ?? '') : '';
-            if (edit && path) {
-                const count = edits.get(path) ?? 0;
-                if (count >= 4) {
-                    const reason = `${path} was edited ${count} times with no passing check between`;
-                    return nudge(reason);
-                }
-            }
-            const repeat = repeated(name, event.input);
-            const failure = failing(name, event.input);
-            const reason = repeat ?? failure;
-            if (!reason)
-                return undefined;
-            return nudge(reason);
         });
     };
 }

package/dist/sdk/terminal/client.d.ts

@@ -1,5 +1,7 @@
 export declare const SOCKET_ENV = "XINGULAR_HARNESS_SOCKET";
 export declare const TOKEN_ENV = "XINGULAR_HARNESS_TOKEN";
+/** Set by `xagent --remote-control`: the terminal turns on `/remote-control` as it opens. */
+export declare const REMOTE_CONTROL_ENV = "XINGULAR_HARNESS_REMOTE_CONTROL";
 export declare class SocketError extends Error {
     readonly code: string;
     constructor(code: string, message: string);
@@ -10,6 +12,6 @@ export interface SocketConnection {
 }
 export declare function connectionFromEnv(env?: NodeJS.ProcessEnv): SocketConnection;
 /** A memory, Wiki, recall, or connected-app call made on behalf of the session that owns the token. */
-export declare function socketCall<T = unknown>(connection: SocketConnection, call: string, params?: Record<string, unknown>, timeoutMs?: number, control?: string): Promise<T>;
+export declare function socketCall<T = unknown>(connection: SocketConnection, call: string, params?: Record<string, unknown>, timeoutMs?: number, control?: string, signal?: AbortSignal): Promise<T>;
 /** Telemetry and decisions from the native `pi` process. Approvals may wait on a person, so the default wait is long. */
 export declare function terminalCall<T = Record<string, unknown>>(event: string, data?: Record<string, unknown>, timeoutMs?: number): Promise<T>;

package/dist/sdk/terminal/client.js

@@ -5,6 +5,8 @@
 import { createConnection } from 'node:net';
 export const SOCKET_ENV = 'XINGULAR_HARNESS_SOCKET';
 export const TOKEN_ENV = 'XINGULAR_HARNESS_TOKEN';
+/** Set by `xagent --remote-control`: the terminal turns on `/remote-control` as it opens. */
+export const REMOTE_CONTROL_ENV = 'XINGULAR_HARNESS_REMOTE_CONTROL';
 export class SocketError extends Error {
     code;
     constructor(code, message) {
@@ -46,18 +48,18 @@ function putIdle(path, stream) {
     entries.add(entry);
     idle.set(path, entries);
 }
-function request(connection, body, what, timeoutMs) {
+function request(connection, body, what, timeoutMs, signal) {
     const reused = takeIdle(connection.socket);
-    return attempt(connection, body, what, timeoutMs, reused).catch((error) => {
+    return attempt(connection, body, what, timeoutMs, reused, signal).catch((error) => {
         // An idle connection the harness had already closed fails before any reply; one fresh retry.
         if (reused && error instanceof StaleConnection)
-            return attempt(connection, body, what, timeoutMs, undefined);
+            return attempt(connection, body, what, timeoutMs, undefined, signal);
         throw error;
     });
 }
 class StaleConnection extends Error {
 }
-function attempt(connection, body, what, timeoutMs, reused) {
+function attempt(connection, body, what, timeoutMs, reused, signal) {
     return new Promise((resolve, reject) => {
         const stream = reused ?? createConnection(connection.socket);
         let buffer = '';
@@ -91,6 +93,7 @@ function attempt(connection, body, what, timeoutMs, reused) {
                 return;
             settled = true;
             clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
             stream.off('connect', send);
             stream.off('data', onData);
             stream.off('error', onError);
@@ -107,6 +110,12 @@ function attempt(connection, body, what, timeoutMs, reused) {
             stream.destroy();
             finish(() => reject(new SocketError('timeout', `The harness did not answer ${what}.`)));
         }, timeoutMs);
+        const onAbort = () => { stream.destroy(); finish(() => reject(new SocketError('aborted', `${what} was cancelled.`))); };
+        if (signal?.aborted) {
+            onAbort();
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
         stream.on('data', onData);
         stream.on('error', onError);
         stream.on('close', onClose);
@@ -117,8 +126,8 @@ function attempt(connection, body, what, timeoutMs, reused) {
     });
 }
 /** A memory, Wiki, recall, or connected-app call made on behalf of the session that owns the token. */
-export function socketCall(connection, call, params = {}, timeoutMs = 120_000, control) {
-    return request(connection, { call, params, ...(control ? { control } : {}) }, call, timeoutMs);
+export function socketCall(connection, call, params = {}, timeoutMs = 120_000, control, signal) {
+    return request(connection, { call, params, ...(control ? { control } : {}) }, call, timeoutMs, signal);
 }
 /** Telemetry and decisions from the native `pi` process. Approvals may wait on a person, so the default wait is long. */
 export function terminalCall(event, data = {}, timeoutMs = 600_000) {

package/dist/sdk/terminal/control.d.ts

@@ -1,4 +1,4 @@
 import { type SocketConnection } from "./client.js";
 /** A process owns the claim across native session replacement; it never enters the environment. */
 export declare function claimTerminalControl(connection?: SocketConnection): Promise<string>;
-export declare function controlCall<T = unknown>(call: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<T>;
+export declare function controlCall<T = unknown>(call: string, params?: Record<string, unknown>, timeoutMs?: number, signal?: AbortSignal): Promise<T>;

package/dist/sdk/terminal/control.js

@@ -18,8 +18,8 @@ export function claimTerminalControl(connection = connectionFromEnv()) {
     }
     return claim;
 }
-export async function controlCall(call, params = {}, timeoutMs = 120_000) {
+export async function controlCall(call, params = {}, timeoutMs = 120_000, signal) {
     const connection = connectionFromEnv();
     const control = await claimTerminalControl(connection);
-    return socketCall(connection, call, params, timeoutMs, control);
+    return signal ? socketCall(connection, call, params, timeoutMs, control, signal) : socketCall(connection, call, params, timeoutMs, control);
 }

package/dist/sdk/terminal/controller.d.ts

@@ -57,7 +57,10 @@ export interface ControllerHooks {
 export declare class TerminalController {
     private readonly hooks;
     private run;
+    private lastRunId;
     private readonly pending;
+    private pendingRevision;
+    private readonly pendingWaiters;
     private readonly subagents;
     private subagentParentRunId;
     private ready;
@@ -70,9 +73,20 @@ export declare class TerminalController {
     private nativeId;
     private readonly seen;
     private readonly commands;
+    /** When the reply last produced something other than a heartbeat; silence is what a stall is. */
+    private progressAt;
+    private readonly runningTools;
+    private stallRequested;
+    private stallTimer;
     constructor(hooks: ControllerHooks);
+    private pendingChanged;
+    private setPending;
+    private deletePending;
+    private waitPending;
     get nativeSessionId(): string | null;
     get activeRun(): ActiveRun | null;
+    /** The run this terminal is showing, or the last one it finished: `/context` reads it after a reply. */
+    get lastRun(): string | null;
     state(): {
         ready: boolean;
         dirty: boolean;
@@ -81,6 +95,14 @@ export declare class TerminalController {
     private requestId;
     private begin;
     private finish;
+    private watchProgress;
+    private stopStallWatch;
+    /**
+     * Ends a reply its native turn can no longer finish: the process is alive and keeps reporting, but
+     * the reply produced nothing for the whole window (a model request that never came back). A person
+     * may already be answering an approval, and a tool may still be working, so neither is cut short.
+     */
+    private checkStall;
     /** Hands the native process an instruction and waits until it acknowledges the prompt. */
     send(runId: string, text: string): Promise<void>;
     /** What the person typed into the terminal, so an instruction is never sent over their draft. */

package/dist/sdk/terminal/controller.js

@@ -7,6 +7,7 @@ import { HarnessError } from "../core/errors.js";
 import { runStatusSchema } from "../sessions/contracts.js";
 import { briefTitle } from "../sessions/subagents.js";
 import { MAIN_PROFILE, SubagentMonitor } from "./subagentMonitor.js";
+import { replyStalled } from "./stallWatch.js";
 function monitorRun(record, relation, profile, runtime) {
     return {
         id: record.id,
@@ -23,10 +24,15 @@ function monitorRun(record, relation, profile, runtime) {
 }
 const READY_TIMEOUT_MS = 90_000;
 const ACK_TIMEOUT_MS = 25_000;
+/** How often a live reply's progress is checked against the stall windows. */
+const STALL_CHECK_MS = 30_000;
 export class TerminalController {
     hooks;
     run = null;
+    lastRunId = null;
     pending = new Map();
+    pendingRevision = 0;
+    pendingWaiters = new Set();
     subagents = new SubagentMonitor();
     subagentParentRunId = null;
     ready = false;
@@ -39,16 +45,48 @@ export class TerminalController {
     nativeId;
     seen = new Map();
     commands = [];
+    /** When the reply last produced something other than a heartbeat; silence is what a stall is. */
+    progressAt = 0;
+    runningTools = new Map();
+    stallRequested = null;
+    stallTimer = null;
     constructor(hooks) {
         this.hooks = hooks;
         this.nativeId = hooks.nativeSessionId;
     }
+    pendingChanged() {
+        this.pendingRevision += 1;
+        for (const wake of this.pendingWaiters)
+            wake();
+    }
+    setPending(key, value) {
+        this.pending.set(key, value);
+        this.pendingChanged();
+    }
+    deletePending(key) {
+        if (this.pending.delete(key))
+            this.pendingChanged();
+    }
+    async waitPending(revision) {
+        if (revision === this.pendingRevision && !this.disposed) {
+            await new Promise(resolve => {
+                const wake = () => { clearTimeout(timer); this.pendingWaiters.delete(wake); resolve(); };
+                const timer = setTimeout(wake, 20_000);
+                this.pendingWaiters.add(wake);
+            });
+        }
+        return { revision: this.pendingRevision, requests: [...this.pending.values()] };
+    }
     get nativeSessionId() {
         return this.nativeId;
     }
     get activeRun() {
         return this.run && !this.run.finished ? this.run : null;
     }
+    /** The run this terminal is showing, or the last one it finished: `/context` reads it after a reply. */
+    get lastRun() {
+        return this.activeRun?.runId ?? this.lastRunId;
+    }
     state() {
         return { ready: this.ready, dirty: this.dirty, active: !!this.activeRun || !!this.delivery };
     }
@@ -67,7 +105,9 @@ export class TerminalController {
             throw new Error('The native prompt did not match the reserved delivery. Inspect the terminal before continuing.');
         const run = this.hooks.begin({ reservedRunId: delivery?.runId ?? null, nativeTurnId, text, ...launch });
         this.run = run;
+        this.lastRunId = run.runId;
         this.subagentParentRunId = run.runId;
+        this.watchProgress();
         this.subagents.begin(run.runId);
         run.onInterrupt(() => void this.commands.push({ type: 'interrupt' }));
         if (text)
@@ -77,10 +117,45 @@ export class TerminalController {
         return run;
     }
     finish(outcome, message, reason) {
+        this.stopStallWatch();
         this.run?.finish(outcome, message ? { code: 'terminal_attention', message } : undefined, reason);
         this.run = null;
         this.seen.clear();
-        this.pending.clear();
+        if (this.pending.size) {
+            this.pending.clear();
+            this.pendingChanged();
+        }
+    }
+    watchProgress() {
+        this.progressAt = Date.now();
+        this.runningTools.clear();
+        this.stallRequested = null;
+        if (this.stallTimer)
+            clearInterval(this.stallTimer);
+        this.stallTimer = setInterval(() => this.checkStall(), STALL_CHECK_MS);
+        this.stallTimer.unref?.();
+    }
+    stopStallWatch() {
+        if (this.stallTimer)
+            clearInterval(this.stallTimer);
+        this.stallTimer = null;
+        this.stallRequested = null;
+        this.runningTools.clear();
+    }
+    /**
+     * Ends a reply its native turn can no longer finish: the process is alive and keeps reporting, but
+     * the reply produced nothing for the whole window (a model request that never came back). A person
+     * may already be answering an approval, and a tool may still be working, so neither is cut short.
+     */
+    checkStall() {
+        const run = this.activeRun;
+        if (!run || this.stallRequested || this.pending.size)
+            return;
+        if (!replyStalled({ now: Date.now(), progressAt: this.progressAt, runningTools: [...this.runningTools.values()] }))
+            return;
+        this.stallRequested = run.runId;
+        this.hooks.telemetry('stall');
+        this.commands.push({ type: 'interrupt' });
     }
     /** Hands the native process an instruction and waits until it acknowledges the prompt. */
     async send(runId, text) {
@@ -145,19 +220,19 @@ export class TerminalController {
             return;
         if (event.type === 'question.requested') {
             const payload = event.payload;
-            this.pending.set(String(payload.questionId), { ...payload, type: 'question', requestId: payload.questionId, runId: event.runId });
+            this.setPending(String(payload.questionId), { ...payload, type: 'question', requestId: payload.questionId, runId: event.runId });
         }
         else if (event.type === 'approval.requested') {
             const payload = event.payload;
             if (!payload.automatic && (descendant || payload.target === 'workspace-write')) {
-                this.pending.set(String(payload.approvalId), { ...payload, type: 'approval', requestId: payload.approvalId, runId: event.runId });
+                this.setPending(String(payload.approvalId), { ...payload, type: 'approval', requestId: payload.approvalId, runId: event.runId });
             }
         }
         else if (event.type === 'approval.resolved') {
-            this.pending.delete(String(event.payload.approvalId));
+            this.deletePending(String(event.payload.approvalId));
         }
         else if (event.type === 'question.answered') {
-            this.pending.delete(String(event.payload.questionId));
+            this.deletePending(String(event.payload.questionId));
         }
     }
     /** A child event that belongs to the active terminal parent run. */
@@ -197,6 +272,8 @@ export class TerminalController {
         }
         if (call === 'terminal.pending')
             return { requests: [...this.pending.values()] };
+        if (call === 'terminal.pending.wait')
+            return this.waitPending(data.revision);
         if (call === 'terminal.interrupt')
             return this.activeRun && this.hooks.interrupt ? this.hooks.interrupt(this.activeRun.runId) : {};
         if (call === 'terminal.policy') {
@@ -292,7 +369,7 @@ export class TerminalController {
             rememberable: policy.rememberable === true,
             standing: policy.standing
         });
-        this.pending.set(key, {
+        this.setPending(key, {
             type: 'approval', requestId: key, runId: run.runId, target: tool, action,
             operation, rememberable: policy.rememberable === true, direct: true
         });
@@ -301,13 +378,14 @@ export class TerminalController {
             return { decision: await response };
         }
         finally {
-            this.pending.delete(key);
+            this.deletePending(key);
         }
     }
     async accept(event, data) {
         if (this.disposed)
             throw new Error('This terminal controller was disposed.');
-        if (event !== 'poll')
+        // Streamed reply text is frequent and only feeds run events; it is not host telemetry.
+        if (event !== 'poll' && event !== 'delta')
             this.hooks.telemetry(event);
         if (event === 'startup') {
             this.startupPhase = String(data.phase);
@@ -321,6 +399,9 @@ export class TerminalController {
         }
         if (event === 'poll')
             return { command: this.commands.shift() ?? null };
+        // A heartbeat proves the turn is alive, not that it is working; only real events restart the clock.
+        if (event !== 'heartbeat')
+            this.progressAt = Date.now();
         if (event === 'ready') {
             if (!this.ready) {
                 this.dirty = false;
@@ -355,7 +436,8 @@ export class TerminalController {
         if (event === 'settled') {
             // A reply that stopped at its work-slice boundary is interrupted, not completed: the record
             // says `slice_complete` (or `stalled`) so a host can continue it (PROP-0041).
-            const reason = typeof data.reason === 'string' ? data.reason : undefined;
+            const stalled = this.stallRequested !== null && this.stallRequested === this.run?.runId;
+            const reason = stalled ? 'stalled' : typeof data.reason === 'string' ? data.reason : undefined;
             const outcome = data.error ? 'failed' : data.aborted || reason ? 'interrupted' : 'completed';
             this.finish(outcome, data.error ? String(data.error) : undefined, reason);
             return {};
@@ -380,9 +462,9 @@ export class TerminalController {
                 const summary = typeof data.summary === 'string' && data.summary.trim() ? data.summary.trim() : undefined;
                 const sketchMode = data.uiSketch === undefined ? {} : { uiSketch: data.uiSketch };
                 const response = run.requestAnswer({ requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect, allowText: true });
-                this.pending.set(key, { type: 'question', requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect });
+                this.setPending(key, { type: 'question', requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect });
                 this.seen.set(key, response);
-                return response.finally(() => this.pending.delete(key));
+                return response.finally(() => this.deletePending(key));
             }
             const response = run.requestApproval({
                 requestId: key,
@@ -391,26 +473,34 @@ export class TerminalController {
                 operation: { tool: String(data.tool ?? data.target), args: data.args ?? {} },
                 rememberable: false
             });
-            this.pending.set(key, { type: 'approval', requestId: key, target: String(data.target ?? 'Action'), action: String(data.action ?? '{}') });
+            this.setPending(key, { type: 'approval', requestId: key, target: String(data.target ?? 'Action'), action: String(data.action ?? '{}') });
             this.seen.set(key, response);
             try {
                 return { decision: await response };
             }
             finally {
-                this.pending.delete(key);
+                this.deletePending(key);
             }
         }
         if (event === 'usage')
             run.emit('usage.updated', data);
+        else if (event === 'heartbeat')
+            run.emit('heartbeat', data);
         else if (event === 'todo' || event === 'checklist')
             run.emit('todo.updated', { items: data.items });
         else if (event === 'checkpoint')
             run.emit('checkpoint', data);
         else if (event === 'file')
             run.emit('file.changed', data);
+        else if (event === 'delta')
+            run.emit('message.delta', { messageId: String(data.id ?? ''), text: String(data.text ?? '') });
         else if (event === 'message')
             run.emit('message.completed', { messageId: data.id ?? randomUUID(), role: data.role ?? 'assistant', text: String(data.text) });
         else if (event === 'tool') {
+            if (data.phase === 'start')
+                this.runningTools.set(String(data.id), Date.now());
+            else
+                this.runningTools.delete(String(data.id));
             run.emit(data.phase === 'start' ? 'tool.started' : 'tool.completed', {
                 toolCallId: String(data.id),
                 name: String(data.name),
@@ -425,6 +515,7 @@ export class TerminalController {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.pendingChanged();
         this.ready = false;
         this.delivery?.reject(new Error('The terminal stopped before prompt acknowledgement.'));
         this.delivery = null;