@xingular/harness 1.2.0 → 1.3.1-unstable.0

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

@@ -21,24 +21,26 @@ function mark(status, frame) {
         case 'running': return { mark: frame, tone: 'warning' };
     }
 }
-export function subagentTasks(checklist) {
-    return checklist && checklist.total > 0 ? `${checklist.done} of ${checklist.total} tasks` : null;
+export function subagentTasks(todo) {
+    return todo && todo.total > 0 ? `${todo.done} of ${todo.total} tasks` : null;
 }
 /**
  * The compact live roster shown under the status line: active children first, at most three
  * rows. The session name is cut first when the terminal is narrow.
  */
 export function subagentRoster(items, width, frame = getWorkingSpinnerFrames()[0] ?? '') {
-    if (!items.length || width < 1)
+    // The status line already describes the main agent; its row is only on the /subagents page.
+    const children = items.filter(item => item.relation !== 'main');
+    if (!children.length || width < 1)
         return null;
-    const ordered = [...items].sort((left, right) => {
+    const ordered = [...children].sort((left, right) => {
         const active = Number(ACTIVE_SUBAGENT_STATUSES.has(right.status)) - Number(ACTIVE_SUBAGENT_STATUSES.has(left.status));
         return active || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id);
     });
     const rows = ordered.slice(0, MAX_VISIBLE_ROWS).map((item) => {
         const status = mark(item.status, frame);
         const profile = cut(safe(item.profile?.name ?? '') || 'subagent', Math.max(1, Math.min(24, width - 2)));
-        const tasks = subagentTasks(item.checklist);
+        const tasks = subagentTasks(item.todo);
         const used = 2 + visibleWidth(profile) + GAP.length + (tasks ? GAP.length + tasks.length : 0);
         const title = cut(safe(item.title) || 'Subagent', Math.max(1, width - used));
         return { id: item.id, mark: status.mark, tone: status.tone, profile, color: item.profile?.color ?? null, title, tasks };

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

@@ -37,6 +37,7 @@ export function profileColor(theme, name) {
         case 'cyan': return theme.cyan;
         case 'orange': return theme.primary;
         case 'purple': return theme.purple;
+        case 'main': return theme.primary;
         default: return theme.accent;
     }
 }

package/dist/sdk/terminal/piExtension.js

@@ -2,15 +2,15 @@
 // session does to the harness, asks before each tool call, takes instructions the harness
 // queues for it, and gives the session the harness's own tools. It runs in the `pi` process,
 // so everything it knows about the harness comes through the session socket.
-import { createBashTool, createEditTool, createWriteTool } from '@earendil-works/pi-coding-agent';
+import { createBashTool, createEditTool, createPowerShellTool, createWriteTool } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { connectionFromEnv, socketCall, terminalCall } from "./client.js";
 import { controlCall } from "./control.js";
 import { SPAWN_SUBAGENT, SUBAGENT_OWNER, SUBAGENT_RECEIPT, SUBAGENT_RESULTS, subagentHistory } from "../sessions/subagents.js";
 import { PLAN_RESEARCH_TOOLS } from "../agents/planResearch.js";
 import { askUserTool } from "../tools/askUser.js";
-import { checklistTool } from "../tools/checklist.js";
-import { checkpointTool } from "../tools/checkpoint.js";
+import { todoTool } from "../tools/todo.js";
+import { CHECKPOINT_WRITE, checkpointTool } from "../tools/checkpoint.js";
 import { createSliceState, parseWorkSlice, workSliceGuard } from "../sessions/workSlice.js";
 import { DEFAULT_COMMAND_TIMEOUT_SECONDS, withCommandBudget } from "../core/commandBudget.js";
 import { sessionNameTool } from "../tools/sessionName.js";
@@ -20,7 +20,7 @@ import { compactionCheckpoint } from "../sessions/compactionCheckpoint.js";
 import { pruneToolImages } from "../world/images.js";
 import { parseInitialBashCommand } from "../sessions/initialBash.js";
 import { inspectWorkspaceWrite } from "../sessions/workspaceBoundary.js";
-import { withWorkspaceWriteScope } from "../core/workspaceBashTool.js";
+import { createWorkspaceShellTool } from "../core/workspaceBashTool.js";
 import { createWorkspaceBashOperations, runWithWorkspaceWriteScope } from "../core/workspaceSandbox.js";
 import { withWorkspaceWriteAuthorization, workspaceEditOperations, workspaceWriteOperations } from "../core/workspaceWriteOperations.js";
 import { BUDGET_GUARD, OUTPUT_TRIM, budgetGuard, outputTrim } from "../plugins/firstParty.js";
@@ -48,6 +48,7 @@ export default async function (pi, planRun, getSession) {
     let context = null;
     let nativeSubagents = false;
     let subagentParent = false;
+    let stoppedChildren = null;
     let timer = null;
     let polling = false;
     let failure;
@@ -135,7 +136,7 @@ export default async function (pi, planRun, getSession) {
         },
         workspaceWriteScope: () => planRun?.active ? 'read-only' : undefined
     });
-    pi.registerTool(withWorkspaceWriteScope(createBashTool(process.cwd(), { operations: workspaceBash })));
+    pi.registerTool(createWorkspaceShellTool({ createBashTool, createPowerShellTool }, process.cwd(), workspaceBash));
     pi.registerTool(withWorkspaceWriteAuthorization(createWriteTool(process.cwd(), { operations: workspaceWriteOperations }), writeAuthorizations));
     pi.registerTool(withWorkspaceWriteAuthorization(createEditTool(process.cwd(), { operations: workspaceEditOperations }), writeAuthorizations));
     compactionCheckpoint({ planInstructions: () => planRun?.active ? PLAN_INSTRUCTIONS : null })(pi);
@@ -145,7 +146,7 @@ export default async function (pi, planRun, getSession) {
     const sliceState = createSliceState(slicePolicy);
     // `XINGULAR_WORK_SLICE=off` at launch leaves terminal replies unbounded, as before PROP-0041.
     if (slicePolicy.enabled)
-        workSliceGuard({ policy: slicePolicy, state: sliceState })(pi);
+        workSliceGuard({ policy: slicePolicy, state: sliceState, checkpointAvailable: () => !planRun?.active || planRun.allowedTools.has(CHECKPOINT_WRITE) })(pi);
     // Only the latest screenshots stay in what the model sees (world/images.ts).
     pi.on('context', (event) => {
         const messages = pruneToolImages(event.messages);
@@ -155,7 +156,8 @@ export default async function (pi, planRun, getSession) {
         context = ctx;
         if (timer)
             clearInterval(timer);
-        await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile() });
+        // The branch's parent runs let the controller show the latest one's rows again on reopen.
+        await terminalCall('ready', { nativeSessionId: ctx.sessionManager.getSessionFile(), owners: subagentHistory(ctx.sessionManager.getBranch?.() ?? []).owners });
         timer = setInterval(() => {
             if (polling || !context)
                 return;
@@ -188,15 +190,20 @@ export default async function (pi, planRun, getSession) {
         reasoningTokens = undefined;
         costReported = false;
         // A run a plugin starts with a custom message has no user prompt to record; it still begins a turn.
-        const begun = await terminalCall('begin', { text: event.messageType === 'user' ? event.prompt : '' });
+        const begun = await terminalCall('begin', { text: event.messageType === 'user' ? event.prompt : '', model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel?.() ?? null });
         workspaceRoot = typeof begun.workspaceRoot === 'string' ? begun.workspaceRoot : null;
         if (!workspaceRoot)
             throw new Error('The active project workspace could not be resolved; the turn was not started.');
+        // Every turn marks its run on the branch, so a reopened conversation finds its latest one.
+        pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
+        stoppedChildren = null;
         if (nativeSubagents) {
-            pi.appendEntry(SUBAGENT_OWNER, { runId: begun.runId });
             const snapshot = await controlCall('terminal.subagents.register', { tools: pi.getActiveTools(), model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : null, effort: pi.getThinkingLevel(), plan: planRun?.active === true, history: subagentHistory(ctx.sessionManager.getBranch()) });
             if (planRun && Array.isArray(snapshot.connectors))
                 planRun.connectors = snapshot.connectors;
+            if (planRun && snapshot.subagentProfiles)
+                planRun.subagentProfiles = snapshot.subagentProfiles;
+            stoppedChildren = snapshot.notice ?? null;
             subagentParent = true;
         }
         if (planRun && event.messageType === 'user') {
@@ -260,6 +267,13 @@ export default async function (pi, planRun, getSession) {
             : 'The user’s initial Bash command has already run. Read its native Bash result and explain what it shows. Do not run the same command again unless the user explicitly asks.';
         return { message: { customType: 'xingular-initial-bash', content: instruction, display: false, details: {} } };
     });
+    // A second handler, so the notice joins any initial-Bash message rather than replacing it.
+    pi.on('before_agent_start', async () => {
+        const notice = stoppedChildren;
+        stoppedChildren = null;
+        if (notice)
+            return { message: { customType: SUBAGENT_RESULTS, content: notice.text, display: false, details: { [SUBAGENT_RECEIPT]: notice.receipt } } };
+    });
     const deliverChildren = async (event, ctx, settle) => {
         if (!nativeSubagents || (settle && event.outcome !== 'completed') || ctx.signal?.aborted)
             return;
@@ -437,15 +451,15 @@ export default async function (pi, planRun, getSession) {
             return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined };
         }
     });
-    // The checklist is recorded on the harness run; the shared tool validates and the socket carries the event.
+    // The todo list is recorded on the harness run; the shared tool validates and the socket carries the event.
     let recorded = Promise.resolve();
-    const checklist = checklistTool({ emit: (_type, payload) => { recorded = terminalCall('checklist', payload); } });
+    const todo = todoTool({ emit: (_type, payload) => { recorded = terminalCall('todo', payload); } });
     pi.registerTool({
-        name: checklist.name, label: checklist.label, description: checklist.description,
-        parameters: Type.Unsafe(checklist.parameters(Type)),
+        name: todo.name, label: todo.label, description: todo.description,
+        parameters: Type.Unsafe(todo.parameters(Type)),
         async execute(_id, input) {
             recorded = Promise.resolve();
-            const result = await checklist.execute(input);
+            const result = await todo.execute(input);
             await recorded;
             return { content: [{ type: 'text', text: typeof result === 'string' ? result : result.text }], details: undefined };
         }

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

@@ -5,10 +5,13 @@ export interface TerminalSubagentProfile {
     name: string;
     color: string;
 }
+/** The main agent's row: the parent run itself, shown by name rather than by a profile. */
+export declare const MAIN_PROFILE: TerminalSubagentProfile;
 export interface TerminalSubagentRun {
     id: string;
     parentRunId: string | null;
-    relation: 'subagent';
+    /** `main` is the parent run itself; every other row is a child or nested child. */
+    relation: 'main' | 'subagent';
     /** The short name the parent gave the child (PROP-0030). */
     title: string;
     goal: string | null;
@@ -27,8 +30,8 @@ export interface TerminalSubagentActivity extends TerminalSubagentRun {
     activity: string;
     /** Cumulative run usage only; provider reasoning summaries and request details stay private. */
     usage: TerminalSubagentUsage | null;
-    /** How far the child's own checklist is: counts only, never the items. */
-    checklist: {
+    /** How far the child's own todo is: counts only, never the items. */
+    todo: {
         done: number;
         total: number;
     } | null;
@@ -41,7 +44,17 @@ export declare class SubagentMonitor {
     private parentRunId;
     private readonly activities;
     begin(parentRunId: string): void;
-    observe(parentRunId: string, run: TerminalSubagentRun, event: RunEvent): void;
+    /** Folds one event of the tracked parent (`main`) or one of its descendants; `null` seeds the row. */
+    observe(parentRunId: string, run: TerminalSubagentRun, event: RunEvent | null): void;
+    /**
+     * Rebuilds the rows of a parent run that is no longer live, such as the latest one of a reopened
+     * conversation, by folding each run's saved events. Rows keep their final status.
+     */
+    restore(parentRunId: string, runs: readonly {
+        run: TerminalSubagentRun;
+        events: readonly RunEvent[];
+    }[]): void;
+    /** The main row first, then children in start order. */
     snapshot(parentRunId: string): TerminalSubagentActivity[];
     clear(parentRunId?: string): void;
 }

package/dist/sdk/terminal/subagentMonitor.js

@@ -1,4 +1,6 @@
 import { usagePayloadSchema } from "../sessions/contracts.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']);
 export function terminalSubagentDuration(activity, now = Date.now()) {
     const start = Date.parse(activity.startedAt);
@@ -50,8 +52,11 @@ export class SubagentMonitor {
         this.parentRunId = parentRunId;
         this.activities.clear();
     }
+    /** Folds one event of the tracked parent (`main`) or one of its descendants; `null` seeds the row. */
     observe(parentRunId, run, event) {
-        if (this.parentRunId !== parentRunId || run.relation !== 'subagent')
+        if (this.parentRunId !== parentRunId)
+            return;
+        if ((run.relation === 'main') !== (run.id === parentRunId))
             return;
         const row = this.activities.get(run.id) ?? {
             id: run.id,
@@ -63,7 +68,7 @@ export class SubagentMonitor {
             startedAt: run.startedAt,
             endedAt: run.endedAt,
             activity: statusActivity(run.status),
-            checklist: null,
+            todo: null,
             profile: run.profile ?? null,
             accountLabel: run.accountLabel ?? null,
             model: run.model ?? null,
@@ -86,8 +91,11 @@ export class SubagentMonitor {
         row.status = run.status;
         row.startedAt = run.startedAt;
         row.endedAt = run.endedAt;
-        const payload = payloadOf(event);
-        if (event.type === 'tool.started') {
+        const payload = event ? payloadOf(event) : {};
+        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';
             if (toolCallId)
@@ -125,22 +133,35 @@ export class SubagentMonitor {
                 };
             }
         }
-        else if (event.type === 'checklist.updated') {
+        else if (event.type === 'todo.updated' || event.type === 'checklist.updated') {
             const items = Array.isArray(payload.items) ? payload.items : [];
-            row.checklist = items.length ? { done: items.filter(item => item?.status === 'completed').length, total: items.length } : null;
+            row.todo = items.length ? { done: items.filter(item => item?.status === 'completed').length, total: items.length } : null;
         }
         if (run.status !== 'running')
             row.tools.clear();
         row.activity = run.status === 'running'
-            ? latestTool(row.tools) ?? row.lastTool?.text ?? (event.type === 'message.delta' ? 'Responding' : 'Working')
+            ? latestTool(row.tools) ?? row.lastTool?.text ?? (event?.type === 'message.delta' || (!event && row.activity === 'Responding') ? 'Responding' : 'Working')
             : statusActivity(run.status);
         this.activities.set(run.id, row);
     }
+    /**
+     * Rebuilds the rows of a parent run that is no longer live, such as the latest one of a reopened
+     * conversation, by folding each run's saved events. Rows keep their final status.
+     */
+    restore(parentRunId, runs) {
+        this.begin(parentRunId);
+        for (const { run, events } of runs) {
+            this.observe(parentRunId, run, null);
+            for (const event of events)
+                this.observe(parentRunId, run, event);
+        }
+    }
+    /** The main row first, then children in start order. */
     snapshot(parentRunId) {
         if (this.parentRunId !== parentRunId)
             return [];
         return [...this.activities.values()]
-            .sort((left, right) => left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
+            .sort((left, right) => Number(right.relation === 'main') - Number(left.relation === 'main') || left.startedAt.localeCompare(right.startedAt) || left.id.localeCompare(right.id))
             .map(({ tools: _tools, lastTool: _lastTool, ...activity }) => activity);
     }
     clear(parentRunId) {

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

@@ -150,6 +150,13 @@ export declare class Terminals {
     /** Each child's profile name and colour, looked up once per child run. */
     private readonly childProfiles;
     private subagentProfile;
+    /** Account, model and effort for a monitor row, from the run record. */
+    private monitorRuntime;
+    /**
+     * Shows the reopened conversation's latest parent run again: the last owner on its native branch
+     * that ran in this folder, with every descendant flat, as each ended.
+     */
+    private hydrateMonitor;
     constructor(options: TerminalsOptions);
     /** The commands a terminal session finds on PATH. Rewritten only when they change. */
     private ensureCommands;

package/dist/sdk/terminal/terminals.js

@@ -22,9 +22,9 @@ import * as componentLibrary from "../variant/components.js";
 import * as variantStore from "../variant/store.js";
 import { compile, copyToRun, record, render, saveForSession } from "../prompt/compile.js";
 import { isActiveStatus } from "../sessions/contracts.js";
-import { findRun, loadRun, saveRun, updateRun } from "../sessions/runStore.js";
+import { findRun, loadRun, readEvents, recordedSubagents, saveRun, updateRun } from "../sessions/runStore.js";
 import { combineWorkspaceScope, inspectRunWorkspaceWrite } from "../sessions/workspaceBoundary.js";
-import { CHECKLIST_WRITE } from "../tools/checklist.js";
+import { TODO_WRITE } from "../tools/todo.js";
 import { DEFAULT_TOOL_NAMES } from "../tools/definitions.js";
 import { harnessTools } from "../tools/harnessTools.js";
 import { HARNESS_PLUGINS } from "../plugins/builtin.js";
@@ -42,7 +42,7 @@ import { TerminalController } from "./controller.js";
 import { terminalCommandFiles } from "./launch.js";
 import { SessionSocket, socketPath } from "./socket.js";
 import { harnessLogInfo, readHarnessLogChunk } from "./logs.js";
-import { listTerminalTrajectoryRuns, readTerminalTrajectory } from "./trajectory.js";
+import { listTerminalTrajectoryRuns, readTerminalTrajectory, latestTerminalTodo } from "./trajectory.js";
 import { BrowserControl } from "./browserControl.js";
 /** Identity of the exact resource decision that this terminal was prepared with. */
 function resourceIdentity(loading) {
@@ -98,12 +98,61 @@ export class Terminals {
         }
         return this.childProfiles.get(record.id) ?? null;
     }
+    /** Account, model and effort for a monitor row, from the run record. */
+    monitorRuntime(live, record) {
+        let accountLabel = record.accountId === live.account.id ? live.account.label : null;
+        if (accountLabel === null && record.accountId) {
+            try {
+                accountLabel = this.options.accounts.find(record.accountId).label;
+            }
+            catch { }
+        }
+        return { accountLabel, model: record.model ?? null, effort: record.effort ?? null };
+    }
+    /**
+     * Shows the reopened conversation's latest parent run again: the last owner on its native branch
+     * that ran in this folder, with every descendant flat, as each ended.
+     */
+    hydrateMonitor(live, owners) {
+        const { root } = this.options.env;
+        const native = live.controller.nativeSessionId;
+        if (!native)
+            return;
+        for (const id of [...owners].reverse()) {
+            const record = findRun(root, id);
+            if (!record || record.relation || record.nativeSessionId !== native || record.workingDirectory !== live.input.cwd)
+                continue;
+            const children = [];
+            const seen = new Set([record.id]);
+            const visit = (parentId) => {
+                for (const childId of recordedSubagents(root, parentId)) {
+                    if (seen.has(childId))
+                        continue;
+                    seen.add(childId);
+                    const child = findRun(root, childId);
+                    if (child?.relation !== 'subagent')
+                        continue;
+                    children.push(child);
+                    visit(child.id);
+                }
+            };
+            visit(record.id);
+            const entry = (run, profile = null) => ({ record: run, events: readEvents(root, run.id), profile, runtime: this.monitorRuntime(live, run) });
+            live.controller.restoreMonitor(entry(record), children.map(child => entry(child, this.subagentProfile(child))));
+            return;
+        }
+    }
     constructor(options) {
         this.options = options;
         this.assets = options.assets ?? defaultAssets();
         options.runs.listen(event => {
-            this.sessions.get(event.sessionId)?.controller.observe(event);
+            const session = this.sessions.get(event.sessionId);
+            session?.controller.observe(event);
             const record = findRun(options.env.root, event.runId);
+            if (record && !record.relation && session) {
+                session.controller.observeMain(record, event, this.monitorRuntime(session, record));
+                return;
+            }
             if (record?.relation !== 'subagent')
                 return;
             let parentId = record.parentRunId;
@@ -119,8 +168,8 @@ export class Terminals {
                     const settings = options.subagents?.runtimeSettings(record.id);
                     owner.controller.observeSubagent(parent.id, record, event, this.subagentProfile(record), {
                         accountLabel: owner.account.label,
-                        model: settings?.model ?? null,
-                        effort: settings?.effort ?? null
+                        model: settings?.model ?? record.model ?? null,
+                        effort: settings?.effort ?? record.effort ?? null
                     });
                     break;
                 }
@@ -690,7 +739,7 @@ export class Terminals {
         };
     }
     /** The run a native turn reports into: the one reserved by `send`, or a new one for what the person typed. */
-    begin(live, reservedRunId, text) {
+    begin(live, reservedRunId, text, launch = {}) {
         const { root } = this.options.env;
         const { sessionId } = live.input;
         if (this.options.runs.activeForSession(sessionId))
@@ -706,6 +755,14 @@ export class Terminals {
             saveRun(root, this.runRecord(live, runId, text || null));
             copyToRun(root, live.input.sessionFolder, runId);
         }
+        if (launch.model || launch.effort) {
+            updateRun(root, runId, (record) => {
+                if (launch.model)
+                    record.model = launch.model;
+                if (launch.effort)
+                    record.effort = launch.effort;
+            });
+        }
         return this.options.runs.start(sessionId, runId);
     }
     async decide(live, run, tool, args) {
@@ -747,7 +804,7 @@ export class Terminals {
         }
         if (inspection.outside)
             return { allowed: false, requiresApproval: true, rememberable: false, standing: 'switch', reason: inspection.reason, workspaceRoot };
-        if (name === SESSION_NAME || name === CHECKLIST_WRITE || name === SPAWN_SUBAGENT || name === WAIT_SUBAGENTS || READ_ONLY_TOOLS.has(name) || this.worldReadOnly.has(name) || this.options.apps.toolNames.includes(name) || ['bash', 'edit', 'write'].includes(name)) {
+        if (name === SESSION_NAME || name === TODO_WRITE || name === SPAWN_SUBAGENT || name === WAIT_SUBAGENTS || READ_ONLY_TOOLS.has(name) || this.worldReadOnly.has(name) || this.options.apps.toolNames.includes(name) || ['bash', 'edit', 'write'].includes(name)) {
             return { allowed: true, workspaceRoot };
         }
         return { allowed: false, requiresApproval: true, rememberable: true, reason: 'This native action requires approval.', workspaceRoot };
@@ -850,13 +907,22 @@ export class Terminals {
             if (params.plan !== undefined && typeof params.plan !== 'boolean')
                 throw invalid('plan must be a boolean.');
             const readOnly = live.input.readOnly === true;
-            const readTools = new Set([...READ_ONLY_TOOLS, SESSION_NAME, CHECKLIST_WRITE, SPAWN_SUBAGENT, WAIT_SUBAGENTS, 'ask_user', 'mcp_list_tools', 'mcp_call_tool', 'history_search', 'history_read', 'wiki_search', 'wiki_read', 'wiki_list', 'memory_facts', 'skill_load']);
+            const readTools = new Set([...READ_ONLY_TOOLS, SESSION_NAME, TODO_WRITE, SPAWN_SUBAGENT, WAIT_SUBAGENTS, 'ask_user', 'mcp_list_tools', 'mcp_call_tool', 'history_search', 'history_read', 'wiki_search', 'wiki_read', 'wiki_list', 'memory_facts', 'skill_load']);
             const tools = [...new Set(params.tools)].filter(name => (!readOnly || readTools.has(name)) && (params.plan === true || (name !== 'ask_user' && name !== 'ask_user_question')));
             const caller = { ...live.caller, runId: run.runId };
             const capabilities = this.options.resolveCapabilities ? await this.options.resolveCapabilities(caller, tools, live.input.cwd) : { version: 1, tools, connectors: [], contributions: [] };
+            const variantDir = this.variantDirs.get(live.input.sessionId) ?? null;
+            const subagentProfiles = {
+                normal: profileSection(this.options.env.root, live.input.cwd, variantDir).body,
+                plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true, {
+                    frozenTools: capabilities.tools,
+                    contributions: capabilities.contributions,
+                    descriptors: HARNESS_PLUGINS
+                }).body
+            };
             freezeRun(this.options.env.root, run.runId, caller, capabilities);
             if (!service || live.input.subagents === null)
-                return { runId: run.runId, connectors: capabilities.connectors };
+                return { runId: run.runId, connectors: capabilities.connectors, subagentProfiles };
             service.register({
                 run: { id: run.runId, sessionId: live.input.sessionId, mode: live.input.run?.mode ?? 'code', projectId: live.input.projectId, worktreeId: live.input.run?.worktreeId },
                 cwd: live.input.cwd, sessionDir: this.historyDir(live.input), text: '', caller: live.caller,
@@ -868,8 +934,11 @@ export class Terminals {
                 variant: live.variant ? { dir: live.variant.dir, scope: live.variant.scope } : null,
                 capabilities
             }, live.account.id, capabilities);
-            service.restore(run.runId, params.history ?? { owners: [], receipts: [] });
-            return { runId: run.runId, connectors: capabilities.connectors };
+            const history = params.history ?? { owners: [], receipts: [] };
+            service.restore(run.runId, history);
+            // Children an earlier reply left stopped, reported before the model answers.
+            const notice = await service.delivery(run.runId, history, false);
+            return { runId: run.runId, connectors: capabilities.connectors, subagentProfiles, notice };
         }
         if (call === 'terminal.subagents.verify') {
             await service.verify(run.runId, params.history);
@@ -1030,7 +1099,7 @@ export class Terminals {
                 this.variantDirs.set(sessionId, variant.dir);
             const worldTools = await this.worldToolNames(input, preparedAccount);
             const ownTools = await this.ownToolNames(input, preparedAccount);
-            const launchTools = [...new Set([...(input.launch?.tools ?? []), CHECKLIST_WRITE, SESSION_NAME, ...ownTools, ...(broker ? apps.toolNames : []), ...worldTools])];
+            const launchTools = [...new Set([...(input.launch?.tools ?? []), TODO_WRITE, SESSION_NAME, ...ownTools, ...(broker ? apps.toolNames : []), ...worldTools])];
             // The profiles replace the variant's own subagent list, which they include.
             const profiles = this.options.subagents && input.subagents !== null ? profileSection(root, input.cwd, variant?.dir ?? null) : null;
             const launchSections = profiles ? [...(input.launch?.sections ?? []).filter((section) => section.id !== profiles.id), profiles] : input.launch?.sections;
@@ -1050,7 +1119,8 @@ export class Terminals {
                 controller: new TerminalController({
                     sessionId,
                     nativeSessionId: input.nativeSessionId ?? null,
-                    begin: ({ reservedRunId, text }) => this.begin(live, reservedRunId, text),
+                    begin: ({ reservedRunId, text, model, effort }) => this.begin(live, reservedRunId, text, { model, effort }),
+                    hydrate: (owners) => this.hydrateMonitor(live, owners),
                     policy: (run, tool, args) => this.decide(live, run, tool, args),
                     workspaceRoot: run => {
                         const record = loadRun(this.options.env.root, run.runId);
@@ -1168,6 +1238,8 @@ export class Terminals {
                             return this.componentsCall(live, call, params);
                         if (call.startsWith('terminal.trajectory.'))
                             return this.trajectoryCall(live, call, params);
+                        if (call === 'terminal.todo')
+                            return latestTerminalTodo(this.options.env.root, live.input.sessionId, live.controller.nativeSessionId);
                         if (call === 'terminal.permissions.get') {
                             const policy = this.options.approvals.read();
                             return { full: this.options.approvals.isAuto('pi'), globalTools: policy.globalTools.pi ?? [] };

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

@@ -1,4 +1,4 @@
-import type { RunEvent, RunRecord } from "../sessions/contracts.js";
+import type { RunEvent, RunRecord, TodoItem } from "../sessions/contracts.js";
 export type TerminalTrajectoryRun = Pick<RunRecord, 'id' | 'mode' | 'goal' | 'startedAt' | 'endedAt' | 'status'>;
 export interface TerminalTrajectorySnapshot {
     run: TerminalTrajectoryRun;
@@ -6,5 +6,10 @@ export interface TerminalTrajectorySnapshot {
 }
 /** The native conversation file is the terminal's boundary for this read-only view. */
 export declare function listTerminalTrajectoryRuns(root: string, sessionId: string, nativeSessionId: string | null): TerminalTrajectoryRun[];
+/** The todo of the latest reply in this native conversation, for a host's /todo view. */
+export declare function latestTerminalTodo(root: string, sessionId: string, nativeSessionId: string | null): {
+    runId: string;
+    todo: TodoItem[];
+};
 /** Read a run only when it belongs to both this terminal and its current native conversation. */
 export declare function readTerminalTrajectory(root: string, sessionId: string, nativeSessionId: string | null, runId: string, afterSequence?: number): TerminalTrajectorySnapshot;

package/dist/sdk/terminal/trajectory.js

@@ -1,5 +1,6 @@
 import { notFound } from "../core/errors.js";
 import { findRun, listRuns, readEvents } from "../sessions/runStore.js";
+import { todoOf } from "../tools/todo.js";
 function summary(run) {
     return {
         id: run.id,
@@ -18,6 +19,13 @@ export function listTerminalTrajectoryRuns(root, sessionId, nativeSessionId) {
         .filter(run => run.nativeSessionId === nativeSessionId || run.trigger === 'side-question' && run.sessionId === sessionId)
         .map(summary);
 }
+/** The todo of the latest reply in this native conversation, for a host's /todo view. */
+export function latestTerminalTodo(root, sessionId, nativeSessionId) {
+    if (!nativeSessionId)
+        return { runId: '', todo: [] };
+    const run = listRuns(root, { sessionId }).find(candidate => candidate.nativeSessionId === nativeSessionId && candidate.trigger !== 'side-question');
+    return run ? { runId: run.id, todo: todoOf(readEvents(root, run.id)) } : { runId: '', todo: [] };
+}
 /** Read a run only when it belongs to both this terminal and its current native conversation. */
 export function readTerminalTrajectory(root, sessionId, nativeSessionId, runId, afterSequence) {
     if (!nativeSessionId || !Number.isSafeInteger(afterSequence ?? 0) || (afterSequence ?? 0) < 0)

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

@@ -62,3 +62,7 @@ export declare function pageFrame({ title, meta, body, footer, width, rows, them
     rows: number;
     headerLine?: string;
 }): string[];
+/** A full-width two-pane list uses a 40/60 split once there is room to read both panes. */
+export declare function inspectorListWidth(width: number): number | undefined;
+/** Joins a list and passive detail pane without drawing a box around either. */
+export declare function splitColumns(left: readonly string[], right: readonly string[], leftWidth: number, width: number, rows: number, theme: Theme): string[];

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

@@ -167,3 +167,16 @@ export function pageFrame({ title, meta, body, footer, width, rows, theme, heade
         footerRow(footer, width, theme)
     ].slice(0, rows);
 }
+/** A full-width two-pane list uses a 40/60 split once there is room to read both panes. */
+export function inspectorListWidth(width) {
+    return width < 88 ? undefined : Math.max(32, Math.floor((width - 3) * 0.4));
+}
+/** Joins a list and passive detail pane without drawing a box around either. */
+export function splitColumns(left, right, leftWidth, width, rows, theme) {
+    const rightWidth = Math.max(0, width - leftWidth - 3);
+    return Array.from({ length: Math.max(0, Math.trunc(rows)) }, (_, index) => {
+        const leftLine = truncateToWidth(left[index] ?? '', leftWidth, '');
+        const rightLine = truncateToWidth(right[index] ?? '', rightWidth, '');
+        return leftLine + ' '.repeat(Math.max(0, leftWidth - visibleWidth(leftLine))) + theme.fg('dim', ' │ ') + rightLine;
+    });
+}

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

@@ -1,6 +1,8 @@
 import { DoctorPage } from "./pages/doctorPage.js";
 import { AccountsPage } from "./pages/accountsPage.js";
 import { BrowserPage } from "./pages/browserPage.js";
+import { PluginsPage } from "./pages/pluginsPage.js";
+import { HubPage } from "./pages/hubPage.js";
 import { LogPage, formatRunEventLog } from "./pages/logPage.js";
 import { PermissionsPage } from "./pages/permissionsPage.js";
 import { SettingsPage } from "./pages/settingsPage.js";
@@ -40,17 +42,25 @@ export function createCommandPage(host, id, options = {}) {
                 activeTools: () => host.session().getActiveToolNames(),
                 confirm: (title, message) => host.ui.confirm(title, message), notify, changed: host.changed
             });
+        case 'plugins':
+            return new PluginsPage({
+                theme, call: host.control, changed: host.changed,
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify, input: host.ui.input.bind(host.ui) }
+            });
+        case 'hub':
+            return new HubPage({
+                theme, call: host.control, changed: host.changed,
+                ui: { select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify }
+            });
         case 'harness':
         case 'skills':
         case 'connections':
         case 'tools':
-        case 'plugins':
-        case 'hub':
         case 'components':
             return new BrowserPage({
                 theme, call: host.control, changed: host.changed,
-                section: id === 'harness' || id === 'hub' ? 'overview' : id === 'components' ? 'library' : id,
-                source: id === 'hub' ? 'discover' : 'installed',
+                section: id === 'harness' ? 'overview' : id === 'components' ? 'library' : id,
+                source: 'installed',
                 ui: {
                     select: host.ui.select.bind(host.ui), confirm: host.ui.confirm.bind(host.ui), notify: host.ui.notify.bind(host.ui), input: host.ui.input.bind(host.ui),
                     secretInput: (title, placeholder) => {

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

@@ -2,6 +2,7 @@ import { type AgentSession, type ExtensionUIContext } from '@earendil-works/pi-c
 import { type SkillEntry } from "./skillInvocation.js";
 import type { TerminalRuntime } from "./runtime.js";
 import type { TerminalTrajectoryRun, TerminalTrajectorySnapshot } from "../trajectory.js";
+import type { TodoEntry } from "../opentui/model.js";
 import type { TerminalSubagentActivity } from "../subagentMonitor.js";
 import { type TerminalCommandCompletion, type TerminalCommandHelpGroup } from "../commandHelp.js";
 export type { TerminalCommandCompletion } from "../commandHelp.js";
@@ -20,6 +21,9 @@ export interface TerminalCommandHost {
     refresh(): void;
     changed(): void;
     showHelp(groups: TerminalCommandHelpGroup[]): void;
+    /** The latest todo list of this reply, or an empty list. */
+    todo(): Promise<readonly TodoEntry[]>;
+    showTodo(items: readonly TodoEntry[]): void;
     plan(brief: string): void;
     /** Asks a side question in its own tool-free session; empty text dismisses the one showing. */
     btw(question: string): Promise<void>;

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

@@ -399,6 +399,14 @@ export function createTerminalCommands(host) {
                 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.');
+                    else
+                        host.showTodo(items);
+                    break;
+                }
                 case 'subagents':
                     await openPage('subagents');
                     break;