@plurnk/plurnk 0.74.0 → 0.76.0

package/dist/tui.js

@@ -19,12 +19,16 @@ import { isAbsolute, resolve } from "node:path";
 import PasteFilter from "./paste.js";
 import { extractOpenPaths } from "./openpaths.js";
 import { pathPartial, completePath, dslOpPartial, completeOps, dslStatement } from "./completion.js";
-import { renderLogEntry, renderSummary, isPromptEntry, coordLabel, progressLabel, entryTarget, isEntryMaterialization } from "./render.js";
-import { renderProposalMenu, keyToResolution, isServerResolved, questionFromProposal, renderQuestionMenu, answerForLine } from "./proposal.js";
+import { renderLogEntry, renderReasoning, renderReasoningPreview, renderSummary, isPromptEntry, progressLabel, entryTarget, isEntryMaterialization } from "./render.js";
+import { renderProposalMenu, keyToResolution, isServerResolved, renderQuestionMenu, questionChoices, answerForQuestion, editInEditor } from "./proposal.js";
 import { ProblemError, renderDiagnostic, report, clientSubcommandUnknownVerb, NO_MODEL_HINT } from "./diagnostics.js";
 import StreamTrace, { inlineable, renderInline } from "./stream.js";
 import { runModels, runWorkspaceList, runWorkspaceWorkers, runLogRead } from "./subcommands.js";
+import { Validator, } from "@plurnk/plurnk-contracts";
 import { handleMcp } from "./mcp.js";
