@softov/ahpc 0.2.0 → 0.4.0

package/dist/src/app.js

@@ -3,19 +3,15 @@ import { createBag, defineComponent, useApp, useTheme, useStoreSubtree, useStore
 import { KeyHints, Row, registerBuiltins } from '@textui/widgets';
 import { CONTROLLER, createController } from './control.js';
 import { fakeHost } from './ahp/fake.js';
+import { hostResources } from './resources.js';
 import { BOOD, BOOD_FLOAT, BOOD_FLOOR, BOOD_INLINE, FOCUS, HOST, HOST_ERROR, INPUT, INPUT_STATUS, OPEN, RUNNING, SCREEN, SESSIONS, SPLIT_AT, SPLIT_DEFAULT, STATUS, WORKSPACE, boodFloor, openSession, workspaceName, } from './state.js';
 import { decodeStatus } from './ahp/status.js';
 import { AutomationsScreen, ChangesScreen, ChatScreen, FilesScreen, HostsScreen, McpScreen, NewAutomationScreen, NewSessionScreen, SessionsScreen, TerminalScreen, SettingsScreen, SkillsScreen, } from './screens.js';
-import { ChatBubble, ReasoningBlock, StreamingText } from './view/bubble.js';
-import { ChatComposer } from './view/composer.js';
-import { ChatHitl } from './view/hitl.js';
-import { ChatTranscript } from './view/transcript.js';
+import { ChatBubble, ChatComposer, ChatHitl, ChatTranscript, ConnectionBadge, ReasoningBlock, SEND_ID, SessionList, StreamingText, ToolCallRow, } from '@textui/chat';
 import { BoodSprite, Creature, moodOf, pickBood } from './view/creature.js';
 import { ChangesList } from './view/changes.js';
 import { FileList } from './view/files.js';
 import { AutomationList } from './view/automations.js';
-import { ConnectionBadge, SessionList } from './view/sessions.js';
-import { ToolCallRow } from './view/toolcall.js';
 /**
  * A chat client for an agent host.
  *
@@ -124,6 +120,7 @@ const Header = defineComponent('ChatHeader', () => {
  */
 const Hints = defineComponent('ChatHints', (props) => {
     const theme = useTheme();
+    const app = useApp();
     /**
      * Which key the footer names for a newline.
      *
@@ -153,8 +150,19 @@ const Hints = defineComponent('ChatHints', (props) => {
     // it, escape leaves the field; from the transcript, escape leaves the
     // screen - and a hint row that said one of those in both places is wrong
     // half the time.
-    const focused = useStoreValue(FOCUS, null);
+    const focused = useStoreValue(FOCUS, null) ?? null;
     const composing = focused === 'chat.composer';
+    // The control rows under the field are their own place: enter there opens
+    // a chip's panel or sends, and "alt+enter newline" is a key for a field
+    // the keyboard has left.
+    const onChip = focused !== null && focused.startsWith('chat.option.');
+    const onSend = focused === SEND_ID;
+    // A panel over the screen - a chip's picker, the palette - holds the
+    // keyboard, and the keys are the panel's until it closes. Read off the
+    // layers when the focus moves, which a panel that traps it does on the way
+    // in and on the way out; the layers themselves are not something a
+    // component can subscribe to.
+    const inPanel = app.layers.entries().some((entry) => entry.trapFocus === true);
     // A question is not a confirmation, and the keys are not the same either.
     // Offering "a approve" over an elicitation is the same mistake as rendering
     // one as the other, made in the one row that is supposed to explain it.
@@ -174,6 +182,22 @@ const Hints = defineComponent('ChatHints', (props) => {
                 { keys: 'esc', label: 'read' },
             ] }));
     }
+    if (inPanel) {
+        return (_jsx(KeyHints, { ...props, hints: [
+                { keys: upDown, label: 'move' },
+                { keys: 'enter', label: 'choose' },
+                { keys: 'esc', label: 'back' },
+                { keys: 'ctrl+c', label: running ? 'stop' : 'quit' },
+            ] }));
+    }
+    if ((screen === 'chat' || screen === 'new') && (onChip || onSend)) {
+        return (_jsx(KeyHints, { ...props, hints: [
+                { keys: 'enter', label: onSend ? (screen === 'new' ? 'start' : running ? 'queue' : 'send') : 'open' },
+                { keys: 'tab', label: 'next option' },
+                { keys: 'esc', label: 'write' },
+                { keys: 'ctrl+c', label: running ? 'stop' : 'quit' },
+            ] }));
+    }
     if (screen === 'chat') {
         return (_jsx(KeyHints, { ...props, hints: composing
                 ? [
@@ -293,6 +317,9 @@ export function registerChat(app, options = {}) {
     app.store.set(BOOD_FLOAT, options.boodFloat ?? false);
     bag.add(controller);
     bag.add(app.services.provide(CONTROLLER, controller));
+    // `file:` is the host's disk from here on, for the picker and anything
+    // else in textui that reads the resource registry.
+    bag.add(app.resources.registerProvider(hostResources(host)));
     for (const [component, render] of [
         ['ChatBubble', ChatBubble],
         ['StreamingText', StreamingText],

package/dist/src/blocks.d.ts

@@ -1,4 +1,7 @@
-import type { QueuedMessage, ToolCall, Turn } from './ahp/types.js';
+import type { Block } from '@textui/chat';
+import type { QueuedMessage, Turn } from './ahp/types.js';
+export type { Block } from '@textui/chat';
+export { selectable } from '@textui/chat';
 /**
  * A conversation, flattened into the rows a viewport scrolls.
  *
@@ -12,77 +15,4 @@ import type { QueuedMessage, ToolCall, Turn } from './ahp/types.js';
  * in one stream, and "let me search for those" means something before the
  * searches and nothing after them.
  */
-export type Block = {
-    kind: 'said';
-    id: string;
-    turnId: string;
-    text: string;
-} | {
-    kind: 'header';
-    id: string;
-    turnId: string;
-    model?: string;
-    /**
-     * What the turn was asked for besides the model, in the host's words.
-     *
-     * The values rather than the keys: `thinkingLevel` is one host's name for
-     * a property whose *answers* are what a person reads, and a header that
-     * spelled out the key would be twice as long and no clearer.
-     */
-    settings?: string;
-    meta: string;
-    state: Turn['state'];
-} | {
-    kind: 'prose';
-    id: string;
-    turnId: string;
-    content: string;
-    streaming: boolean;
-} | {
-    kind: 'reasoning';
-    id: string;
-    turnId: string;
-    content: string;
-    streaming: boolean;
-} | {
-    kind: 'notice';
-    id: string;
-    turnId: string;
-    content: string;
-} | {
-    kind: 'failure';
-    id: string;
-    turnId: string;
-    content: string;
-    resumable: boolean;
-} | {
-    kind: 'tool';
-    id: string;
-    turnId: string;
-    call: ToolCall;
-} | {
-    kind: 'queued';
-    id: string;
-    messageId: string;
-    text: string;
-};
-/**
- * Everything in a block that a person could be looking for.
- *
- * A tool call is its name, its command and what came back, because all three
- * are things somebody searches a transcript for - the file a command touched
- * is in the output and nowhere else. A header is the model and the settings,
- * which is how "where did I switch to opus" is answered.
- */
-export declare function blockText(block: Block): string;
-/**
- * Where in the conversation a query appears, as block indices in order.
- *
- * Case-insensitive, and a blank query matches nothing rather than everything:
- * a find with no term is a find that has not been typed yet, and lighting up
- * every block for it is the opposite of what the box is for.
- */
-export declare function findBlocks(blocks: Block[], query: string): number[];
-/** Blocks the cursor stops on: the ones that do something when activated. */
-export declare function selectable(block: Block): boolean;
 export declare function toBlocks(turns: Turn[], queued?: QueuedMessage[]): Block[];

package/dist/src/blocks.js

@@ -1,55 +1,17 @@
+export { selectable } from '@textui/chat';
 /**
- * Everything in a block that a person could be looking for.
+ * A conversation, flattened into the rows a viewport scrolls.
  *
- * A tool call is its name, its command and what came back, because all three
- * are things somebody searches a transcript for - the file a command touched
- * is in the output and nowhere else. A header is the model and the settings,
- * which is how "where did I switch to opus" is answered.
- */
-export function blockText(block) {
-    switch (block.kind) {
-        case 'said':
-        case 'queued':
-            return block.text;
-        case 'prose':
-        case 'reasoning':
-        case 'notice':
-        case 'failure':
-            return block.content;
-        case 'header':
-            return [block.model, block.settings, block.meta].filter(Boolean).join(' ');
-        case 'tool':
-            return [
-                block.call.name, block.call.toolName, block.call.input,
-                block.call.intention, block.call.outcome, block.call.output,
-                ...(block.call.files ?? []),
-            ].filter(Boolean).join(' ');
-    }
-}
-/**
- * Where in the conversation a query appears, as block indices in order.
+ * A turn is not a box. It is a run of rows - a header, some prose, a tool
+ * call, more prose - and the transcript has to be able to put its cursor on
+ * one of them, measure it, and scroll to it. Nesting each turn inside a
+ * container would mean the transcript could only ever scroll to a whole turn,
+ * and a turn can be four hundred rows long.
  *
- * Case-insensitive, and a blank query matches nothing rather than everything:
- * a find with no term is a find that has not been typed yet, and lighting up
- * every block for it is the opposite of what the box is for.
+ * The order is the host's order. `responseParts` interleaves prose and calls
+ * in one stream, and "let me search for those" means something before the
+ * searches and nothing after them.
  */
-export function findBlocks(blocks, query) {
-    const needle = query.trim().toLowerCase();
-    if (needle === '')
-        return [];
-    const found = [];
-    blocks.forEach((block, index) => {
-        if (blockText(block).toLowerCase().includes(needle))
-            found.push(index);
-    });
-    return found;
-}
-/** Blocks the cursor stops on: the ones that do something when activated. */
-export function selectable(block) {
-    // A queued message among them, because taking one back is something you do
-    // to it - and the cursor is how anything in the transcript is reached.
-    return block.kind === 'tool' || block.kind === 'reasoning' || block.kind === 'queued';
-}
 export function toBlocks(turns, queued = []) {
     const blocks = [];
     for (const turn of turns) {

package/dist/src/cli/main.d.ts

@@ -1,5 +1,5 @@
 /** Every command, and the argv reading that picks one. */
-export declare const HELP = "ahpc - drive an agent host from a shell\n\n  ahpc [--host ws://\u2026] <command> [args]        the screen is 'ahpc' with no command\n\nSessions\n  session list                 the catalogue, newest first   [--archived] [--json]\n  session show <uri>           what the host says about one  [--full] [--json]\n  session new                  start one   [--agent P] [--cwd DIR] [--set k=v]\u2026 [--json]\n  session rm <uri>             dispose it\n  session history <uri>        its turns               [--all] [--full] [--json]\n  session config <uri>         the schema and what is in force        [--json]\n  session set <uri> <k> <v>    change one config key\n  session read <uri>           mark read                     [--unread]\n  session archive <uri>        put it away                   [--undo]\n  session customizations <uri> skills, prompts, agents, servers        [--json]\n  session export <uri>         the whole session as one document\n                               [--json] [--markdown]\n  session toggle <uri> <id>    turn one on                   [--off]\n\nTurns\n  prompt <uri> <text>          say it and stream the answer  [--model M] [--json]\n  exec <text>                  a session, one turn, and dispose it\n                                       [--agent P] [--cwd DIR] [--model M] [--json]\n  cancel <uri>                 stop the running turn\n  queue <uri> <text>           say it after the one running  [--model M]\n  unqueue <uri> <id>           take it back\n\nAnswering\n  watch <uri>                  BLOCK until something wants a person, print, exit\n                                       [--until turn|input|idle] [--timeout S] [--json]\n  confirm <uri> <toolCallId>   approve a tool call           [--deny] [--option ID]\n  answer <uri> <requestId>     answer a question      [--field k=v]\u2026 [--reject]\n\nChats\n  chat list <uri>              the conversations in a session         [--json]\n  chat new <uri> [text]        another one beside it\n  chat rm <chatUri>            close one\n\nThe harness\n  agents                       what it serves, and each one's models  [--json]\n  models                       every model, by harness                [--json]\n  commands                     what a slash offers                    [--json]\n  customizations               skills, prompts, agents and MCP servers,\n                               before any session exists     [--kind k] [--json]\n  completions <uri> <text>     what the host would complete  [--offset N] [--json]\n\nChanges and files\n  changes <uri>                the files a session touched            [--json]\n                               [--list] [--scope s] [--<variable> v]\n                               [--reviewed f] [--unreviewed f]\n                               [--operations]           what may be done to it\n                               [--run id] [--file f] [--yes]      do one of them\n                               [--list] every changeset it offers\n                               [--scope <name>] one of them, e.g. turn\n                               [--turnId <id>] what a chosen scope still needs\n                               [--reviewed <file>] tick one off, repeatable\n                               [--unreviewed <file>] and clear one\n  content <uri> <file>         one of them, in full\n  resource list <uri>          a directory the host serves            [--json]\n  resource read <uri>          a file on the host\n  resource stat <uri>          what it is, without reading it         [--json]\n  resource write <uri> [file]  from a file, or from stdin      [--create-only]\n                               guarded by the file's etag unless      [--force]\n  resource rm <uri>            delete it                        [--recursive]\n  resource mkdir <uri>         make a directory\n  resource mv <uri> <to>       move it                     [--fail-if-exists]\n  resource cp <uri> <to>       copy it                     [--fail-if-exists]\n\nAutomations\n  automation list              what runs on its own                   [--json]\n  automation show <uri>        one of them                            [--json]\n  automation triggers          what this host can trigger on          [--json]\n  automation runs <uri>        its history, every page                [--json]\n  automation run <uri>         start it now\n  automation enable <uri>      switch it on\n  automation disable <uri>     switch it off\n  automation rm <uri>          forget it\n\nThe host's own log\n  logs                         what the daemon is saying  [--level L] [--follow]\n\nSigning in\n  auth                         what this host protects                [--json]\n  auth <resource>              push a token   [--token T] [--expires-in S]\n                               or set AHPC_TOKEN_<RESOURCE>, or pipe one in\n\nTerminals\n  terminal list                what is running                        [--json]\n  terminal new                 open a shell        [--cwd DIR] [--name N]\n  terminal rm <uri>            kill it\n  terminal send <uri> <text>   type into it\n  terminal watch <uri>         follow its output   [--timeout S]\n\nRecording\n  AHPC_RECORD=<file>           append every frame, both directions, for\n                               'npm run wire' to check against the protocol\n\nServing these sessions to something else\n  mcp                          MCP on stdin and stdout, for a client that\n                               launches this process\n  serve                        the same tools on a socket, shared\n                               [--serve-host H] [--serve-port N] [--serve-token T]\n                               /mcp is MCP; /api/<tool> is plain JSON\n\nAnything else\n  dispatch <uri> <type>        send one action verbatim  [--field k=v]\u2026 [--chat]\n  status                       what this client is connected to       [--json]\n  help                         this\n\nThe host\n  --host <url>    ws://host:port, or AHPC_HOST, or the config file\n  --token <tkn>   a bearer token for it, or AHPC_TOKEN, or the config file\n  --config-file   read this instead of the one below\n  (none)          the scripted host, which needs nothing installed\n\nConfiguration\n  config          where the file is, and what is in force  [--json]\n\nOutput is for reading. --json is the same answer for a program.\n";
+export declare const HELP = "ahpc - drive an agent host from a shell\n\n  ahpc [--host ws://\u2026] <command> [args]        the screen is 'ahpc' with no command\n\nSessions\n  session list                 the catalogue, newest first   [--archived] [--json]\n  session show <uri>           what the host says about one  [--full] [--json]\n  session new                  start one   [--agent P] [--cwd DIR] [--set k=v]\u2026 [--json]\n  session rm <uri>             dispose it\n  session history <uri>        its turns               [--all] [--full] [--json]\n  session config <uri>         the schema and what is in force        [--json]\n  session set <uri> <k> <v>    change one config key\n  session read <uri>           mark read                     [--unread]\n  session archive <uri>        put it away                   [--undo]\n  session customizations <uri> skills, prompts, agents, servers        [--json]\n  session export <uri>         the whole session as one document\n                               [--json] [--markdown]\n  session toggle <uri> <id>    turn one on                   [--off]\n\nTurns\n  prompt <uri> <text>          say it and stream the answer  [--model M] [--json]\n  exec <text>                  a session, one turn, and dispose it\n                                       [--agent P] [--cwd DIR] [--model M] [--json]\n  cancel <uri>                 stop the running turn\n  queue <uri> <text>           say it after the one running  [--model M]\n  unqueue <uri> <id>           take it back\n\nAnswering\n  watch <uri>                  BLOCK until something wants a person, print, exit\n                                       [--until turn|input|idle] [--timeout S] [--json]\n  confirm <uri> <toolCallId>   approve a tool call           [--deny] [--option ID]\n  answer <uri> <requestId>     answer a question      [--field k=v]\u2026 [--reject]\n\nChats\n  chat list <uri>              the conversations in a session         [--json]\n  chat new <uri> [text]        another one beside it\n  chat rm <chatUri>            close one\n\nThe harness\n  agents                       what it serves, and each one's models  [--json]\n  models                       every model, by harness                [--json]\n  commands                     what a slash offers                    [--json]\n  customizations               skills, prompts, agents and MCP servers,\n                               before any session exists     [--kind k] [--json]\n  completions <uri> <text>     what the host would complete  [--offset N] [--json]\n\nChanges and files\n  changes <uri>                the files a session touched            [--json]\n                               [--list] [--scope s] [--<variable> v]\n                               [--reviewed f] [--unreviewed f]\n                               [--operations]           what may be done to it\n                               [--run id] [--file f] [--yes]      do one of them\n                               [--list] every changeset it offers\n                               [--scope <name>] one of them, e.g. turn\n                               [--turnId <id>] what a chosen scope still needs\n                               [--reviewed <file>] tick one off, repeatable\n                               [--unreviewed <file>] and clear one\n  content <uri> <file>         one of them, in full\n  resource list <uri>          a directory the host serves            [--json]\n  resource read <uri>          a file on the host\n  resource stat <uri>          what it is, without reading it         [--json]\n  resource write <uri> [file]  from a file, or from stdin      [--create-only]\n                               guarded by the file's etag unless      [--force]\n  resource rm <uri>            delete it                        [--recursive]\n  resource mkdir <uri>         make a directory\n  resource mv <uri> <to>       move it                     [--fail-if-exists]\n  resource cp <uri> <to>       copy it                     [--fail-if-exists]\n\nAutomations\n  automation list              what runs on its own                   [--json]\n  automation show <uri>        one of them                            [--json]\n  automation triggers          what this host can trigger on          [--json]\n  automation runs <uri>        its history, every page                [--json]\n  automation run <uri>         start it now\n  automation enable <uri>      switch it on\n  automation disable <uri>     switch it off\n  automation rm <uri>          forget it\n\nThe host's own log\n  logs                         what the daemon is saying  [--level L] [--follow]\n\nSigning in\n  auth                         what this host protects                [--json]\n  auth <resource>              push a token   [--token T] [--expires-in S]\n                               or set AHPC_TOKEN_<RESOURCE>, or pipe one in\n\nTerminals\n  terminal list                what is running                        [--json]\n  terminal new                 open a shell        [--cwd DIR] [--name N]\n  terminal rm <uri>            kill it\n  terminal send <uri> <text>   type into it\n  terminal watch <uri>         follow its output   [--timeout S]\n\nRecording\n  --wire <file>                append every frame, both directions, as JSON\n                               lines: { at, from, peer, frame }, for\n                               'npm run wire' to check against the protocol.\n                               AHPC_RECORD=<file> is the same, from a shell\n  wire <file>                  watch a capture as it is written, from either\n                               end: one row per frame, a row opens to the\n                               frame. Off a terminal, one line per frame\n                               [--follow] [--filter text] [--json]\n\nServing these sessions to something else\n  mcp                          MCP on stdin and stdout, for a client that\n                               launches this process\n  serve                        the same tools on a socket, shared\n                               [--serve-host H] [--serve-port N] [--serve-token T]\n                               [--serve-origin URL]\u2026 a browser page allowed in\n                               /mcp is MCP; /api/<tool> is plain JSON\n  both take [--mcp-tools G,\u2026]  extra tool groups to serve, on top of the\n                               sessions ones: resources, terminals,\n                               automations, changes\n\nAnything else\n  dispatch <uri> <type>        send one action verbatim  [--field k=v]\u2026 [--chat]\n  <uri>, anywhere above        a session URI, or the agent-host-session://\n                               link the host's session tools answer with\n  status                       what this client is connected to       [--json]\n  --version                    what version this is\n  help                         this\n\nThe host\n  --host <url>    ws://host:port, or AHPC_HOST, or the config file\n  --token <tkn>   a bearer token for it, or AHPC_TOKEN, or the config file\n  --config-file   read this instead of the one below\n  (none)          the scripted host, which needs nothing installed\n\nConfiguration\n  config          where the file is, and what is in force  [--json]\n\nOutput is for reading. --json is the same answer for a program.\n";
 /** A message for the person, not a stack trace. */
 export declare class Fault extends Error {
 }

package/dist/src/cli/main.js

@@ -5,8 +5,9 @@ import { configPath, loadConfig } from '../config.js';
 import { ago, archived, branch, json, line, mark, project, table } from './render.js';
 import { operate } from '../ahp/operate.js';
 import { SWITCHES } from '../flags.js';
+import { parseSessionLink, sessionOfLink } from '../links.js';
 import { spoken, turn as runTurn, until } from '../wait.js';
-import { TOOLS } from '../mcp/tools.js';
+import { GROUPS, served } from '../mcp/tools.js';
 import { SERVER } from '../mcp/serve.js';
 import { stdio } from '../mcp/stdio.js';
 import { serve as serveHttp } from '../mcp/http.js';
@@ -104,19 +105,32 @@ Terminals
   terminal watch <uri>         follow its output   [--timeout S]
 
 Recording
-  AHPC_RECORD=<file>           append every frame, both directions, for
-                               'npm run wire' to check against the protocol
+  --wire <file>                append every frame, both directions, as JSON
+                               lines: { at, from, peer, frame }, for
+                               'npm run wire' to check against the protocol.
+                               AHPC_RECORD=<file> is the same, from a shell
+  wire <file>                  watch a capture as it is written, from either
+                               end: one row per frame, a row opens to the
+                               frame. Off a terminal, one line per frame
+                               [--follow] [--filter text] [--json]
 
 Serving these sessions to something else
   mcp                          MCP on stdin and stdout, for a client that
                                launches this process
   serve                        the same tools on a socket, shared
                                [--serve-host H] [--serve-port N] [--serve-token T]
+                               [--serve-origin URL]… a browser page allowed in
                                /mcp is MCP; /api/<tool> is plain JSON
+  both take [--mcp-tools G,…]  extra tool groups to serve, on top of the
+                               sessions ones: resources, terminals,
+                               automations, changes
 
 Anything else
   dispatch <uri> <type>        send one action verbatim  [--field k=v]… [--chat]
+  <uri>, anywhere above        a session URI, or the agent-host-session://
+                               link the host's session tools answer with
   status                       what this client is connected to       [--json]
+  --version                    what version this is
   help                         this
 
 The host
@@ -142,6 +156,24 @@ class Args {
     constructor(rest) {
         this.rest = rest;
     }
+    /** Every positional that is a link, replaced by what it names. */
+    async resolveLinks(resolve) {
+        const next = [...this.rest];
+        for (let i = 0; i < next.length; i++) {
+            const word = next[i];
+            if (word.startsWith('--')) {
+                if (!SWITCHES.has(word))
+                    i++;
+                continue;
+            }
+            if (!/^agent-host-session:\/\//i.test(word))
+                continue;
+            const found = await resolve(word);
+            if (found !== undefined)
+                next[i] = found;
+        }
+        this.rest = next;
+    }
     /** The nth thing that is not a flag or a flag's value. */
     positional(index) {
         const found = [];
@@ -204,6 +236,7 @@ const where = (args) => {
         // write into it. Both off unless asked for.
         ...(args.value('--publish') ? { publish: args.value('--publish') } : {}),
         ...(args.has('--publish-writable') ? { publishWritable: true } : {}),
+        ...(args.value('--wire') ? { wire: args.value('--wire') } : {}),
     };
 };
 /** A URI the command needs, said plainly when it is missing. */
@@ -309,8 +342,53 @@ export async function cli(command, rest) {
             table(rows);
         return 0;
     }
+    /*
+     * A capture is a file, not a host.
+     *
+     * `ahpc wire out.jsonl` reads what `--wire` wrote - here or on the host -
+     * and needs no connection to do it; needing one would make it useless on
+     * exactly the capture of a host that would not answer.
+     */
+    if (command === 'wire') {
+        const file = args.positional(0);
+        if (file === undefined)
+            throw new Fault('wire wants a file: ahpc wire <file>');
+        const settings = loadConfig('ahpc', args.value('--config-file'));
+        const { wireTui } = await import('../wiretui.js');
+        const theme = args.value('--theme') ?? settings.theme;
+        const shell = args.value('--shell') ?? settings.shell;
+        const filter = args.value('--filter');
+        await wireTui({
+            file,
+            follow: args.has('--follow'),
+            json: wants,
+            ...(filter === undefined ? {} : { filter }),
+            ...(theme === undefined ? {} : { theme }),
+            ...(shell === undefined ? {} : { shell }),
+        });
+        return 0;
+    }
     const host = await connect(where(args));
     try {
+        /*
+         * A link where a URI is wanted.
+         *
+         * The reference host's session tools answer with `agent-host-session://`
+         * links, and a person pasting one into `session show` should get the
+         * session it names rather than a refusal about the scheme. Resolved once,
+         * against the catalogue, before any command reads its arguments; a link
+         * nobody on this host answers to is a sentence rather than a lookup that
+         * silently found nothing.
+         */
+        await args.resolveLinks(async (link) => {
+            const parsed = parseSessionLink(link);
+            if (parsed === undefined)
+                return undefined;
+            const row = sessionOfLink(parsed, await host.listSessions());
+            if (row === undefined)
+                throw new Fault(`No session on this host matches ${link}.`);
+            return row.resource;
+        });
         switch (command) {
             case 'status': {
                 const rows = await host.listSessions().catch(() => []);
@@ -331,22 +409,27 @@ export async function cli(command, rest) {
              * `/api/<tool>` for anything that is not an MCP client.
              */
             case 'mcp': {
+                const groups = wanted(args);
                 // Nothing but JSON-RPC on stdout, ever: a stray line here is a parse
                 // error at the other end of a pipe nobody can see.
-                process.stderr.write(`ahpc mcp on ${host.url || '(scripted host)'}, ${TOOLS.length} tools\n`);
-                await stdio(host, { ...SERVER, onProblem: (said) => process.stderr.write(`${said}\n`) });
+                process.stderr.write(`ahpc mcp on ${host.url || '(scripted host)'}, ${served(groups).length} tools\n`);
+                await stdio(host, { ...SERVER, groups, onProblem: (said) => process.stderr.write(`${said}\n`) });
                 return 0;
             }
             case 'serve': {
+                const groups = wanted(args);
                 const at = await serveHttp(host, {
                     ...SERVER,
+                    groups,
                     host: args.value('--serve-host') ?? '127.0.0.1',
                     port: Number(args.value('--serve-port') ?? 7431),
                     ...(args.value('--serve-token') === undefined ? {} : { token: args.value('--serve-token') }),
+                    // Repeatable, because a page and its API are often two origins.
+                    origins: args.every('--serve-origin'),
                     onProblem: (said) => process.stderr.write(`${said}\n`),
                 });
                 line(`ahpc on http://${at.host}:${at.port} against ${host.url || '(scripted host)'}`);
-                line(`  /mcp        MCP, ${TOOLS.length} tools`);
+                line(`  /mcp        MCP, ${served(groups).length} tools`);
                 line('  /api/<tool> the same tools as plain JSON');
                 if (args.value('--serve-token') === undefined && at.host !== '127.0.0.1' && at.host !== '::1') {
                     // Said rather than refused: binding wide open is a decision somebody
@@ -997,6 +1080,26 @@ async function chats(host, args, wants) {
     }
     throw new Fault(`No 'chat ${verb}'. Try 'ahpc help'.`);
 }
+/**
+ * The tool groups `--mcp-tools` asked for.
+ *
+ * Comma-separated and repeatable, because both are what people type. Named
+ * `--mcp-tools` and not `--tools`: every other flag on this client is an AHP
+ * thing, and a bare `--tools` reads like one - it would look like it was
+ * choosing which tools the *agent* may call, which is a different question
+ * with a different answer.
+ */
+function wanted(args) {
+    const said = args.every('--mcp-tools')
+        .flatMap((one) => one.split(','))
+        .map((one) => one.trim())
+        .filter((one) => one !== '');
+    const strange = said.filter((one) => !GROUPS.includes(one));
+    if (strange.length > 0) {
+        throw new Fault(`No tool group called ${strange.join(', ')}. There is ${GROUPS.join(', ')}.`);
+    }
+    return said;
+}
 /** Everything under `terminal`. */
 async function shells(host, args, wants) {
     const verb = args.positional(0) ?? 'list';

package/dist/src/connect.d.ts

@@ -29,6 +29,8 @@ export interface Where {
     publish?: string;
     /** Whether the published directory may be written to. Read-only otherwise. */
     publishWritable?: boolean;
+    /** A file every frame is appended to, both directions, as JSON lines. */
+    wire?: string;
 }
 /**
  * Where a refusal goes before there is an application to put it in.

package/dist/src/connect.js

@@ -27,6 +27,7 @@ export async function connect(options) {
         return await liveHost({
             url: options.host,
             ...(options.token ? { token: options.token } : {}),
+            ...(options.wire ? { wire: options.wire } : {}),
             onRefusal: (_uri, message) => sink.report(message),
             onLimit: (message) => sink.report(message),
             // Work the host is doing under a token of its own. Reported while it

package/dist/src/control.d.ts

@@ -17,6 +17,12 @@ import type { Agent, Answer, Automation, Changeset, ChangesetScope, ChatSource,
 export interface Controller {
     refresh(): Promise<void>;
     open(uri: SessionUri): void;
+    /**
+     * Open what an `agent-host-session://` link names: the session, and the
+     * chat in it when the link says one. False when this host has no such
+     * session, said out loud as well.
+     */
+    openLink(link: string): Promise<boolean>;
     close(): void;
     /** Send, or queue when a turn is already running. */
     send(text: string): void;