@xingular/harness 1.2.0 → 1.3.1-unstable.1

package/dist/sdk/terminal/terminals.js

@@ -17,14 +17,15 @@ import { formatBashCommandForApproval } from "../core/workspaceBashTool.js";
 import { resolveWorkspaceRoot } from "../core/workspace.js";
 import { prependSearchPath, searchPath } from "../core/path.js";
 import { dispatch } from "../tools/dispatch.js";
+import { defaultSkillPaths } from "../tools/defaultSkills.js";
 import { materialise } from "../variant/materialise.js";
 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 +43,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) {
@@ -50,7 +51,7 @@ function resourceIdentity(loading) {
         return 'null';
     return JSON.stringify({
         extensions: loading.extensionPaths, builtins: loading.builtins, skills: loading.skillPaths,
-        prompts: loading.promptPaths, themes: loading.themePaths, detached: loading.detached,
+        prompts: loading.promptPaths, themes: loading.themePaths, profiles: loading.profilePaths, detached: loading.detached,
         project: loading.projectCode, packages: loading.packageCode
     });
 }
@@ -72,6 +73,8 @@ export class Terminals {
     diagnosticOwners = new Map();
     /** The variant each live session runs, for loading its skills. */
     variantDirs = new Map();
+    /** The subagent profile files each live session's packages bring, chosen when it started. */
+    packageProfiles = new Map();
     /** The world tools each session was given, so a call can only reach one of them. */
     worldNames = new Map();
     worldReadOnly = new Set();
@@ -98,12 +101,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 +171,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;
                 }
@@ -309,6 +361,19 @@ export class Terminals {
             return params[name];
         };
         switch (call) {
+            case 'plugins.proposals.list':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals.list();
+            case 'plugins.proposals.preview':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals.preview(text('id'));
+            case 'plugins.proposals.accept':
+            case 'plugins.proposals.reject':
+                if (!api.proposals)
+                    throw invalid('Proposal review is unavailable in this host.');
+                return api.proposals[call === 'plugins.proposals.accept' ? 'accept' : 'reject'](text('id'), text('hash'));
             case 'plugins.attach':
             case 'plugins.detach':
                 return api.attach({ ...scope, id: text('id'), scope: params.everywhere === true || !projectId ? {} : { projectId } }, call === 'plugins.attach');
@@ -432,7 +497,7 @@ export class Terminals {
             return params.scope;
         };
         switch (call.slice('terminal.agents.'.length)) {
-            case 'list': return { ...listProfiles(root, cwd, this.variantDirs.get(live.input.sessionId) ?? null), dirs: profileDirs(root, cwd) };
+            case 'list': return { ...listProfiles(root, cwd, this.variantDirs.get(live.input.sessionId) ?? null, this.packageProfiles.get(live.input.sessionId)), dirs: profileDirs(root, cwd) };
             case 'create': return createProfile(root, cwd, { name: name(), scope: scope(), from: typeof params.from === 'string' && params.from ? params.from : null });
             case 'remove':
                 removeProfile(root, cwd, { name: name(), scope: scope() });
@@ -533,6 +598,9 @@ export class Terminals {
         if (call === 'terminal.usage.limits') {
             return params.refresh === true ? limits.refresh(live.account.id, { force: true }) : limits.read(live.account.id);
         }
+        if (call === 'terminal.usage.allLimits') {
+            return params.refresh === true ? limits.refresh() : limits.read();
+        }
         if (call === 'terminal.usage.headers') {
             if (typeof params.provider !== 'string' || !params.provider)
                 throw invalid('A provider is required.');
@@ -587,14 +655,14 @@ export class Terminals {
             case 'read': return pageNotes.read(root, id());
             case 'create': {
                 const note = pageNotes.create(root, { source: params.source, target: params.target, body: params.body, tags: params.tags });
-                return params.share === true ? pageNotes.share(root, note.id, { sessionId }) : note;
+                return params.share === true ? needNotes().share(note.id, undefined, sessionId) : note;
             }
             case 'update': return pageNotes.update(root, id(), version(), (params.patch ?? {}));
             case 'delete':
                 pageNotes.remove(root, id(), version());
                 return {};
             // A terminal shares with, and withdraws from, its own session only.
-            case 'share': return pageNotes.share(root, id(), { sessionId });
+            case 'share': return needNotes().share(id(), undefined, sessionId);
             case 'unshare': return pageNotes.unshare(root, id(), { sessionId });
             case 'open': return needCapture().open(sessionId, typeof params.url === 'string' && params.url ? params.url : null);
             case 'identity': return needCapture().identity(sessionId);
@@ -613,7 +681,7 @@ export class Terminals {
                 const note = pageNotes.read(root, id());
                 return needCapture().reveal(sessionId, note.source.url, note.target);
             }
-            // ---- The inspector and the queue (PROP-0018); a terminal queues and sends to its own session.
+            // ---- The inspector and sending (PROP-0018, PROP-0042); a terminal shares with and sends to its own session.
             case 'target': return { ...needCapture().describe(sessionId), windows: await needCapture().windows(sessionId).catch(() => []) };
             case 'attach': {
                 const kind = params.kind;
@@ -635,10 +703,18 @@ export class Terminals {
                 await needCapture().stopInspect(sessionId);
                 return {};
             case 'next': return inspectStep(needCapture(), needNotes(), sessionId, sessionId, 'terminal');
-            case 'queue': return needNotes().queue(id(), version(), sessionId);
-            case 'dequeue': return needNotes().dequeue(id(), version());
             case 'confirm': return needNotes().confirm(id(), version());
-            case 'send': return needNotes().send(sessionId, { ids: Array.isArray(params.ids) ? params.ids.filter((entry) => typeof entry === 'string') : null });
+            case 'confirmAll': return { notes: needNotes().confirmAll(sessionId) };
+            case 'clear': return { notes: needNotes().clear(sessionId) };
+            case 'send': return needNotes().send(sessionId, {
+                ids: Array.isArray(params.ids) ? params.ids.filter((entry) => typeof entry === 'string') : null,
+                prompt: typeof params.prompt === 'string' ? params.prompt : null
+            });
+            case 'discover': return { apps: await needCapture().discover() };
+            case 'launch':
+                if (typeof params.path !== 'string' || !params.path.trim())
+                    throw invalid('Give the path of the app to start.');
+                return needCapture().launchApp(sessionId, params.path, Array.isArray(params.args) ? params.args.filter((entry) => typeof entry === 'string') : []);
             default:
                 throw new HarnessError('unknown_method', `Unknown call ${call}.`);
         }
@@ -690,7 +766,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 +782,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 +831,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 };
@@ -829,11 +913,12 @@ export class Terminals {
         }
         if (call === 'terminal.subagents.tools') {
             const variantDir = this.variantDirs.get(live.input.sessionId) ?? null;
+            const packaged = this.packageProfiles.get(live.input.sessionId) ?? [];
             return {
                 tools: subagentTools(service, '').map(tool => ({ name: tool.name, label: tool.label, description: tool.description, parameters: tool.parameters(Type) })),
                 profiles: {
-                    normal: profileSection(this.options.env.root, live.input.cwd, variantDir).body,
-                    plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true).body
+                    normal: profileSection(this.options.env.root, live.input.cwd, variantDir, false, undefined, packaged).body,
+                    plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true, undefined, packaged).body
                 }
             };
         }
@@ -850,13 +935,23 @@ 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 packaged = this.packageProfiles.get(live.input.sessionId) ?? [];
+            const subagentProfiles = {
+                normal: profileSection(this.options.env.root, live.input.cwd, variantDir, false, undefined, packaged).body,
+                plan: profileSection(this.options.env.root, live.input.cwd, variantDir, true, {
+                    frozenTools: capabilities.tools,
+                    contributions: capabilities.contributions,
+                    descriptors: HARNESS_PLUGINS
+                }, packaged).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,
@@ -866,10 +961,14 @@ export class Terminals {
                 connections: live.input.connections === false ? false : { readOnly }, subagents: live.input.subagents,
                 plan: params.plan === true,
                 variant: live.variant ? { dir: live.variant.dir, scope: live.variant.scope } : null,
+                packageProfiles: packaged,
                 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);
@@ -1028,11 +1127,12 @@ export class Terminals {
                 plugins: () => this.options.pluginControl?.list({ cwd: input.cwd, accountId: preparedAccount.id, projectId: input.projectId ?? null }) ?? Promise.resolve([]) });
             if (variant)
                 this.variantDirs.set(sessionId, variant.dir);
+            this.packageProfiles.set(sessionId, loading?.profilePaths ?? []);
             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 profiles = this.options.subagents && input.subagents !== null ? profileSection(root, input.cwd, variant?.dir ?? null, false, undefined, loading?.profilePaths ?? []) : null;
             const launchSections = profiles ? [...(input.launch?.sections ?? []).filter((section) => section.id !== profiles.id), profiles] : input.launch?.sections;
             // A terminal is a person's own session: the same standard sections a host's session has.
             const standard = input.launch?.standard === null ? null : input.launch?.standard ?? { cwd: input.cwd };
@@ -1050,7 +1150,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 +1269,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 ?? [] };
@@ -1208,7 +1311,7 @@ export class Terminals {
                 // The pi command's own extensions are not loaded: a host's session cannot have them (PROP-0039).
                 for (const path of [...(loading?.extensionPaths ?? []), ...(variant?.extensionPaths ?? [])])
                     args.push('--extension', path);
-                for (const path of [...(variant?.skillPaths ?? []), ...(loading?.skillPaths ?? [])])
+                for (const path of [...(variant?.skillPaths ?? []), ...defaultSkillPaths(variant?.dir), ...(loading?.skillPaths ?? [])])
                     args.push('--skill', path);
                 for (const path of loading?.promptPaths ?? [])
                     args.push('--prompt-template', path);
@@ -1239,6 +1342,7 @@ export class Terminals {
                 this.socket.revoke(token);
             this.sessions.delete(sessionId);
             this.variantDirs.delete(sessionId);
+            this.packageProfiles.delete(sessionId);
             this.worldNames.delete(sessionId);
             if (this.worktreeLeases.get(sessionId) === acquiredWorktreeId)
                 this.worktreeLeases.delete(sessionId);

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/annotateCommand.d.ts

@@ -1,3 +1,7 @@
 import type { AnnotateStart } from "./pages/annotatePage.js";
-/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+/** A typed page address: a bare host gets https, localhost gets http. */
+export declare function normalizeAddress(text: string): string;
+/** A typed DevTools port or loopback address. */
+export declare function normalizeDevTools(text: string): string;
+/** `/annotate:` accepts a page address, an app's DevTools port, or the page bridge. */
 export declare function parseAnnotate(argument: string): AnnotateStart | string;

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

@@ -1,4 +1,20 @@
-/** `/annotate:annotate` accepts a page address, DevTools target, or page-bridge target. */
+/** A typed page address: a bare host gets https, localhost gets http. */
+export function normalizeAddress(text) {
+    const word = text.trim();
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(word))
+        return word;
+    return /^(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(word) ? `http://${word}` : `https://${word}`;
+}
+/** A typed DevTools port or loopback address. */
+export function normalizeDevTools(text) {
+    const word = text.trim();
+    if (/^\d+$/.test(word))
+        return `http://127.0.0.1:${word}`;
+    if (/^(localhost|127\.0\.0\.1|\[::1\]):\d+$/.test(word))
+        return `http://${word}`;
+    return word;
+}
+/** `/annotate:` accepts a page address, an app's DevTools port, or the page bridge. */
 export function parseAnnotate(argument) {
     const words = argument.trim().split(/\s+/).filter(Boolean);
     if (!words.length)
@@ -6,17 +22,15 @@ export function parseAnnotate(argument) {
     if (words[0] === '--app') {
         const endpoint = words[1];
         if (!endpoint)
-            return 'Give the app\'s DevTools address: /annotate:annotate --app http://127.0.0.1:9229';
-        const address = /^\d+$/.test(endpoint) ? `http://127.0.0.1:${endpoint}` : endpoint;
+            return { kind: 'apps' };
         const name = words.slice(2).join(' ');
-        return { kind: 'cdp', endpoint: address, ...(name ? { name } : {}) };
+        return { kind: 'cdp', endpoint: normalizeDevTools(endpoint), ...(name ? { name } : {}) };
     }
     if (words[0] === '--bridge') {
         const name = words.slice(1).join(' ');
         return { kind: 'bridge', ...(name ? { name } : {}) };
     }
     if (words.length > 1 || words[0].startsWith('--'))
-        return 'Use /annotate:annotate [url], /annotate:annotate --app <DevTools address>, or /annotate:annotate --bridge.';
-    const url = /^[a-z][a-z0-9+.-]*:\/\//i.test(words[0]) ? words[0] : /^(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(words[0]) ? `http://${words[0]}` : `https://${words[0]}`;
-    return { kind: 'web', url };
+        return 'Use /annotate: [url], /annotate: --app [port], or /annotate: --bridge.';
+    return { kind: 'web', url: normalizeAddress(words[0]) };
 }

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

@@ -0,0 +1,30 @@
+import type { MenuCall } from "../pluginMenu.js";
+import type { Note } from "../../annotations/store.js";
+type SendResult = {
+    state: 'sent';
+    ids: string[];
+} | {
+    state: 'busy';
+    ids: string[];
+} | {
+    state: 'host';
+    ids: string[];
+} | {
+    state: 'empty';
+    ids: [];
+    unconfirmed?: number;
+};
+export interface AnnotateSendUi {
+    confirm(title: string, message: string): Promise<boolean>;
+}
+/** Unsent annotations of `sessionId`, oldest first. */
+export declare function unsent(notes: readonly Note[], sessionId: string | null): Note[];
+/**
+ * Sends every unsent annotation of this terminal's session, with `prompt` after them when given.
+ * Returns what to tell the person.
+ */
+export declare function sendUnsent(call: MenuCall, ui: AnnotateSendUi, options?: {
+    prompt?: string;
+}): Promise<string>;
+export declare function describeSend(result: SendResult, withPrompt?: boolean): string;
+export {};

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

@@ -0,0 +1,40 @@
+const count = (n) => `${n} annotation${n === 1 ? '' : 's'}`;
+/** Unsent annotations of `sessionId`, oldest first. */
+export function unsent(notes, sessionId) {
+    return notes
+        .filter((note) => note.status === 'open' && note.delivery?.state === 'pending' && note.delivery.sessionId === sessionId)
+        .sort((left, right) => left.delivery.queuedAt.localeCompare(right.delivery.queuedAt));
+}
+/**
+ * Sends every unsent annotation of this terminal's session, with `prompt` after them when given.
+ * Returns what to tell the person.
+ */
+export async function sendUnsent(call, ui, options = {}) {
+    const listed = await call('terminal.annotations.list');
+    const waiting = unsent(listed.notes, listed.sessionId);
+    if (!waiting.length) {
+        return options.prompt
+            ? 'No unsent annotations. Annotate something with /annotate: first, or send your request as a normal message.'
+            : 'Nothing to send. Annotate something first.';
+    }
+    const unconfirmed = waiting.filter((note) => note.delivery?.confirm);
+    if (unconfirmed.length) {
+        const yes = await ui.confirm(`Send ${count(waiting.length)} to the agent?`, `${count(unconfirmed.length)} came from the app's own page scripts, which could have written them. Check that the comments are yours.`);
+        if (!yes)
+            return 'Nothing was sent.';
+        await call('terminal.annotations.confirmAll');
+    }
+    const result = await call('terminal.annotations.send', options.prompt ? { prompt: options.prompt } : {});
+    return describeSend(result, !!options.prompt);
+}
+export function describeSend(result, withPrompt = false) {
+    if (result.state === 'sent')
+        return `Sent ${count(result.ids.length)} to the agent.`;
+    if (result.state === 'busy' && withPrompt)
+        return 'The agent is still working. Submit again when it finishes; your annotations stay unsent.';
+    if (result.state === 'busy')
+        return `The agent is working; ${count(result.ids.length)} go${result.ids.length === 1 ? 'es' : ''} out when it finishes.`;
+    if (result.state === 'host')
+        return `${count(result.ids.length)} handed to the app to send.`;
+    return result.unconfirmed ? `${count(result.unconfirmed)} still wait for your confirmation.` : 'Nothing to send.';
+}

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.d.ts

@@ -7,7 +7,7 @@ export declare function createCommandPage(host: TerminalCommandHost, id: Command
     runId?: string;
     url?: string;
     annotate?: AnnotateStart;
-    usageTab?: 'analysis' | 'limit';
+    usageTab?: 'analysis' | 'limit' | 'accounts';
     usagePeriod?: 'today' | '7d' | '30d' | 'all';
     close?(): void;
 }): TerminalPage;

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

@@ -1,12 +1,13 @@
 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";
 import { TrajectoryPage } from "./pages/trajectoryPage.js";
 import { WorktreesPage } from "./pages/worktreesPage.js";
-import { NotesPage } from "./pages/notesPage.js";
 import { AnnotatePage } from "./pages/annotatePage.js";
 import { SubagentsPage } from "./pages/subagentsPage.js";
 import { AgentsPage } from "./pages/agentsPage.js";
@@ -18,7 +19,7 @@ export function createCommandPage(host, id, options = {}) {
     const notify = (message, type) => host.ui.notify(message, type === 'error' || type === 'warning' ? type : 'info');
     switch (id) {
         case 'usage':
-            return new UsagePage({ theme, call: host.control, changed: host.changed, initialTab: options.usageTab === 'limit' ? 'limits' : 'analysis', ...(options.usagePeriod ? { initialPeriod: options.usagePeriod } : {}) });
+            return new UsagePage({ theme, call: host.control, changed: host.changed, initialTab: options.usageTab === 'limit' ? 'limits' : options.usageTab === 'accounts' ? 'accounts' : 'analysis', ...(options.usagePeriod ? { initialPeriod: options.usagePeriod } : {}) });
         case 'doctor':
             return new DoctorPage({ theme, call: host.control, confirm: host.ui.confirm.bind(host.ui), select: host.ui.select.bind(host.ui), changed: host.changed,
                 selection: () => {
@@ -40,17 +41,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) => {
@@ -75,13 +84,9 @@ export function createCommandPage(host, id, options = {}) {
                 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) }
             });
         case 'notes':
-            return new NotesPage({
-                theme, call: host.control, changed: host.changed, ...(options.url !== undefined ? { start: options.url ? { url: options.url } : {} } : {}),
-                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) }
-            });
         case 'annotate':
             return new AnnotatePage({
-                theme, call: host.control, changed: host.changed, start: options.annotate ?? { kind: 'web' },
+                theme, call: host.control, changed: host.changed, start: options.annotate ?? { kind: 'web' }, initialTab: id === 'notes' ? 'all' : 'annotate',
                 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) }
             });
         case 'settings':

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>;