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

package/dist/sdk/terminal/client.js

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

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

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

package/dist/sdk/terminal/control.js

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

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

@@ -57,7 +57,10 @@ export interface ControllerHooks {
 export declare class TerminalController {
     private readonly hooks;
     private run;
+    private lastRunId;
     private readonly pending;
+    private pendingRevision;
+    private readonly pendingWaiters;
     private readonly subagents;
     private subagentParentRunId;
     private ready;
@@ -71,8 +74,14 @@ export declare class TerminalController {
     private readonly seen;
     private readonly commands;
     constructor(hooks: ControllerHooks);
+    private pendingChanged;
+    private setPending;
+    private deletePending;
+    private waitPending;
     get nativeSessionId(): string | null;
     get activeRun(): ActiveRun | null;
+    /** The run this terminal is showing, or the last one it finished: `/context` reads it after a reply. */
+    get lastRun(): string | null;
     state(): {
         ready: boolean;
         dirty: boolean;

package/dist/sdk/terminal/controller.js

@@ -26,7 +26,10 @@ const ACK_TIMEOUT_MS = 25_000;
 export class TerminalController {
     hooks;
     run = null;
+    lastRunId = null;
     pending = new Map();
+    pendingRevision = 0;
+    pendingWaiters = new Set();
     subagents = new SubagentMonitor();
     subagentParentRunId = null;
     ready = false;
@@ -43,12 +46,39 @@ export class TerminalController {
         this.hooks = hooks;
         this.nativeId = hooks.nativeSessionId;
     }
+    pendingChanged() {
+        this.pendingRevision += 1;
+        for (const wake of this.pendingWaiters)
+            wake();
+    }
+    setPending(key, value) {
+        this.pending.set(key, value);
+        this.pendingChanged();
+    }
+    deletePending(key) {
+        if (this.pending.delete(key))
+            this.pendingChanged();
+    }
+    async waitPending(revision) {
+        if (revision === this.pendingRevision && !this.disposed) {
+            await new Promise(resolve => {
+                const wake = () => { clearTimeout(timer); this.pendingWaiters.delete(wake); resolve(); };
+                const timer = setTimeout(wake, 20_000);
+                this.pendingWaiters.add(wake);
+            });
+        }
+        return { revision: this.pendingRevision, requests: [...this.pending.values()] };
+    }
     get nativeSessionId() {
         return this.nativeId;
     }
     get activeRun() {
         return this.run && !this.run.finished ? this.run : null;
     }
+    /** The run this terminal is showing, or the last one it finished: `/context` reads it after a reply. */
+    get lastRun() {
+        return this.activeRun?.runId ?? this.lastRunId;
+    }
     state() {
         return { ready: this.ready, dirty: this.dirty, active: !!this.activeRun || !!this.delivery };
     }
@@ -67,6 +97,7 @@ export class TerminalController {
             throw new Error('The native prompt did not match the reserved delivery. Inspect the terminal before continuing.');
         const run = this.hooks.begin({ reservedRunId: delivery?.runId ?? null, nativeTurnId, text, ...launch });
         this.run = run;
+        this.lastRunId = run.runId;
         this.subagentParentRunId = run.runId;
         this.subagents.begin(run.runId);
         run.onInterrupt(() => void this.commands.push({ type: 'interrupt' }));
@@ -80,7 +111,10 @@ export class TerminalController {
         this.run?.finish(outcome, message ? { code: 'terminal_attention', message } : undefined, reason);
         this.run = null;
         this.seen.clear();
-        this.pending.clear();
+        if (this.pending.size) {
+            this.pending.clear();
+            this.pendingChanged();
+        }
     }
     /** Hands the native process an instruction and waits until it acknowledges the prompt. */
     async send(runId, text) {
@@ -145,19 +179,19 @@ export class TerminalController {
             return;
         if (event.type === 'question.requested') {
             const payload = event.payload;
-            this.pending.set(String(payload.questionId), { ...payload, type: 'question', requestId: payload.questionId, runId: event.runId });
+            this.setPending(String(payload.questionId), { ...payload, type: 'question', requestId: payload.questionId, runId: event.runId });
         }
         else if (event.type === 'approval.requested') {
             const payload = event.payload;
             if (!payload.automatic && (descendant || payload.target === 'workspace-write')) {
-                this.pending.set(String(payload.approvalId), { ...payload, type: 'approval', requestId: payload.approvalId, runId: event.runId });
+                this.setPending(String(payload.approvalId), { ...payload, type: 'approval', requestId: payload.approvalId, runId: event.runId });
             }
         }
         else if (event.type === 'approval.resolved') {
-            this.pending.delete(String(event.payload.approvalId));
+            this.deletePending(String(event.payload.approvalId));
         }
         else if (event.type === 'question.answered') {
-            this.pending.delete(String(event.payload.questionId));
+            this.deletePending(String(event.payload.questionId));
         }
     }
     /** A child event that belongs to the active terminal parent run. */
@@ -197,6 +231,8 @@ export class TerminalController {
         }
         if (call === 'terminal.pending')
             return { requests: [...this.pending.values()] };
+        if (call === 'terminal.pending.wait')
+            return this.waitPending(data.revision);
         if (call === 'terminal.interrupt')
             return this.activeRun && this.hooks.interrupt ? this.hooks.interrupt(this.activeRun.runId) : {};
         if (call === 'terminal.policy') {
@@ -292,7 +328,7 @@ export class TerminalController {
             rememberable: policy.rememberable === true,
             standing: policy.standing
         });
-        this.pending.set(key, {
+        this.setPending(key, {
             type: 'approval', requestId: key, runId: run.runId, target: tool, action,
             operation, rememberable: policy.rememberable === true, direct: true
         });
@@ -301,7 +337,7 @@ export class TerminalController {
             return { decision: await response };
         }
         finally {
-            this.pending.delete(key);
+            this.deletePending(key);
         }
     }
     async accept(event, data) {
@@ -380,9 +416,9 @@ export class TerminalController {
                 const summary = typeof data.summary === 'string' && data.summary.trim() ? data.summary.trim() : undefined;
                 const sketchMode = data.uiSketch === undefined ? {} : { uiSketch: data.uiSketch };
                 const response = run.requestAnswer({ requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect, allowText: true });
-                this.pending.set(key, { type: 'question', requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect });
+                this.setPending(key, { type: 'question', requestId: key, ...(summary ? { summary } : {}), ...sketchMode, question: String(data.question ?? ''), options: data.options ?? [], multiSelect: !!data.multiSelect });
                 this.seen.set(key, response);
-                return response.finally(() => this.pending.delete(key));
+                return response.finally(() => this.deletePending(key));
             }
             const response = run.requestApproval({
                 requestId: key,
@@ -391,13 +427,13 @@ export class TerminalController {
                 operation: { tool: String(data.tool ?? data.target), args: data.args ?? {} },
                 rememberable: false
             });
-            this.pending.set(key, { type: 'approval', requestId: key, target: String(data.target ?? 'Action'), action: String(data.action ?? '{}') });
+            this.setPending(key, { type: 'approval', requestId: key, target: String(data.target ?? 'Action'), action: String(data.action ?? '{}') });
             this.seen.set(key, response);
             try {
                 return { decision: await response };
             }
             finally {
-                this.pending.delete(key);
+                this.deletePending(key);
             }
         }
         if (event === 'usage')
@@ -425,6 +461,7 @@ export class TerminalController {
         if (this.disposed)
             return;
         this.disposed = true;
+        this.pendingChanged();
         this.ready = false;
         this.delivery?.reject(new Error('The terminal stopped before prompt acknowledgement.'));
         this.delivery = null;

package/dist/sdk/terminal/piExtension.js

@@ -2,8 +2,10 @@
 // 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 { readFileSync } from 'node:fs';
 import { createBashTool, createEditTool, createPowerShellTool, createWriteTool } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
+import { bodyOf } from "../core/frontmatter.js";
 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";
@@ -17,9 +19,10 @@ import { SESSION_NAME, deriveSessionName, sessionNameTool } from "../tools/sessi
 import { CAPABILITY_DISCOVERY, describeCapabilities } from "../tools/getCapabilities.js";
 import { PLAN_INSTRUCTIONS, planRefusal } from "../sessions/planMode.js";
 import { compactionCheckpoint } from "../sessions/compactionCheckpoint.js";
-import { sessionStateText } from "../prompt/compile.js";
+import { requiredSkillsText, sessionStateText } from "../prompt/compile.js";
 import { pruneToolImages } from "../world/images.js";
 import { parseInitialBashCommand } from "../sessions/initialBash.js";
+import { skillInvocations } from "./tui/skillInvocation.js";
 import { inspectWorkspaceWrite } from "../sessions/workspaceBoundary.js";
 import { createWorkspaceShellTool } from "../core/workspaceBashTool.js";
 import { createWorkspaceBashOperations, runWithWorkspaceWriteScope } from "../core/workspaceSandbox.js";
@@ -298,6 +301,37 @@ export default async function (pi, planRun, getSession) {
         if (notice)
             return { message: { customType: SUBAGENT_RESULTS, content: notice.text, display: false, details: { [SUBAGENT_RECEIPT]: notice.receipt } } };
     });
+    // A `$name` anywhere in the message makes that skill required for this request. The skill's text is
+    // delivered as a hidden request-scoped message, so the person's own wording reaches the model unchanged.
+    pi.on('before_agent_start', async (event) => {
+        if (event.messageType !== 'user' || /^\s*!/u.test(event.prompt))
+            return;
+        if (pi.getSettings?.().enableSkillCommands === false)
+            return;
+        const skills = (pi.getCommands?.() ?? [])
+            .filter((command) => command.source === 'skill')
+            .map((command) => ({
+            name: command.name.replace(/^skill:/, ''),
+            path: command.sourceInfo.path,
+            ...(command.sourceInfo.baseDir ? { baseDir: command.sourceInfo.baseDir } : {})
+        }));
+        if (!skills.length)
+            return;
+        const names = skillInvocations(event.prompt, new Set(skills.map((skill) => skill.name)));
+        if (!names.length)
+            return;
+        const entries = names.map((name) => {
+            const skill = skills.find((candidate) => candidate.name === name);
+            try {
+                return { name, path: skill.path, baseDir: skill.baseDir, body: bodyOf(readFileSync(skill.path, 'utf8')) };
+            }
+            catch {
+                return { name, path: skill.path, body: '' };
+            }
+        });
+        const content = requiredSkillsText(entries);
+        return content ? { message: { customType: 'xingular-required-skills', content, display: false, details: { skills: names } } } : undefined;
+    });
     // A new user turn starts with an empty todo. The previous list is context, not this run's list.
     // A substantive first turn also gets a provisional name when the terminal policy allows it.
     pi.on('before_agent_start', async (event, ctx) => {

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

@@ -198,6 +198,8 @@ export declare class Terminals {
     private agentsCall;
     /** `/worktree`: the managed worktrees of the repository this session works in. */
     private worktreesCall;
+    /** `/context`: what the session's latest request was made of, and one row's text on request. */
+    private contextCall;
     /** `/usage:analysis` and `/usage:limit`: usage for this session's own account, project or session. */
     private usageCall;
     /** `/annotate:notes` and `/annotate:`: Web annotations and their visible capture browser. */

package/dist/sdk/terminal/terminals.js

@@ -21,6 +21,7 @@ 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 { attribution, rowText } from "../context/attribution.js";
 import { compile, copyToRun, record, render, saveForSession } from "../prompt/compile.js";
 import { isActiveStatus } from "../sessions/contracts.js";
 import { findRun, loadRun, readEvents, recordedSubagents, saveRun, updateRun } from "../sessions/runStore.js";
@@ -575,6 +576,14 @@ export class Terminals {
                 throw new HarnessError('unknown_method', `Unknown call ${call}.`);
         }
     }
+    /** `/context`: what the session's latest request was made of, and one row's text on request. */
+    contextCall(live, params) {
+        const runId = live.controller.lastRun;
+        if (!runId)
+            return { attribution: null, text: null };
+        const text = typeof params.section === 'string' && params.section ? rowText(this.options.env, runId, params.section) : null;
+        return { attribution: attribution(this.options.env, runId), text };
+    }
     /** `/usage:analysis` and `/usage:limit`: usage for this session's own account, project or session. */
     async usageCall(live, call, params) {
         const usage = this.options.usage;
@@ -1290,6 +1299,8 @@ export class Terminals {
                         }
                         if (call.startsWith('terminal.usage.'))
                             return this.usageCall(live, call, params);
+                        if (call === 'terminal.context')
+                            return this.contextCall(live, params);
                         if (call !== 'terminal.resources')
                             return live.controller.control(call, params);
                         const current = await this.options.plugins?.loading({ cwd: input.cwd, agentDir: configDir(accounts.dir, preparedAccount), install: false, caller: { projectId: input.projectId ?? null } }) ?? null;

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

@@ -1,5 +1,5 @@
 import { type AgentSession, type ExtensionUIContext } from '@earendil-works/pi-coding-agent';
-import { type SkillEntry } from "./skillInvocation.js";
+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";
@@ -47,6 +47,5 @@ export declare function createTerminalCommands(host: TerminalCommandHost): {
     execute: (text: string) => Promise<boolean>;
     completions: () => TerminalCommandCompletion[];
     skills: () => SkillEntry[];
-    expandSkill: (text: string) => string;
     legacyAliases: () => string[];
 };

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

@@ -10,7 +10,6 @@ import { TreePicker } from "./treePicker.js";
 import { createCommandPage } from "./commandPages.js";
 import { pageOverlayOptions } from "./dialogGeometry.js";
 import { ResumeSessionsPage } from "./sessionPicker.js";
-import { expandSkillInvocation } from "./skillInvocation.js";
 import { groupTerminalCommands } from "../commandHelp.js";
 import { createBuiltinPluginCommandHandlers } from "./pluginCommands.js";
 export { parseAnnotate } from "./pluginCommands.js";
@@ -43,8 +42,6 @@ export function createTerminalCommands(host) {
             return [];
         return session.resourceLoader.getSkills().skills.map((skill) => ({ name: skill.name, description: skill.description }));
     };
-    /** The text to send: a leading `$name` of a loaded skill becomes the `/skill:name` form Pi expands. */
-    const expandSkill = (text) => expandSkillInvocation(text, new Set(skills().map((skill) => skill.name)));
     async function openPage(id, options = {}) {
         let close = () => { };
         const page = createCommandPage(host, id, { ...options, close: () => close() });
@@ -486,5 +483,5 @@ export function createTerminalCommands(host) {
         }
         return true;
     }
-    return { execute, completions, skills, expandSkill, legacyAliases };
+    return { execute, completions, skills, legacyAliases };
 }

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

@@ -1,6 +1,7 @@
 import type { ExtensionUIContext, ExtensionUIDialogOptions, KeybindingsManager, Theme } from '@earendil-works/pi-coding-agent';
-import { Input, type Component, type Focusable, type SelectListTheme, type TUI, type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import { type Component, type Focusable, type SelectListTheme, type TUI, type TuiMouseEventResult } from '@earendil-works/pi-tui';
 import type { TerminalMouseInput } from "./mouse.js";
+import { MouseSafeInput } from "./mouseReport.js";
 export interface GroupedSelectOption {
     label: string;
     group?: string;
@@ -12,7 +13,7 @@ export type TerminalDialogOptions = ExtensionUIDialogOptions & {
 export type DialogVariant = 'block' | 'page';
 export declare function selectTheme(theme: Theme): SelectListTheme;
 /** Input keeps the original value; only its rendered cells are masked. */
-export declare class SecretInput extends Input {
+export declare class SecretInput extends MouseSafeInput {
     render(width: number): string[];
 }
 /** Choices as a `FilterList`, with the standard search field visible for every list. */

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

@@ -1,8 +1,9 @@
-import { Editor, Input, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { Editor, matchesKey, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
 import { CENTER_DIALOG_PAD, CHROME_ROWS, blockFrame, centerDialogChromeRows, centerDialogContentWidth, centerDialogFrame, centerDialogVerticalPad, contentWidth, pageFrame, safeText, selectionText } from "./chrome.js";
 import { centeredDialogHost, dialogFits, pageOverlayOptions, pageRows } from "./dialogGeometry.js";
 import { FilterList } from "./list.js";
 import { searchFieldRowsFor } from "./search.js";
+import { MouseSafeInput } from "./mouseReport.js";
 export function selectTheme(theme) {
     return {
         selectedPrefix: text => selectionText(theme, text), selectedText: text => selectionText(theme, text.replace(/^→/, '❯')),
@@ -11,7 +12,7 @@ export function selectTheme(theme) {
     };
 }
 /** Input keeps the original value; only its rendered cells are masked. */
-export class SecretInput extends Input {
+export class SecretInput extends MouseSafeInput {
     render(width) {
         const lines = super.render(width);
         if (!this.getValue())
@@ -280,7 +281,7 @@ export class TerminalDialogs {
     }
     input(title, placeholder, opts, secret = false) {
         return this.show(done => {
-            const InputType = secret ? SecretInput : Input;
+            const InputType = secret ? SecretInput : MouseSafeInput;
             const input = new InputType({ prompt: secret ? '' : '> ', placeholder, placeholderStyle: text => this.theme().fg('dim', text) });
             input.onSubmit = done;
             input.onEscape = () => done(undefined);

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

@@ -4,7 +4,7 @@ declare module '@earendil-works/pi-tui' {
     interface Keybindings {
         'app.thinking.increase': true;
         'app.thinking.decrease': true;
-        'app.message.followUp': true;
+        'app.message.steer': true;
     }
 }
 export declare const HARNESS_KEYBINDINGS: KeybindingDefinitions;

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

@@ -11,7 +11,7 @@ const actions = {
     'app.model.cycleForward': 'ctrl+p', 'app.model.cycleBackward': 'alt+p',
     'app.model.select': 'ctrl+l', 'app.tools.expand': 'ctrl+o', 'app.thinking.toggle': 'ctrl+t',
     'app.editor.external': 'ctrl+g', 'app.message.copy': 'ctrl+x',
-    'app.message.followUp': ['super+enter', 'ctrl+enter', 'alt+enter'], 'app.message.dequeue': 'alt+up',
+    'app.message.steer': ['super+enter', 'ctrl+enter', 'alt+enter'], 'app.message.dequeue': 'alt+up',
     'app.clipboard.pasteImage': process.platform === 'darwin' ? ['ctrl+v', 'alt+v'] : 'ctrl+v',
     'app.session.toggleNamedFilter': 'ctrl+n', 'app.session.togglePath': 'ctrl+p',
     'app.session.toggleSort': 'ctrl+s', 'app.session.rename': 'ctrl+r',

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

@@ -34,9 +34,10 @@ export declare class ModeChoices {
     quietly<T>(action: () => T | Promise<T>): Promise<T>;
     /**
      * Applies a mode's saved model and effort to the session. A model the account cannot use is
-     * skipped, and Pi clamps an effort the model does not support.
+     * skipped, and Pi clamps an effort the model does not support. A mode with no effort of its own
+     * returns to `fallback`, so a level chosen in another mode does not stay with this one.
      */
-    apply(session: ChoiceSession, mode: ComposerMode, modelFor: (reference: string) => ChoiceModel | undefined): Promise<void>;
+    apply(session: ChoiceSession, mode: ComposerMode, modelFor: (reference: string) => ChoiceModel | undefined, fallback: AgentSession['thinkingLevel']): Promise<void>;
     /** Records a selection the person made in `mode`. Skipped while the terminal is making its own change. */
     record(mode: ComposerMode, patch: ChoicePatch): Promise<void>;
 }

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

@@ -31,9 +31,10 @@ export class ModeChoices {
     }
     /**
      * Applies a mode's saved model and effort to the session. A model the account cannot use is
-     * skipped, and Pi clamps an effort the model does not support.
+     * skipped, and Pi clamps an effort the model does not support. A mode with no effort of its own
+     * returns to `fallback`, so a level chosen in another mode does not stay with this one.
      */
-    async apply(session, mode, modelFor) {
+    async apply(session, mode, modelFor, fallback) {
         const choice = this.resolve(mode);
         await this.quietly(async () => {
             const model = choice.model ? modelFor(choice.model) : undefined;
@@ -45,8 +46,7 @@ export class ModeChoices {
                     // Not usable on this account (no key, or no longer offered): keep the session's model.
                 }
             }
-            if (choice.effort)
-                session.setThinkingLevel(choice.effort, { persist: false });
+            session.setThinkingLevel((choice.effort ?? fallback), { persist: false });
         });
     }
     /** Records a selection the person made in `mode`. Skipped while the terminal is making its own change. */

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

@@ -0,0 +1,30 @@
+import { Input } from '@earendil-works/pi-tui';
+/** A leaked report is echoed within one read; ten characters in this window is 50 characters a second. */
+export declare const MOUSE_REPORT_TAIL_WINDOW_MS = 200;
+export interface MouseReportMatch {
+    /** The whole report the keys spelled, without its `ESC[` prefix. */
+    report: string;
+    /** What a text field already held before the completing sequence. */
+    inserted: string;
+}
+/**
+ * Follows the printable characters of one report. A caller that receives the completing sequence
+ * before insertion removes `inserted`; a caller that receives it after insertion removes `report`.
+ */
+export declare class MouseReportTail {
+    private text;
+    private startedAt;
+    push(sequence: string, nowMs?: number): MouseReportMatch | undefined;
+    reset(): void;
+}
+/** A single-line input that drops a leaked mouse report instead of keeping it as text. */
+export declare class MouseSafeInput extends Input {
+    private readonly mouseTail;
+    handleInput(data: string): void;
+    setValue(value: string): void;
+}
+/**
+ * Removes reports from text that is about to be printed. A bare `<\d;\d;\d>M` stays: once recorded it
+ * is content, and rewriting it would misreport what a run received.
+ */
+export declare function stripMouseReports(text: string): string;

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

@@ -0,0 +1,80 @@
+// A mouse report that the input parser split across its timeout loses its `ESC[` prefix: the orphaned
+// prefix is flushed as an unknown response and the rest is decoded as keystrokes. These helpers keep
+// that tail out of text fields, without touching what a person types or pastes.
+import { Input } from '@earendil-works/pi-tui';
+/** A leaked report is echoed within one read; ten characters in this window is 50 characters a second. */
+export const MOUSE_REPORT_TAIL_WINDOW_MS = 200;
+const REPORT = /^<\d{1,3};\d{1,4};\d{1,4}[Mm]$/;
+const PARTIAL = /^<\d{0,3}(;\d{0,4}){0,2}$/;
+const WHOLE = /^(?:\x1b\[)?<\d{1,3};\d{1,4};\d{1,4}[Mm]$/;
+const SGR_REPORT = /\x1b\[<\d+;\d+;\d+[Mm]|\\u001b\[<\d+;\d+;\d+[Mm]|\\x1b\[<\d+;\d+;\d+[Mm]/g;
+const X10_REPORT = /\x1b\[M[\u0020-\u00ff]{3}/g;
+/**
+ * Follows the printable characters of one report. A caller that receives the completing sequence
+ * before insertion removes `inserted`; a caller that receives it after insertion removes `report`.
+ */
+export class MouseReportTail {
+    text = '';
+    startedAt = 0;
+    push(sequence, nowMs = Date.now()) {
+        if (WHOLE.test(sequence)) {
+            this.reset();
+            return { report: sequence.replace(/^\x1b\[/, ''), inserted: '' };
+        }
+        if (sequence.length !== 1) {
+            this.reset();
+            return undefined;
+        }
+        if (sequence === '<') {
+            this.text = '<';
+            this.startedAt = nowMs;
+            return undefined;
+        }
+        if (!this.text)
+            return undefined;
+        if (nowMs - this.startedAt > MOUSE_REPORT_TAIL_WINDOW_MS) {
+            this.reset();
+            return undefined;
+        }
+        const next = this.text + sequence;
+        if (REPORT.test(next)) {
+            const inserted = this.text;
+            this.reset();
+            return { report: next, inserted };
+        }
+        if (!PARTIAL.test(next)) {
+            this.reset();
+            return undefined;
+        }
+        this.text = next;
+        return undefined;
+    }
+    reset() {
+        this.text = '';
+        this.startedAt = 0;
+    }
+}
+/** A single-line input that drops a leaked mouse report instead of keeping it as text. */
+export class MouseSafeInput extends Input {
+    mouseTail = new MouseReportTail();
+    handleInput(data) {
+        super.handleInput(data);
+        const match = this.mouseTail.push(data);
+        if (!match)
+            return;
+        const value = this.getValue();
+        if (value.endsWith(match.report))
+            this.setValue(value.slice(0, -match.report.length));
+    }
+    setValue(value) {
+        this.mouseTail.reset();
+        super.setValue(value);
+    }
+}
+/**
+ * Removes reports from text that is about to be printed. A bare `<\d;\d;\d>M` stays: once recorded it
+ * is content, and rewriting it would misreport what a run received.
+ */
+export function stripMouseReports(text) {
+    return text.replace(SGR_REPORT, '').replace(X10_REPORT, '');
+}

package/dist/sdk/terminal/tui/pages/annotatePage.js

@@ -1,4 +1,5 @@
-import { Input, matchesKey, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { matchesKey, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
+import { MouseSafeInput } from "../mouseReport.js";
 import { FilterList } from "../list.js";
 import { normalizeAddress, normalizeDevTools } from "../annotateCommand.js";
 import { describeSend, sendUnsent, unsent } from "../annotateSend.js";
@@ -185,7 +186,7 @@ export class AnnotatePage {
         return 'Load the bridge script in the app (shown at the top), then reload the app.';
     }
     openField(kind) {
-        const input = new Input({ prompt: '', placeholder: FIELDS[kind].placeholder, placeholderStyle: text => this.options.theme().fg('dim', text) });
+        const input = new MouseSafeInput({ prompt: '', placeholder: FIELDS[kind].placeholder, placeholderStyle: text => this.options.theme().fg('dim', text) });
         this.field = { kind, input };
         this.syncFocus();
         this.options.changed();

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

@@ -52,7 +52,7 @@ export declare class BrowserPage implements TerminalPage {
     get focused(): boolean;
     set focused(value: boolean);
     tabs(): {
-        id: "skills" | "tools" | "connections" | "plugins" | "variant" | "library" | "overview" | "foundation";
+        id: "skills" | "tools" | "connections" | "plugins" | "variant" | "library" | "foundation" | "overview";
         title: string;
     }[];
     activeTab(): string;