@xingular/harness 1.5.0-unstable → 1.6.0-unstable

package/dist/sdk/sessions/workSlice.d.ts

@@ -22,7 +22,13 @@ export interface SlicePolicy {
     maxSlices: number;
     continue: boolean;
 }
-/** The foundation defaults: enough for one meaningful step of work, short enough to report. */
+/**
+ * The foundation defaults: no budget (ADR-0081). A reply is not cut at a number of tool calls, a
+ * length of time or a number of tokens, and nothing is continued as a "next slice"; it ends when the
+ * work is done, a person's decision is needed, or the person interrupts. The limits stay available
+ * to a caller that asks for one (`workSlice`, `XINGULAR_WORK_SLICE`), and the three-compaction guard
+ * is not a budget and stays on.
+ */
 export declare const DEFAULT_SLICE_POLICY: SlicePolicy;
 export declare class WorkSliceError extends Error {
 }
@@ -150,4 +156,12 @@ export declare function sliceContinuation(options: SliceContinuationOptions): (p
 export declare function sliceOf(root: string, runId: string, limit?: number): number;
 /** The reason a checkpoint the harness derives (no model handoff) records. */
 export declare function derivedReason(end: SliceEnd | null): Checkpoint['reason'];
+/** What a heartbeat reports about the tools in flight: their names once each, and the oldest one's age. */
+export declare function activeToolBeat(tools: ReadonlyMap<string, {
+    name: string;
+    at: number;
+}>, now?: number): {
+    activeTools: string[];
+    oldestToolMs: number;
+} | Record<string, never>;
 export {};

package/dist/sdk/sessions/workSlice.js

@@ -1,17 +1,18 @@
 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. */
+/**
+ * The foundation defaults: no budget (ADR-0081). A reply is not cut at a number of tool calls, a
+ * length of time or a number of tokens, and nothing is continued as a "next slice"; it ends when the
+ * work is done, a person's decision is needed, or the person interrupts. The limits stay available
+ * to a caller that asks for one (`workSlice`, `XINGULAR_WORK_SLICE`), and the three-compaction guard
+ * is not a budget and stays on.
+ */
 export const DEFAULT_SLICE_POLICY = {
     enabled: true,
-    // A chapter of a task, not an interruption every few edits: roughly 80 minutes of ordinary work
-    // (about 15 s a call), with 60 minutes of wall clock as the ceiling, whichever comes first. A task
-    // still gets eight slices before it returns to the person.
-    maxToolCalls: 320,
-    maxMinutes: 60,
-    // No token cap: the tool calls and the clock are the bound. Counting new input, cache writes and
-    // output made a few large reads end a reply before useful work (see the "Confirm plan model
-    // support" thread), so a cap is available to whoever asks for one and off unless they do.
+    maxToolCalls: 0,
+    maxMinutes: 0,
     maxNewTokens: 0,
+    // Inert while no limit ends a slice; a caller that sets one gets the same continuation as before.
     maxSlices: 8,
     continue: true
 };
@@ -256,3 +257,10 @@ export function sliceOf(root, runId, limit = 100) {
 export function derivedReason(end) {
     return end ?? 'requested';
 }
+/** What a heartbeat reports about the tools in flight: their names once each, and the oldest one's age. */
+export function activeToolBeat(tools, now = Date.now()) {
+    if (!tools.size)
+        return {};
+    const names = [...new Set([...tools.values()].map((tool) => tool.name))].slice(0, 16);
+    return { activeTools: names, oldestToolMs: Math.max(0, now - Math.min(...[...tools.values()].map((tool) => tool.at))) };
+}

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

@@ -78,6 +78,8 @@ export declare class TerminalController {
     /** When the reply last produced something other than a heartbeat; silence is what a stall is. */
     private progressAt;
     private readonly runningTools;
+    /** Each live subagent's own clock: its last real event and the tools it is inside. */
+    private readonly children;
     private stallRequested;
     private stallTimer;
     constructor(hooks: ControllerHooks);
@@ -103,6 +105,8 @@ export declare class TerminalController {
      * 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.
+     * A reply that is only waiting for subagents is judged by them: a quiet child is ended on its own
+     * clock, which returns the wait and lets the reply carry on without anyone stepping in.
      */
     private checkStall;
     /** Hands the native process an instruction and waits until it acknowledges the prompt. */
@@ -115,6 +119,8 @@ export declare class TerminalController {
     observe(event: RunEvent, descendant?: boolean): void;
     /** A child event that belongs to the active terminal parent run. */
     observeSubagent(parentRunId: string, run: RunRecord, event: RunEvent, profile?: TerminalSubagentProfile | null, runtime?: Pick<TerminalSubagentRun, 'accountLabel' | 'model' | 'effort'>): void;
+    /** Folds a child's event into its own stall clock; a heartbeat only proves the process lives. */
+    private trackChild;
     /** An event of the tracked parent run itself, shown as the `main` row; it outlives settlement. */
     observeMain(run: RunRecord, event: RunEvent, runtime?: MonitorRuntime): void;
     /** Shows a saved parent run and its descendants, as they ended, until another run begins. */

package/dist/sdk/terminal/controller.js

@@ -4,10 +4,10 @@
 // extension's questions about policy, approvals, and what to do next.
 import { createHash, randomUUID } from 'node:crypto';
 import { HarnessError } from "../core/errors.js";
-import { runStatusSchema } from "../sessions/contracts.js";
+import { isActiveStatus, runStatusSchema } from "../sessions/contracts.js";
 import { briefTitle } from "../sessions/subagents.js";
 import { MAIN_PROFILE, SubagentMonitor } from "./subagentMonitor.js";
-import { replyStalled } from "./stallWatch.js";
+import { childStalled, replyStalled, waitingOnChildren } from "./stallWatch.js";
 /** Stop codes the native extension may report for a reply it settled itself. */
 const SETTLED_CODES = new Set(['slice_budget', 'compaction_thrash', 'needs_person', 'unfinished']);
 function monitorRun(record, relation, profile, runtime) {
@@ -50,6 +50,8 @@ export class TerminalController {
     /** When the reply last produced something other than a heartbeat; silence is what a stall is. */
     progressAt = 0;
     runningTools = new Map();
+    /** Each live subagent's own clock: its last real event and the tools it is inside. */
+    children = new Map();
     stallRequested = null;
     stallTimer = null;
     constructor(hooks) {
@@ -131,6 +133,7 @@ export class TerminalController {
     watchProgress() {
         this.progressAt = Date.now();
         this.runningTools.clear();
+        this.children.clear();
         this.stallRequested = null;
         if (this.stallTimer)
             clearInterval(this.stallTimer);
@@ -143,17 +146,34 @@ export class TerminalController {
         this.stallTimer = null;
         this.stallRequested = null;
         this.runningTools.clear();
+        this.children.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.
+     * A reply that is only waiting for subagents is judged by them: a quiet child is ended on its own
+     * clock, which returns the wait and lets the reply carry on without anyone stepping in.
      */
     checkStall() {
         const run = this.activeRun;
-        if (!run || this.stallRequested || this.pending.size)
+        if (!run || this.pending.size)
             return;
-        if (!replyStalled({ now: Date.now(), progressAt: this.progressAt, runningTools: [...this.runningTools.values()] }))
+        const now = Date.now();
+        const children = [...this.children.values()].map((child) => ({ progressAt: child.progressAt, runningTools: [...child.tools.values()], stopRequestedAt: child.stopRequestedAt }));
+        for (const [id, child] of this.children) {
+            if (!childStalled(now, { progressAt: child.progressAt, runningTools: [...child.tools.values()], stopRequestedAt: child.stopRequestedAt }))
+                continue;
+            child.stopRequestedAt = now;
+            this.hooks.telemetry('stall');
+            void this.hooks.interrupt?.(id, { reason: 'stalled', code: 'stalled' }).catch(() => { });
+        }
+        if (this.stallRequested)
+            return;
+        const tools = [...this.runningTools.values()];
+        if (waitingOnChildren(now, tools.map((tool) => tool.name), children))
+            return;
+        if (!replyStalled({ now, progressAt: this.progressAt, runningTools: tools.map((tool) => tool.at) }))
             return;
         this.stallRequested = run.runId;
         this.hooks.telemetry('stall');
@@ -242,6 +262,25 @@ export class TerminalController {
         if (this.disposed || this.activeRun?.runId !== parentRunId || run.relation !== 'subagent')
             return;
         this.subagents.observe(parentRunId, monitorRun(run, 'subagent', profile, runtime), event);
+        this.trackChild(run, event);
+    }
+    /** Folds a child's event into its own stall clock; a heartbeat only proves the process lives. */
+    trackChild(run, event) {
+        const status = event.payload.status;
+        const settled = event.type === 'completed' || event.type === 'failed' || (event.type === 'status.changed' && typeof status === 'string' && !isActiveStatus(status));
+        if (settled || !isActiveStatus(run.status)) {
+            this.children.delete(run.id);
+            return;
+        }
+        const child = this.children.get(run.id) ?? { progressAt: Date.now(), tools: new Map(), stopRequestedAt: null };
+        if (event.type !== 'heartbeat')
+            child.progressAt = Date.now();
+        const toolCallId = String(event.payload.toolCallId ?? '');
+        if (event.type === 'tool.started' && toolCallId)
+            child.tools.set(toolCallId, Date.now());
+        else if (event.type === 'tool.completed')
+            child.tools.delete(toolCallId);
+        this.children.set(run.id, child);
     }
     /** An event of the tracked parent run itself, shown as the `main` row; it outlives settlement. */
     observeMain(run, event, runtime = {}) {
@@ -514,7 +553,7 @@ export class TerminalController {
             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());
+                this.runningTools.set(String(data.id), { name: String(data.name ?? ''), at: Date.now() });
             else
                 this.runningTools.delete(String(data.id));
             run.emit(data.phase === 'start' ? 'tool.started' : 'tool.completed', {

package/dist/sdk/terminal/opentui/model.js

@@ -1,5 +1,6 @@
 import { sessionEntryToContextMessages } from '@earendil-works/pi-coding-agent';
 import { parseProposedPlan } from "../tui/planMode.js";
+import { toolDisplayName } from "../toolName.js";
 import { ansiLabel, ansiPlain } from "./ansi.js";
 const MAX_TOOL_OUTPUT = 12_000;
 const OUTPUT_CLIP_MARKER = '\n… output clipped …\n';
@@ -447,7 +448,8 @@ export class TranscriptModel {
             const text = contentText(message.content);
             if (!text.trim())
                 return items;
-            items.push({ kind: 'custom', id: `m${index}`, label: stringField(message, 'customType') ?? 'Extension', text });
+            const customType = stringField(message, 'customType') ?? '';
+            items.push({ kind: 'custom', id: `m${index}`, label: toolDisplayName(customType) || 'Extension', text });
             return items;
         }
         if (role === 'compactionSummary') {

package/dist/sdk/terminal/piExtension.js

@@ -16,7 +16,7 @@ import { goalStopOutcome, handoffFields, stopCheckpointReason, stopSummary } fro
 import { launchSwitchOff, sessionCheckModel } from "../sessions/completionCheck.js";
 import { GOAL_STATE_ENTRY, GOAL_TOOLS, goalTools } from "../sessions/goal.js";
 import { GOAL_EXTENSION, goalLoop, goalNotice } from "../sessions/goalLoop.js";
-import { createSliceState, DEFAULT_SLICE_POLICY, parseWorkSlice, sliceContinuation, workSliceGuard, WORK_SLICE_EXTENSION } from "../sessions/workSlice.js";
+import { activeToolBeat, createSliceState, DEFAULT_SLICE_POLICY, parseWorkSlice, sliceContinuation, workSliceGuard, WORK_SLICE_EXTENSION } from "../sessions/workSlice.js";
 import { DEFAULT_COMMAND_TIMEOUT_SECONDS, withCommandBudget } from "../core/commandBudget.js";
 import { SESSION_NAME, deriveSessionName, sessionNameTool } from "../tools/sessionName.js";
 import { CAPABILITY_DISCOVERY, describeCapabilities } from "../tools/getCapabilities.js";
@@ -76,6 +76,7 @@ export default async function (pi, planRun, getSession, goal) {
     let requestStartedAt = null;
     let pendingRefusals = [];
     const toolStartedAt = new Map();
+    const toolsInFlight = new Map();
     const fileTools = new Map();
     const writeAuthorizations = new Map();
     let workspaceRoot = null;
@@ -298,6 +299,7 @@ export default async function (pi, planRun, getSession, goal) {
         // A live reply reports progress so a person and the watchdog can tell a long turn from a wedged
         // one; a turn that stops producing anything is settled with reason `stalled` (INV-RUN-14).
         turnStartedAt = Date.now();
+        toolsInFlight.clear();
         if (heartbeat)
             clearInterval(heartbeat);
         heartbeat = setInterval(() => {
@@ -307,7 +309,8 @@ export default async function (pi, planRun, getSession, goal) {
                 lastTool: sliceState.lastTool,
                 compactions: sliceState.compactions,
                 slice: sliceState.slice,
-                maxToolCalls: slicePolicy.enabled ? slicePolicy.maxToolCalls : 0
+                maxToolCalls: slicePolicy.enabled ? slicePolicy.maxToolCalls : 0,
+                ...activeToolBeat(toolsInFlight)
             }, 10_000).catch(() => { });
         }, 30_000);
         heartbeat.unref?.();
@@ -735,11 +738,13 @@ export default async function (pi, planRun, getSession, goal) {
         if (['edit', 'write'].includes(event.toolName) && typeof event.args.path === 'string')
             fileTools.set(event.toolCallId, event.args.path);
         toolStartedAt.set(event.toolCallId, Date.now());
+        toolsInFlight.set(event.toolCallId, { name: event.toolName, at: Date.now() });
         await terminalCall('tool', { phase: 'start', id: event.toolCallId, name: event.toolName, summary: JSON.stringify(event.args).slice(0, 200) });
     });
     pi.on('tool_execution_end', async (event) => {
         const started = toolStartedAt.get(event.toolCallId);
         toolStartedAt.delete(event.toolCallId);
+        toolsInFlight.delete(event.toolCallId);
         const resultChars = resultSize(event.result);
         await terminalCall('tool', { phase: 'end', id: event.toolCallId, name: event.toolName, ok: !event.isError, ...(started === undefined ? {} : { durationMs: Date.now() - started }), ...(resultChars === null ? {} : { resultChars }) });
         const path = fileTools.get(event.toolCallId);

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

@@ -11,3 +11,21 @@ export interface ReplyProgress {
 }
 /** Whether a live reply has gone too long without progress and should be ended. The oldest running tool counts. */
 export declare function replyStalled({ now, progressAt, runningTools }: ReplyProgress): boolean;
+/** The tools that block a reply until its children settle. */
+export declare const CHILD_WAIT_TOOLS: ReadonlySet<string>;
+/** How long a child may stay unsettled after it was told to stop before its parent's own watch resumes. */
+export declare const CHILD_STOP_GRACE_MS: number;
+/** One subagent the terminal reply is waiting on. */
+export interface ChildProgress {
+    progressAt: number;
+    runningTools: readonly number[];
+    /** When the stall watch ended this child, if it did. */
+    stopRequestedAt: number | null;
+}
+/** Whether a child has gone quiet for the same windows as a reply, and was not yet told to stop. */
+export declare function childStalled(now: number, child: ChildProgress): boolean;
+/**
+ * Whether the parent's own watch is paused: it is only waiting for children, and at least one still
+ * answers to its own watch. A child that ignored the stop for the grace period hands the clock back.
+ */
+export declare function waitingOnChildren(now: number, runningToolNames: readonly string[], children: readonly ChildProgress[]): boolean;

package/dist/sdk/terminal/stallWatch.js

@@ -2,6 +2,9 @@
 // told instead of watching a run that never settles. This is the turn-level rule; the run-store
 // sweep (`reconcileStaleRuns`) settles a record whose owner stopped reporting, and both use the
 // same reason, `stalled` (INV-RUN-14).
+//
+// A reply that waits for its subagents is not silent: each child is watched on its own clock and ended
+// with the same reason when it goes quiet, so the wait returns and the parent carries on by itself.
 /** Silence with no tool running: the model request never came back. */
 export const REPLY_STALL_MS = 15 * 60_000;
 /** One tool may run this long; past it the reply is wedged, not busy. */
@@ -14,3 +17,20 @@ export function replyStalled({ now, progressAt, runningTools }) {
         ? now - Math.min(...runningTools) >= TOOL_STALL_MS
         : now - progressAt >= REPLY_STALL_MS;
 }
+/** The tools that block a reply until its children settle. */
+export const CHILD_WAIT_TOOLS = new Set(['wait_subagents', 'spawn_subagent']);
+/** How long a child may stay unsettled after it was told to stop before its parent's own watch resumes. */
+export const CHILD_STOP_GRACE_MS = 5 * 60_000;
+/** Whether a child has gone quiet for the same windows as a reply, and was not yet told to stop. */
+export function childStalled(now, child) {
+    return child.stopRequestedAt === null && replyStalled({ now, progressAt: child.progressAt, runningTools: child.runningTools });
+}
+/**
+ * Whether the parent's own watch is paused: it is only waiting for children, and at least one still
+ * answers to its own watch. A child that ignored the stop for the grace period hands the clock back.
+ */
+export function waitingOnChildren(now, runningToolNames, children) {
+    if (!runningToolNames.length || !runningToolNames.every((name) => CHILD_WAIT_TOOLS.has(name)))
+        return false;
+    return children.some((child) => child.stopRequestedAt === null || now - child.stopRequestedAt < CHILD_STOP_GRACE_MS);
+}

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

@@ -28,6 +28,8 @@ export interface TerminalSubagentRun {
 export type TerminalSubagentUsage = Partial<Pick<UsagePayload, 'provider' | 'model' | 'inputTokens' | 'outputTokens' | 'cacheReadTokens' | 'cacheWriteTokens' | 'reasoningTokens' | 'costUsd' | 'costSource' | 'requests' | 'contextTokens' | 'contextWindow'>>;
 export interface TerminalSubagentActivity extends TerminalSubagentRun {
     activity: string;
+    /** When the run last did anything but heartbeat; how long it has been quiet is what a stall is. */
+    lastEventAt?: string;
     /** Cumulative run usage only; provider reasoning summaries and request details stay private. */
     usage: TerminalSubagentUsage | null;
     /** How far the child's own todo is: counts only, never the items. */

package/dist/sdk/terminal/subagentMonitor.js

@@ -1,4 +1,5 @@
 import { usagePayloadSchema } from "../sessions/contracts.js";
+import { toolDisplayName } from "./toolName.js";
 /** The main agent's row: the parent run itself, shown by name rather than by a profile. */
 export const MAIN_PROFILE = { name: 'main', color: 'main' };
 export const ACTIVE_SUBAGENT_STATUSES = new Set(['queued', 'running', 'waiting_for_approval', 'waiting_for_input']);
@@ -92,12 +93,14 @@ export class SubagentMonitor {
         row.startedAt = run.startedAt;
         row.endedAt = run.endedAt;
         const payload = event ? payloadOf(event) : {};
+        if (event && event.type !== 'heartbeat')
+            row.lastEventAt = event.timestamp;
         if (!event) {
             // A seeded row keeps what it already folded.
         }
         else if (event.type === 'tool.started') {
             const toolCallId = stringOf(payload.toolCallId);
-            const name = stringOf(payload.name) ?? 'Tool';
+            const name = toolDisplayName(stringOf(payload.name) ?? '') || 'Tool';
             if (toolCallId)
                 row.tools.set(toolCallId, { sequence: event.sequence, text: name });
         }

package/dist/sdk/terminal/terminals.js

@@ -1259,15 +1259,46 @@ export class Terminals {
                             const world = this.options.world;
                             if (!world)
                                 throw invalid('Browser settings are unavailable in this host.');
-                            return { allowPrivate: world.browserConfig().allowPrivate };
+                            const config = world.browserConfig();
+                            return { backend: config.backend, allowPrivate: config.allowPrivate };
                         }
                         if (call === 'terminal.browser.configure') {
                             const world = this.options.world;
                             if (!world)
                                 throw invalid('Browser settings are unavailable in this host.');
-                            if (typeof params.allowPrivate !== 'boolean')
-                                throw invalid('allowPrivate must be a boolean.');
-                            return { allowPrivate: world.configureBrowser({ allowPrivate: params.allowPrivate }).allowPrivate };
+                            const change = {};
+                            if ('allowPrivate' in params) {
+                                if (typeof params.allowPrivate !== 'boolean')
+                                    throw invalid('allowPrivate must be a boolean.');
+                                change.allowPrivate = params.allowPrivate;
+                            }
+                            if ('backend' in params) {
+                                if (params.backend !== 'isolated' && params.backend !== 'brave')
+                                    throw invalid('backend must be isolated or brave.');
+                                change.backend = params.backend;
+                            }
+                            if (!Object.keys(change).length)
+                                throw invalid('Set a browser backend or allowPrivate value.');
+                            const config = await world.configureBrowser(change);
+                            return { backend: config.backend, allowPrivate: config.allowPrivate };
+                        }
+                        if (call === 'terminal.browser.extension.status') {
+                            const world = this.options.world;
+                            if (!world)
+                                throw invalid('Browser settings are unavailable in this host.');
+                            return world.browserExtensionStatus();
+                        }
+                        if (call === 'terminal.browser.extension.start') {
+                            const world = this.options.world;
+                            if (!world)
+                                throw invalid('Browser settings are unavailable in this host.');
+                            return world.browserExtensionStart();
+                        }
+                        if (call === 'terminal.browser.extension.stop') {
+                            const world = this.options.world;
+                            if (!world)
+                                throw invalid('Browser settings are unavailable in this host.');
+                            return world.browserExtensionStop();
                         }
                         if (call === 'terminal.browser.snapshot')
                             return browser.snapshot(params.refresh === true);

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

@@ -0,0 +1,6 @@
+/**
+ * A tool or message id as a person reads it: `todo_write` becomes `TodoWrite`,
+ * `computer-screenshot` becomes `ComputerScreenshot`. Only the first letter of each part is
+ * raised, so a name that already carries capitals keeps them.
+ */
+export declare function toolDisplayName(name: string): string;

package/dist/sdk/terminal/toolName.js

@@ -0,0 +1,12 @@
+/**
+ * A tool or message id as a person reads it: `todo_write` becomes `TodoWrite`,
+ * `computer-screenshot` becomes `ComputerScreenshot`. Only the first letter of each part is
+ * raised, so a name that already carries capitals keeps them.
+ */
+export function toolDisplayName(name) {
+    return name
+        .split(/[^A-Za-z0-9]+/u)
+        .filter(part => part !== '')
+        .map(part => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join('');
+}

package/dist/sdk/terminal/tui/commandPages.d.ts

@@ -2,7 +2,7 @@ import type { TerminalPage } from "./page.js";
 import type { TerminalCommandHost } from "./commands.js";
 import { type AnnotateStart } from "./pages/annotatePage.js";
 import { type ContextTab } from "./pages/contextPage.js";
-export type CommandPageId = 'doctor' | 'accounts' | 'permissions' | 'plugins' | 'hub' | 'components' | 'settings' | 'trajectory' | 'log' | 'harness' | 'skills' | 'connections' | 'tools' | 'worktree' | 'notes' | 'annotate' | 'subagents' | 'agents' | 'usage' | 'context' | 'remote-control';
+export type CommandPageId = 'doctor' | 'accounts' | 'permissions' | 'plugins' | 'hub' | 'components' | 'settings' | 'trajectory' | 'log' | 'harness' | 'skills' | 'connections' | 'tools' | 'worktree' | 'notes' | 'annotate' | 'subagents' | 'agents' | 'usage' | 'context' | 'remote-control' | 'follow-up';
 /** Construct one independent full-screen page for a slash command. */
 export declare function createCommandPage(host: TerminalCommandHost, id: CommandPageId, options?: {
     runId?: string;

package/dist/sdk/terminal/tui/commandPages.js

@@ -14,12 +14,15 @@ import { AgentsPage } from "./pages/agentsPage.js";
 import { UsagePage } from "./pages/usagePage.js";
 import { ContextPage } from "./pages/contextPage.js";
 import { RemoteControlPage } from "./pages/remoteControlPage.js";
+import { FollowUpQueuePage } from "./pages/followUpQueuePage.js";
 import { createSettingsModel } from "./settingsModel.js";
 /** Construct one independent full-screen page for a slash command. */
 export function createCommandPage(host, id, options = {}) {
     const theme = () => host.ui.theme;
     const notify = (message, type) => host.ui.notify(message, type === 'error' || type === 'warning' ? type : 'info');
     switch (id) {
+        case 'follow-up':
+            return new FollowUpQueuePage({ editor: host.followUpQueue(), theme, changed: host.changed, close: options.close ?? (() => { }) });
         case 'remote-control':
             return new RemoteControlPage({ theme, call: host.control, changed: host.changed, copy: host.copyText, notify });
         case 'context':

package/dist/sdk/terminal/tui/commands.d.ts

@@ -7,8 +7,22 @@ import type { TerminalSubagentActivity } from "../subagentMonitor.js";
 import { type TerminalCommandCompletion, type TerminalCommandHelpGroup } from "../commandHelp.js";
 export type { TerminalCommandCompletion } from "../commandHelp.js";
 export { parseAnnotate } from "./pluginCommands.js";
+export type FollowUpQueueEntry = {
+    id: string;
+    kind: 'steering' | 'followUp';
+    text: string;
+    hasImages: boolean;
+};
+export type FollowUpQueueEditor = {
+    entries(): readonly FollowUpQueueEntry[];
+    edit(id: string): Promise<void>;
+    sendNext(): Promise<void>;
+    remove(id: string): void;
+    close(): void;
+};
 export interface TerminalCommandHost {
     session(): AgentSession;
+    followUpQueue(): FollowUpQueueEditor;
     /** Navigation is scope checked by the Harness runtime adapter. */
     runtime(): Pick<TerminalRuntime, 'newSession' | 'switchSession' | 'fork' | 'importFromJsonl' | 'reload' | 'navigateTree' | 'installationDeviceId' | 'permissions' | 'setFullPermission' | 'setGlobalTool' | 'snapshot' | 'interrupt'>;
     /** The protected `accounts.*`, `plugins.*` and `hub.*` calls of this session, made with its control key. */

package/dist/sdk/terminal/tui/commands.js

@@ -356,13 +356,16 @@ export function createTerminalCommands(host) {
                 case 'worktree':
                     await openPage('worktree');
                     break;
+                case 'follow-up':
+                    await openPage('follow-up');
+                    break;
                 case 'trajectory':
                     await openPage('trajectory', { runId: argument });
                     break;
                 case 'todo': {
                     const items = await host.todo();
                     if (!items.length)
-                        notify('No todo list in this reply yet. The agent writes one with todo_write for multi-step work.');
+                        notify('No todo list in this reply yet. The agent writes one with TodoWrite for multi-step work.');
                     else
                         host.showTodo(items);
                     break;

package/dist/sdk/terminal/tui/pages/followUpQueuePage.d.ts

@@ -0,0 +1,34 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TabInfo } from "../chrome.js";
+import type { FollowUpQueueEditor } from "../commands.js";
+import type { TerminalMouseInput } from "../mouse.js";
+import type { TerminalPage } from "../page.js";
+export declare class FollowUpQueuePage implements TerminalPage {
+    private readonly options;
+    presentation: "centered";
+    private selected;
+    private disposed;
+    private closed;
+    constructor(options: {
+        editor: FollowUpQueueEditor;
+        theme(): Theme;
+        changed(): void;
+        close(): void;
+    });
+    get focused(): boolean;
+    set focused(_value: boolean);
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    activate(): void;
+    dispose(): void;
+    private closeEditor;
+    private entries;
+    render(_width: number, _rows: number): string[];
+    private act;
+    handleInput(data: string): boolean;
+    handleMouse(event: TerminalMouseInput): {
+        handled: boolean;
+        render: boolean;
+    } | undefined;
+}