+import { handleSkills } from "./skills.js";
+import { handleAgents } from "./agents.js";
+import { formatWorkerReasoning, readWorkerReasoning, setWorkerReasoning, } from "./reasoning.js";
 export const renderTuiFailure = (cause) => {
     if (cause instanceof ProblemError) {
         return renderDiagnostic(cause.problem)
@@ -39,14 +43,15 @@ export const renderTuiFailure = (cause) => {
 // ambiguous (workspace or worker?) and is gone. /rename retargets the current
 // workspace's mutable handle (a worker's name is immutable — no /rename for workers).
 export const VERBS = [
-    "help", "models", "workspaces", "workers", "log", "model", "child",
+    "help", "models", "workspaces", "workers", "log", "model", "child", "reasoning",
     "yolo", "workspace", "rename", "worker", "stop", "quit",
-    "pick", "hide", "view", "drop", "members", "import", "script", "mcp",
+    "pick", "hide", "view", "drop", "members", "import", "script", "mcp", "editor",
     "accept", "reject", "cancel", "edit",
 ];
 export const TUI_HELP = [
-    "  /models /workspaces /workers /log [n]   inspect",
-    "  /model <alias> · /child <alias|inherit>   parent and child models",
+    "  /models [search] /workspaces /workers /log [n]   inspect",
+    "  /model <selector> · /child <selector|inherit>   parent and child models",
+    "  /reasoning [off|adaptive|effort]       inspect or set reasoning",
     "  /yolo                              toggle local auto-accept",
     "  /workspace [name]                    new workspace",
     "  /rename <name>                     rename this workspace (a mutable handle)",
@@ -58,8 +63,13 @@ export const TUI_HELP = [
     "  /members                           the model's resolved file universe (+ rules)",
     "  /import <path>                     dump a local file's content into the prompt",
     "  /script <path>                     run a .plk file (its DSL → op.parse)",
-    "  /mcp [definition.json]             list or attach workspace MCP servers",
-    "       replace <file> · detach/reconnect <name> · oauth <name> <callback-url>",
+    "  /mcp                              list available workspace MCP servers",
+    "       add <alias> <target> [options.json] · enable/disable/remove <alias>",
+    "       oauth <alias> <callback-url>",
+    "  /agents                           list this Worker's outbound A2A agents",
+    "       discover <url> · add <alias> <url> [options.json] · enable/disable/remove <alias>",
+    "  /skills                           list this Worker's Agent Skills",
+    "       discover <query|source> · add <name> <source> [--global] · enable/disable/remove <name>",
     "  /accept /reject /cancel /edit      resolve a pending proposal (or keys a/e/r/c)",
     "  /stop                              cancel the running loop",
     "  /quit                              exit",
@@ -67,6 +77,8 @@ export const TUI_HELP = [
     "  ## LOOK0 (uri)                    off-run READ — inspect a uri for you, not the model",
     "  Alt-p / Alt-n                     cycle ## LOOK0 through prior operations' targets",
     "  Ctrl-J / Alt-Enter                 insert a ↵ newline (editable); Enter submits",
+    "  Esc                               cancel the running loop; idle: clear the line",
+    "  /editor · Alt-e                    compose the prompt line in $EDITOR",
     "  Alt-m/s · Alt-R/L/Y/N/M · Alt-x    quick verbs (nvim case): models workspaces runs",
     "                                     log yolo workspace members stop · Alt-h help",
 ].join("\n") + "\n";
@@ -93,7 +105,7 @@ export const expandNewlines = (line) => line.replaceAll(NL_MARK, "\n");
 // owns a/e/n/p/u/w/k/l. Alt-b/f/d are skipped (readline word-ops).
 export const ALT_SHORTCUTS = Object.freeze({
     m: "/models", s: "/workspaces", R: "/workers", L: "/log",
-    Y: "/yolo", N: "/workspace", M: "/members", x: "/stop", h: "/help",
+    Y: "/yolo", N: "/workspace", M: "/members", x: "/stop", h: "/help", e: "/editor",
 });
 // An Alt-<letter> keypress (ESC then a single letter, no `[`/`O` → not an arrow
 // or function key) mapped to its verb, or null. Case-sensitive (mirrors nvim).
@@ -140,8 +152,11 @@ export const parseSlash = (line) => {
 // Plain readline machinery only; no screen takeover, no terminal hell.
 // readline's async completer form (arity 2 → async). Verb/alias completion
 // answers synchronously; path positions read the local fs (co-location law)
-// and answer once readdir resolves.
-export const makeCompleter = (getAliases, cwd) => (line, callback) => {
+// and answer once readdir resolves. A fragment holding a provider prefix
+// (`/model openai/…`) completes lazily from one bounded, provider-scoped
+// daemon catalog page ([§cli-plurnk-models]); the client never preloads or
+// owns the Models.dev snapshot.
+export const makeCompleter = (getAliases, cwd, getReasoningPolicies = () => [], getProviderModels = async () => []) => (line, callback) => {
     const verbFrag = line.match(/^\/(\w*)$/);
     if (verbFrag) {
         callback(null, [VERBS.map((v) => `/${v}`).filter((v) => v.startsWith(line)), line]);
@@ -149,18 +164,48 @@ export const makeCompleter = (getAliases, cwd) => (line, callback) => {
     }
     const aliasFrag = line.match(/^\/(model|child)\s+(\S*)$/);
     if (aliasFrag) {
+        const fragment = aliasFrag[2];
+        const provider = /^([A-Za-z0-9_-]+)\//.exec(fragment)?.[1];
+        if (provider !== undefined) {
+            getProviderModels(provider).then((selectors) => callback(null, [selectors.filter((selector) => selector.startsWith(fragment)), fragment]), () => callback(null, [[], fragment]));
+            return;
+        }
         const candidates = aliasFrag[1] === "child"
             ? ["inherit", ...getAliases().filter((alias) => alias !== "inherit")]
             : getAliases();
-        callback(null, [candidates.filter((a) => a.startsWith(aliasFrag[2])), aliasFrag[2]]);
+        callback(null, [candidates.filter((a) => a.startsWith(fragment)), fragment]);
+        return;
+    }
+    const reasoningFrag = line.match(/^\/reasoning\s+(\S*)$/);
+    if (reasoningFrag) {
+        callback(null, [
+            getReasoningPolicies().filter((policy) => policy.startsWith(reasoningFrag[1])),
+            reasoningFrag[1],
+        ]);
         return;
     }
     const mcpFrag = line.match(/^\/mcp\s+(\S*)$/);
     if (mcpFrag) {
         const fragment = mcpFrag[1];
-        const commands = ["replace", "detach", "reconnect", "oauth"]
+        const commands = ["add", "enable", "disable", "remove", "oauth"]
             .filter((command) => command.startsWith(fragment));
-        void completePath(fragment, cwd).then(([paths]) => callback(null, [[...commands, ...paths], fragment]));
+        callback(null, [commands, fragment]);
+        return;
+    }
+    const agentsFrag = line.match(/^\/agents\s+(\S*)$/);
+    if (agentsFrag) {
+        const fragment = agentsFrag[1];
+        const commands = ["add", "discover", "enable", "disable", "remove"]
+            .filter((command) => command.startsWith(fragment));
+        callback(null, [commands, fragment]);
+        return;
+    }
+    const skillsFrag = line.match(/^\/skills\s+(\S*)$/);
+    if (skillsFrag) {
+        const fragment = skillsFrag[1];
+        const commands = ["add", "discover", "enable", "disable", "remove"]
+            .filter((command) => command.startsWith(fragment));
+        callback(null, [commands, fragment]);
         return;
     }
     const op = dslOpPartial(line);
@@ -190,26 +235,50 @@ export const seedPromptHistory = async (rpc, workspaceId, rl) => {
     catch { /* history is a convenience; never block the REPL */ }
 };
 // The one-line startup banner: version · workspace [· worker] · model · help. Pure so the
-// model-label resolution is unit-testable. modelLabel = the client's
-// --model/PLURNK_MODEL when set, else the daemon's active default
+// model-label resolution is unit-testable. modelLabel = the client's explicit
+// --model selector when set, else the daemon's active default
 // (providers.list `active`), else an honest fallback.
 export const buildHeader = (opts) => {
     const head = opts.versionNotice ?? "plurnk";
     const worker = opts.workerName !== undefined ? ` · worker: ${opts.workerName}` : "";
-    const modelLabel = opts.modelAlias ?? opts.activeAlias ?? "(daemon default)";
+    const modelLabel = opts.modelSelector ?? opts.activeAlias ?? "(daemon default)";
+    const reasoning = opts.reasoningPolicy === undefined || opts.reasoningPolicy === null
+        ? ""
+        : ` · reasoning: ${opts.reasoningPolicy}`;
     const yolo = opts.yolo ? " · yolo: on" : "";
-    return `${head} · workspace: ${opts.workspaceName}${worker} · model: ${modelLabel}${yolo} · /help`;
+    return `${head} · workspace: ${opts.workspaceName}${worker} · model: ${modelLabel}${reasoning}${yolo} · /help`;
 };
+const modelRouteOrNull = (value) => value === null ? null : Validator.assertModelRoute(value);
+const workerModelProjection = (value) => {
+    if (value === null || typeof value !== "object") {
+        throw new TypeError("worker.model.get returned no model projection");
+    }
+    const projection = value;
+    return {
+        model: modelRouteOrNull(projection.model),
+        spawnModel: modelRouteOrNull(projection.spawnModel),
+    };
+};
+export const resolvedModelLabel = (spec) => spec.alias ?? `${spec.provider}/${spec.model}`;
 export const handleVerb = async (line, ctx) => {
     const { verb, rest } = parseSlash(line);
     const { rpc, opts, write } = ctx;
+    const refreshWorkerPolicy = async () => {
+        const model = workerModelProjection(await rpc.call("worker.model.get"));
+        ctx.setModel(model.model);
+        ctx.setSpawnModel(model.spawnModel);
+        ctx.setReasoning(await readWorkerReasoning(rpc));
+    };
     switch (verb) {
         case "":
         case "help":
             write(TUI_HELP);
             return;
         case "models":
-            await runModels(rpc, { json: false });
+            await runModels(rpc, {
+                json: false,
+                query: rest.length === 0 ? {} : { search: rest },
+            });
             return;
         case "workspaces":
             await runWorkspaceList(rpc, { json: false });
@@ -225,30 +294,53 @@ export const handleVerb = async (line, ctx) => {
         }
         case "model":
             if (rest.length === 0) {
-                write(`  model: ${opts.modelAlias ?? "(daemon default)"}\n`);
+                write(`  model: ${ctx.model === null ? "(daemon default)" : resolvedModelLabel(ctx.model)}\n`);
+                return;
+            }
+            // {§worker-model-selection} — /model is a server-backed durable selection:
+            // the daemon resolves and persists onto the conversation worker; nothing
+            // client-local rides the next loop.
+            try {
+                ctx.setModel(Validator.assertModelRoute(await rpc.call("worker.model.set", { selector: rest })));
+                write(`  model: ${rest}\n`);
+            }
+            catch (cause) {
+                write(`  model set failed: ${cause instanceof Error ? cause.message : String(cause)}\n`);
                 return;
             }
-            opts.modelAlias = rest;
-            // Retarget ROUTING too, not just the label: without this the next loop
-            // keeps sending the BOOT model's resolved spec (which the daemon prefers
-            // over the alias, #90) — the switch would be cosmetic.
-            opts.model = ctx.resolveModel?.(rest);
-            write(`  model: ${rest}\n`);
+            try {
+                ctx.setReasoning(await readWorkerReasoning(rpc));
+            }
+            catch (cause) {
+                write(`  reasoning refresh failed: ${cause instanceof Error ? cause.message : String(cause)}\n`);
+            }
+            return;
+        case "reasoning":
+            try {
+                const reasoning = rest.length === 0
+                    ? await readWorkerReasoning(rpc)
+                    : await setWorkerReasoning(rpc, rest);
+                ctx.setReasoning(reasoning);
+                write(`${formatWorkerReasoning(reasoning).trimEnd().replace(/^/gm, "  ")}\n`);
+            }
+            catch (cause) {
+                write(`${renderTuiFailure(cause)}\n`);
+            }
             return;
         case "child":
             if (rest.length === 0) {
-                write(`  child: ${opts.childAlias ?? "inherit"}\n`);
+                write(`  child: ${ctx.spawnModel === null ? "inherit" : resolvedModelLabel(ctx.spawnModel)}\n`);
                 return;
             }
-            if (rest === "inherit") {
-                opts.childAlias = null;
-                opts.childModel = undefined;
+            try {
+                // {§worker-model-selection} — inherit IS the server action (selector null
+                // clears the override); the daemon returns null for it.
+                ctx.setSpawnModel(modelRouteOrNull(await rpc.call("worker.child.set", { selector: rest === "inherit" ? null : rest })));
+                write(`  child: ${rest}\n`);
             }
-            else {
-                opts.childAlias = rest;
-                opts.childModel = ctx.resolveModel?.(rest);
+            catch (cause) {
+                write(`  child set failed: ${cause instanceof Error ? cause.message : String(cause)}\n`);
             }
-            write(`  child: ${rest}\n`);
             return;
         case "yolo":
             opts.yolo = !opts.yolo;
@@ -261,6 +353,7 @@ export const handleVerb = async (line, ctx) => {
             // handle (/rename retargets it). client id (#249) + AGENTS override
             // (#268) ride the switch.
             ctx.setWorkspace(await ctx.switchWorkspace(rest.length > 0 ? rest : undefined));
+            await refreshWorkerPolicy();
             write(`  workspace: ${ctx.getWorkspace().name} (new)\n`);
             return;
         }
@@ -277,11 +370,12 @@ export const handleVerb = async (line, ctx) => {
             return;
         }
         case "worker": {
-            // New worker — worker.fork (svc#248) branches this conversation, optionally
+            // New worker — run.fork branches this conversation, optionally
             // named at instantiation (immutable after). Bind to the fork so the
             // next prompt speaks there. The workspace (the world) is unchanged.
-            const forked = await rpc.call("worker.fork", rest.length > 0 ? { name: rest } : {});
+            const forked = await rpc.call("run.fork", rest.length > 0 ? { name: rest } : {});
             await rpc.call("workspace.attach", { id: ctx.getWorkspace().id, workerId: forked.workerId });
+            await refreshWorkerPolicy();
             write(`  worker: ${forked.workerName} (new)\n`);
             return;
         }
@@ -309,8 +403,8 @@ export const handleVerb = async (line, ctx) => {
                 write(`  no constraint matching ${JSON.stringify(rest)}\n`);
                 return;
             }
-            for (const c of matches)
-                await rpc.call("workspace.unconstrain", c);
+            for (const { effect, glob } of matches)
+                await rpc.call("workspace.unconstrain", { effect, glob });
             write(`  dropped ${matches.length} constraint${matches.length === 1 ? "" : "s"} (${rest})\n`);
             return;
         }
@@ -371,7 +465,15 @@ export const handleVerb = async (line, ctx) => {
             return;
         }
         case "mcp": {
-            await handleMcp(rest, rpc, write);
+            await handleMcp(rest, rpc, write, { overlay: opts.mcpConfiguration });
+            return;
+        }
+        case "skills": {
+            await handleSkills(rest, rpc, write);
+            return;
+        }
+        case "agents": {
+            await handleAgents(rest, rpc, write);
             return;
         }
         case "accept":
@@ -384,6 +486,9 @@ export const handleVerb = async (line, ctx) => {
         case "stop":
             await rpc.call("loop.cancel", { reason: "user_stop" });
             return;
+        case "editor":
+            await ctx.composeInEditor();
+            return;
         case "quit":
             return "quit";
         default:
@@ -393,12 +498,23 @@ export const handleVerb = async (line, ctx) => {
 };
 export const runTui = async (transport, workspace, opts) => {
     let current = workspace;
-    // Highest loop_seq the waterfall has shown — the next prompt is one beyond.
-    let lastLoopSeq = 0;
     // Loop state, hoisted so buildPrompt can show a steer prompt while a loop
     // runs and the line handler / SIGINT can share it.
     let inFlight = false;
     let cancelRequested = false;
+    // One cancel path for every interrupt gesture (Ctrl-C, Esc, /stop): the
+    // run's active drain cancels via loop.cancel; the pending loop resolves
+    // 499 and the REPL continues. A failed cancel SURFACES — a stop button
+    // that silently does nothing is the worst kind of broken.
+    const requestCancel = (reason) => {
+        if (cancelRequested)
+            return;
+        cancelRequested = true;
+        process.stdout.write("\r\x1b[2K  \x1b[2mcancelling… (ctrl-c again to quit)\x1b[0m\n");
+        void transport.rpc("loop.cancel", { reason }).catch((err) => {
+            process.stdout.write(`\r\x1b[2K  \x1b[31mcancel failed: ${err instanceof Error ? err.message : String(err)}\x1b[0m\n`);
+        });
+    };
     // Prompt status gutter (#114, refined): two reserved slots — 🧮 while
     // embeddings warm, and a busy glyph (⏳ working / 💤 hibernating) whenever a
     // loop OR embedding is active. Glyphs when active, blanks when not, so the
@@ -414,6 +530,7 @@ export const runTui = async (transport, workspace, opts) => {
     // Alt-n cycler — not synthesized log-entry coordinates. lookCursor walks them.
     const priorTargets = [];
     let lookCursor = null;
+    let liveReasoning = null;
     // Print a line ABOVE the live readline prompt without eating the user's
     // in-progress input. The canonical "log while prompting" idiom: wipe the
     // prompt row, write the line, then re-render the prompt + current buffer on
@@ -433,9 +550,10 @@ export const runTui = async (transport, workspace, opts) => {
     // Alias cache for /model completion + the active alias for the header —
     // one cheap RPC, refreshed never (aliases are daemon-boot-time config).
     // Awaited before the banner so the header can name the model the daemon
-    // will actually use when --model/PLURNK_MODEL is unset (providers.list
+    // will actually use when --model is unset (providers.list
     // marks the boot-time default `active`).
     let aliasCache = [];
+    const providerModelCache = new Map();
     let activeAlias;
     // Alias list for completion + the header's active default. Both terminal gauges
     // ride the loop usage envelope; this client never reconstructs curation policy or
@@ -448,12 +566,50 @@ export const runTui = async (transport, workspace, opts) => {
         }
     }
     catch { /* completion stays empty; header falls back to (daemon default) */ }
+    // {§worker-model-selection} — the worker owns the model. Read the server truth
+    // for the header and the /model /child display; an EXPLICIT --model persists
+    // onto the worker at startup (a one-time durable selection, not a per-loop
+    // reassertion).
+    let workerModel = null;
+    let workerSpawnModel = null;
+    let workerReasoning = { policy: null, supportedPolicies: [] };
+    let reasoningFailure;
+    // Model identity is control-plane truth, not decorative header data. A
+    // transport failure or malformed projection leaves this client unable to
+    // know which durable worker policy it is presenting, so admission fails
+    // instead of silently relabeling the worker as the daemon default.
+    const initialModel = workerModelProjection(await transport.rpc("worker.model.get"));
+    workerModel = initialModel.model;
+    workerSpawnModel = initialModel.spawnModel;
+    if (opts.modelExplicit === true && opts.modelSelector !== undefined) {
+        // A deliberate selection is part of invocation admission, not display
+        // hydration. Refuse the TUI before it accepts input if the daemon cannot
+        // persist it; continuing would silently run the worker's previous model.
+        workerModel = Validator.assertModelRoute(await transport.rpc("worker.model.set", { selector: opts.modelSelector }));
+    }
+    if (opts.reasoningExplicit === true && opts.reasoningPolicy !== undefined) {
+        // Same admission rule as --model: an explicit policy must take effect or
+        // the invocation fails before any model work can run under stale policy.
+        workerReasoning = await setWorkerReasoning({ call: (method, params) => transport.rpc(method, params) }, opts.reasoningPolicy);
+    }
+    else {
+        try {
+            workerReasoning = await readWorkerReasoning({ call: (method, params) => transport.rpc(method, params) });
+        }
+        catch (cause) {
+            reasoningFailure = cause;
+        }
+    }
     // One header line: version · workspace [· worker] · model · help (see buildHeader).
     const header = buildHeader({
         versionNotice: opts.versionNotice, workspaceName: current.name, workerName: opts.workerName,
-        modelAlias: opts.modelAlias, activeAlias, yolo: opts.yolo,
+        modelSelector: workerModel === null ? opts.modelSelector : resolvedModelLabel(workerModel), activeAlias,
+        reasoningPolicy: workerReasoning.policy,
+        yolo: opts.yolo,
     });
     process.stdout.write(`\x1b[2m${header}\x1b[0m\n\n`);
+    if (reasoningFailure !== undefined)
+        process.stdout.write(`${renderTuiFailure(reasoningFailure)}\n`);
     // The prompt is the user's row, restricted to WIDTH-STABLE glyphs —
     // settled empirically in two rounds. Round 1 (`  👤 ✉️  ✅ 201 : `)
     // drifted by exactly one column: ✉️ is U+2709+VS16, the variation-
@@ -468,10 +624,6 @@ export const runTui = async (transport, workspace, opts) => {
     // 💬 (U+1F4AC, stable-wide) fills the op slot the toxic ✉️ vacated.
     // Policy: VS16/ambiguous glyphs are banned from the ENTIRE palette
     // (render.ts) — stable widths are also what make columns align.
-    // The prompt is the user's row, coordinate-prefixed like every other
-    // waterfall line (§5.1). The coordinate is the next actionless prompt row.
-    // lastLoopSeq tracks the highest loop the waterfall has shown; the next
-    // prompt is one beyond it. Plain-ASCII coordinate — width-safe.
     // The prompt is the SAME whether or not a loop is running — kept alive above
     // the streaming traces by printAbove. The user just types; a line submitted
     // while a loop is in flight is folded into it (loop.inject), else it starts
@@ -506,10 +658,10 @@ export const runTui = async (transport, workspace, opts) => {
         const activePercent = embedding ? embeddingPercent
             : searchFetching ? searchPercent
                 : branchPercent;
-        const position = activePercent !== null
-            ? progressLabel(activePercent)
-            : coordLabel(lastLoopSeq + 1, 1, 1);
-        return `${yolo}${position}${origin} ${status} \x1b[32m201\x1b[0m \x1b[1m: \x1b[0m`;
+        // No coordinate, no decorative code (plurnk#21): the prompt is
+        // `[gauge] 🐹 <status> : ` — the busy gauge appears only while active.
+        const position = activePercent !== null ? progressLabel(activePercent) : "";
+        return `${yolo}${position}${origin} ${status} \x1b[1m: \x1b[0m`;
     };
     // Bracketed-paste buffering (paste.ts): a multi-line paste must become ONE
     // prompt, not one loop.run per line. readline reads a PassThrough we feed
@@ -525,7 +677,19 @@ export const runTui = async (transport, workspace, opts) => {
         output: process.stdout,
         terminal: true,
         prompt: buildPrompt(),
-        completer: makeCompleter(() => aliasCache, process.cwd()),
+        completer: makeCompleter(() => aliasCache, process.cwd(), () => workerReasoning.supportedPolicies, async (provider) => {
+            // One bounded page per provider, cached for the session: lazy,
+            // provider-scoped, never the whole catalog.
+            const cached = providerModelCache.get(provider);
+            if (cached !== undefined)
+                return cached;
+            const page = await transport.rpc("models.list", { provider, limit: 100 });
+            const selectors = (page.items ?? [])
+                .map(({ selector }) => selector)
+                .filter((selector) => typeof selector === "string");
+            providerModelCache.set(provider, selectors);
+            return selectors;
+        }),
     });
     const reprompt = () => {
         readline.cursorTo(process.stdout, 0);
@@ -542,11 +706,50 @@ export const runTui = async (transport, workspace, opts) => {
         rl.setPrompt(buildPrompt());
         rl.prompt(true);
     };
-    // Now that rl exists, printAbove can re-render the prompt after each line.
-    printAbove = (text) => {
+    const clearPromptAndLiveReasoning = () => {
         readline.cursorTo(process.stdout, 0);
         readline.clearLine(process.stdout, 0);
+        if (liveReasoning?.shown === true) {
+            readline.moveCursor(process.stdout, 0, -1);
+            readline.cursorTo(process.stdout, 0);
+            readline.clearLine(process.stdout, 0);
+        }
+    };
+    const redrawLiveReasoning = () => {
+        if (liveReasoning?.shown === true) {
+            process.stdout.write(`${renderReasoningPreview(liveReasoning.content, process.stdout.columns ?? 80)}\n`);
+        }
+        rl.prompt(true);
+    };
+    // Now that rl exists, printAbove can re-render the prompt after each line.
+    // A live reasoning preview remains the final row above it, so concurrent
+    // stream or worker activity cannot corrupt the preview's cursor ownership.
+    printAbove = (text) => {
+        clearPromptAndLiveReasoning();
         process.stdout.write(`${text}\n`);
+        redrawLiveReasoning();
+    };
+    const presentReasoning = (update) => {
+        if (update.phase === "start") {
+            if (liveReasoning !== null)
+                throw new TypeError("A second reasoning message started before the first ended.");
+            liveReasoning = { messageId: update.messageId, content: "", shown: false };
+            return;
+        }
+        if (liveReasoning === null || liveReasoning.messageId !== update.messageId) {
+            throw new TypeError(`Reasoning ${update.phase} did not match the active message.`);
+        }
+        clearPromptAndLiveReasoning();
+        if (update.phase === "content") {
+            liveReasoning.content = update.content;
+            liveReasoning.shown = update.content.length > 0;
+            redrawLiveReasoning();
+            return;
+        }
+        const content = update.content;
+        liveReasoning = null;
+        if (content.length > 0)
+            process.stdout.write(`${renderReasoning(content)}\n`);
         rl.prompt(true);
     };
     // Replace the whole readline buffer with `text`, public-API only: Ctrl-U kills
@@ -590,13 +793,32 @@ export const runTui = async (transport, workspace, opts) => {
     // handlers are forward-declared (assigned once verbCtx exists).
     let pendingProposal = null;
     let onProposalKey = () => { };
-    // A pending SEND signal 300 question (#346): answered by TYPING (a number picks a
-    // choice; anything else is free response), NOT the a/e/r/c keypress path —
-    // free response needs text. The line handler intercepts while this is set.
+    // A pending request-user-input question ({§question-tool}): answered by TYPING
+    // (a number picks an enum choice; anything else is free response), NOT the
+    // a/e/r/c keypress path — free response needs text. The line handler
+    // intercepts while this is set.
     let pendingQuestion = null;
     let dispatchShortcut = () => { };
     const onStdin = (chunk) => {
-        const forward = paste.feed(chunk.toString("utf8"));
+        const text = chunk.toString("utf8");
+        // Esc interrupts (plurnk#25) — the agent-CLI convention: bare Esc with
+        // a loop in flight cancels it (same path as the first Ctrl-C); idle it
+        // clears the composed line. Read BEFORE the paste filter, which would
+        // otherwise hold a lone ESC as a possible split \x1b[200~ prefix. An
+        // exact lone-ESC chunk while no paste is open is the KEY — the same
+        // whole-chunk rule the Alt-shortcuts rely on.
+        if (text === "\x1b" && paste.idle()) {
+            if (inFlight) {
+                requestCancel("user_escape");
+                return;
+            }
+            if (rl.line.length > 0) {
+                rl.write(null, { ctrl: true, name: "e" });
+                rl.write(null, { ctrl: true, name: "u" });
+            }
+            return;
+        }
+        const forward = paste.feed(text);
         if (forward.length === 0)
             return;
         // A pending proposal + an EMPTY prompt line: a single review key
@@ -745,9 +967,8 @@ export const runTui = async (transport, workspace, opts) => {
             repromptPreserving();
     };
     transport.subscribe({
+        onReasoning: presentReasoning,
         onEntry: (entry) => {
-            if (entry.loop_seq > lastLoopSeq)
-                lastLoopSeq = entry.loop_seq;
             // The typed line at the prompt is the user's record — rendering the
             // prompt broadcast too would duplicate it (see isPromptEntry).
             if (isPromptEntry(entry))
@@ -787,15 +1008,6 @@ export const runTui = async (transport, workspace, opts) => {
             }
         },
         onProposal: (p) => {
-            // SEND signal 300 question FIRST — even a yolo loop stops the world for a human;
-            // the line handler resolves it from the next typed line.
-            const q = questionFromProposal(p);
-            if (q !== null) {
-                pendingQuestion = { logEntryId: p.logEntryId, choices: q.choices };
-                printAbove(renderQuestionMenu(q.question, q.choices));
-                reprompt();
-                return;
-            }
             if (isServerResolved(p))
                 return;
             if (opts.yolo) {
@@ -806,6 +1018,14 @@ export const runTui = async (transport, workspace, opts) => {
             proposalQueue.push(p);
             showNextProposal();
         },
+        onInteraction: (i) => {
+            // The question tool paused its loop: render the standard message + the
+            // schema's single-property enum choices; the line handler resolves the
+            // typed answer back into the paused run.
+            pendingQuestion = { interactionId: i.interactionId, schema: i.responseSchema };
+            printAbove(renderQuestionMenu(i.message, questionChoices(i.responseSchema)));
+            reprompt();
+        },
         // A loop terminating just clears the parked glyph; the summary is rendered
         // from the run's own done (below).
         onTerminated: () => { hibernating = false; },
@@ -849,7 +1069,13 @@ export const runTui = async (transport, workspace, opts) => {
     // Verb dispatch runs through the testable module-level handleVerb; this
     // context injects the live workspace / opts / stdout / import glue.
     const verbCtx = {
-        rpc: verbRpc, opts, resolveModel: opts.resolveModel,
+        rpc: verbRpc, opts,
+        get model() { return workerModel; },
+        get spawnModel() { return workerSpawnModel; },
+        get reasoning() { return workerReasoning; },
+        setModel: (spec) => { workerModel = spec; },
+        setSpawnModel: (spec) => { workerSpawnModel = spec; },
+        setReasoning: (reasoning) => { workerReasoning = reasoning; },
         getWorkspace: () => current,
         setWorkspace: (s) => { current = s; },
         switchWorkspace: (name) => transport.useSession(name, { projectRoot: opts.projectRoot, client: opts.client }),
@@ -877,6 +1103,32 @@ export const runTui = async (transport, workspace, opts) => {
             }
             await resolvePending({ decision: action });
         },
+        // /editor · Alt-e (plurnk#26): seed $EDITOR with the composed line
+        // (markers expanded), place the result BACK on the line — never
+        // auto-submit (bash Ctrl-X Ctrl-E executes on exit; a prompt line
+        // spends model tokens, so Enter stays the only submit). Same bounded
+        // terminal handoff as proposal edit. Empty buffer ⇒ line unchanged.
+        composeInEditor: async () => {
+            process.stdin.off("data", onStdin);
+            process.stdin.setRawMode?.(false);
+            let edited = null;
+            try {
+                edited = await editInEditor(paste.expand(expandNewlines(rl.line)), ".md");
+            }
+            catch (cause) {
+                process.stdout.write(`${renderTuiFailure(cause)}\n`);
+            }
+            finally {
+                process.stdin.setRawMode?.(true);
+                process.stdin.resume();
+                process.stdin.on("data", onStdin);
+            }
+            if (edited === null)
+                return;
+            rl.write(null, { ctrl: true, name: "e" });
+            rl.write(null, { ctrl: true, name: "u" });
+            rl.write(paste.stash(edited.replace(/\n$/, "")));
+        },
     };
     // Alt-<letter> shortcut → run the verb. Wipe the prompt line, dispatch
     // through the same handleVerb the typed `/verb` uses (the partial prompt in
@@ -899,19 +1151,20 @@ export const runTui = async (transport, workspace, opts) => {
     reprompt();
     return new Promise((resolve) => {
         rl.on("line", async (line) => {
-            // A pending SEND signal 300 question consumes the typed line as its answer,
-            // BEFORE any verb/prompt/inject handling (#346): a number picks a
-            // choice, anything else is free response. Empty → re-ask (don't
-            // resolve with nothing). Resolves the world-stopped proposal via body.
+            // A pending request-user-input question consumes the typed line as its
+            // answer, BEFORE any verb/prompt/inject handling: a number picks an
+            // enum choice, anything else is free response (or raw JSON for a
+            // multi-property schema). Empty → re-ask. Resolves the paused run with
+            // the standard ElicitResult payload.
             if (pendingQuestion !== null) {
-                const body = answerForLine(line, pendingQuestion.choices);
-                if (body === null) {
+                const content = answerForQuestion(line, pendingQuestion.schema);
+                if (content === null) {
                     reprompt();
                     return;
                 }
-                const { logEntryId } = pendingQuestion;
+                const { interactionId } = pendingQuestion;
                 pendingQuestion = null;
-                await transport.resolve({ logEntryId, decision: "accept", body })
+                await transport.resolveInteraction(interactionId, { action: "accept", content })
                     .catch((e) => printAbove(`  \x1b[31manswer failed: ${e instanceof Error ? e.message : String(e)}\x1b[0m`));
                 reprompt();
                 return;
@@ -998,15 +1251,9 @@ export const runTui = async (transport, workspace, opts) => {
                     // Prompt. `? ` = ask (read-only loop, flags.mode="ask");
                     // `: ` = act. Per-line prefix overrides --flags mode.
                     const { flags: lineFlags, prompt: promptText } = lineMode(trimmed, opts.loopFlags);
-                    const loopParams = { prompt: promptText };
-                    if (opts.modelAlias !== undefined)
-                        loopParams.alias = opts.modelAlias; // display label
-                    if (opts.model !== undefined)
-                        loopParams.model = opts.model; // #90 client-resolved routing (precedence)
-                    if (opts.childAlias !== undefined)
-                        loopParams.childAlias = opts.childAlias;
-                    if (opts.childModel !== undefined)
-                        loopParams.childModel = opts.childModel;
+                    // {§worker-model-selection} — no model selector rides the loop: the
+                    // worker owns the model; /model and /child persisted it server-side.
+                    const loopParams = { prompt: promptText, requestUserInput: opts.requestUserInput !== false };
                     if (lineFlags !== undefined && Object.keys(lineFlags).length > 0)
                         loopParams.flags = lineFlags;
                     if (opts.maxTurns !== undefined)
@@ -1057,11 +1304,7 @@ export const runTui = async (transport, workspace, opts) => {
             // unblock (op.parse). A failed cancel SURFACES — a stop button that
             // silently does nothing is the worst kind of broken.
             if (inFlight && !cancelRequested) {
-                cancelRequested = true;
-                process.stdout.write("\r\x1b[2K  \x1b[2mcancelling… (ctrl-c again to quit)\x1b[0m\n");
-                void transport.rpc("loop.cancel", { reason: "user_sigint" }).catch((err) => {
-                    process.stdout.write(`\r\x1b[2K  \x1b[31mcancel failed: ${err instanceof Error ? err.message : String(err)}\x1b[0m\n`);
-                });
+                requestCancel("user_sigint");
                 return;
             }
             rl.close();