@vincemakes/kiso-code 0.31.0 → 0.32.0

package/dist/dispatch.js

@@ -8,8 +8,10 @@ import { newSessionId } from "./session-id.js";
 import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
 import { MODES, MODE_NOTE, getMode, setMode } from "./mode.js";
 import { clipboardWrite, lastAnswer } from "./clipboard.js";
-import { agentModel, body, bodyLog, configModels, dock, readContextLedger, sessionsDir, setAgentModel, setCurrentModelName, setLastBinding } from "./state.js";
+import { agentModel, body, bodyLog, codingToolOptions, kisoHome, configModels, dock, lastBinding, readContextLedger, sessionsDir, setAgentModel, setCurrentModelName, setModelChoice, setLastBinding } from "./state.js";
 import { authForProfile, directWriteProfile, profileAvailable, unavailableReason } from "./config.js";
+import { shellTool } from "@vincemakes/kiso-tools-node";
+import { join } from "node:path";
 /** The picker's CLI half (owner 2026-09-08): a profile's LEGAL effort levels
  *  and its default, from the registry, shown wherever the profile is listed
  *  — kiso never silently drops a level, and now it shows the ones it takes.
@@ -22,6 +24,43 @@ function effortNote(p) {
         return "effort: unknown";
     return `effort: ${effort.levels.map((l) => (l === effort.default ? `[${l}]` : l)).join(" · ")}`;
 }
+/** OR-7 — the pick panel's second axis, as DATA. `effortNote` above stays
+ *  the PRINTED list's string (a machine-readable surface whose bytes do
+ *  not move); the panel gets the levels structured so its cursor can walk
+ *  them, and so the bracket can mean "the cursor is here" rather than
+ *  "the registry default".
+ *
+ *  Where the cursor starts: the session's CURRENT effort when this model
+ *  has that level, else the model's default, else nowhere — a row whose
+ *  registry default is null (the model page states none) marks nothing,
+ *  and enter on it applies the profile alone. Nothing is invented. */
+function effortAxis(p) {
+    const reasoning = lookupModelMetadata(p.model, p.baseUrl)?.capabilities.reasoning ?? null;
+    if (reasoning === null)
+        return {};
+    const effort = reasoning.effort;
+    if (effort === null)
+        return {};
+    const levels = effort.levels;
+    const carried = lastBinding()?.reasoning?.effort;
+    const carriedIdx = carried === undefined || carried === "default" ? -1 : levels.indexOf(carried);
+    const defaultIdx = effort.default === null ? -1 : levels.indexOf(effort.default);
+    const level = carriedIdx >= 0 ? carriedIdx : defaultIdx;
+    // the forbidden set is per THINKING mode, and the panel applies its
+    // pick as thinking "default" — the same setting `/model <p> <e>`
+    // builds — so only pairs forbidden at that mode are dimmed here.
+    const disabled = (reasoning.forbidden ?? []).filter((f) => f.thinking === "default").map((f) => levels.indexOf(f.effort)).filter((i) => i >= 0);
+    return {
+        levels,
+        ...(level >= 0 ? { level } : {}),
+        ...(disabled.length > 0 ? { disabled } : {}),
+        // the sentence the coordination note asked for: said only when the
+        // cursor could NOT land where the previous selection asked.
+        ...(carried !== undefined && carried !== "default" && carriedIdx < 0 && defaultIdx >= 0
+            ? { levelNote: `effort ${carried} \u2192 ${levels[defaultIdx]}: the nearest this model supports` }
+            : {}),
+    };
+}
 /** What signs a profile in, for the listing: the env var's name, `oauth`
  *  for a subscription sign-in, or `no key` for an unauthenticated endpoint. */
 function signInNote(p) {
@@ -40,8 +79,98 @@ import { oauthTokenThunk } from "./auth/token.js";
  *  replay routes through it too — a queued "/last" must never become a
  *  user turn (v2c: the rl lives in main, so lines arrive earlier and the
  *  queue is the common path). */
+/** §2.2 — the `!` command in flight, if one is. A `!` command and a model
+ *  run are never both running (the dispatcher is serialized on the chain),
+ *  so one slot is the whole state. */
+let activeBang = null;
+/** esc while a `!` command runs kills it — the SAME abort the shell tool
+ *  gives a model's call, so the whole process group goes, children
+ *  included. Exported because the esc key reaches the editor first: chat
+ *  offers it here before it reaches a model run, and only one of the two
+ *  can be in flight. */
+export function abortBangCommand() {
+    if (activeBang === null)
+        return false;
+    activeBang.abort();
+    return true;
+}
+/** §2.2 — what a submitted line asks for, if it asks for a shell at all.
+ *  Split out from the dispatcher so the rule is testable without a
+ *  terminal: `null` means this is not the gesture and the line is a turn.
+ *
+ *  `!!` is checked before `!` because the longer prefix is the narrower
+ *  claim; testing `!` first would swallow both. */
+export function parseBang(trimmed) {
+    // a multi-line paste that merely begins with `!` is prose, the same
+    // rule `/` already follows one branch below.
+    if (trimmed.includes("\n") || !trimmed.startsWith("!"))
+        return null;
+    const send = !trimmed.startsWith("!!");
+    return { command: trimmed.slice(send ? 1 : 2).trim(), send };
+}
+/** §2.2 — `!cmd` runs a command and SENDS it, `!!cmd` runs one and shows
+ *  it. Both go through the shell tool's own runner, so the timeout (30 s),
+ *  the output cap (100,000 chars, which names what it dropped), the
+ *  whole-tree kill and the STRIPPED environment are the tool's and not a
+ *  second set of rules. The `!`/`!!` difference is what the MODEL sees,
+ *  never what leaves the machine.
+ *
+ *  No approval panel, at any tier including plan: the human typed the
+ *  command. That is not a policy exemption, it is structural — this
+ *  dispatcher only ever sees lines a human submitted, so a model cannot
+ *  reach this branch. */
+function runBang(command, send, ctx) {
+    ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+        const controller = new AbortController();
+        activeBang = controller;
+        try {
+            const tool = shellTool(codingToolOptions());
+            const result = await tool.execute({ command }, { signal: controller.signal });
+            // one fenced block, read as a terminal transcript: the command
+            // and what it printed. The tool's own overflow note rides inside
+            // `content`, so a capped run says so in the same words a model's
+            // call would.
+            const block = ["```console", `$ ${command}`, result.content, "```"].join("\n");
+            if (send) {
+                // an ORDINARY user turn: durable, in the log, and the model
+                // sees exactly what the human saw.
+                ctx.submitTurn(block);
+                return; // submitTurn owns the prompt from here
+            }
+            bodyLog(block, "words");
+        }
+        finally {
+            activeBang = null;
+        }
+        ctx.input.prompt();
+    });
+}
 export function dispatch(line, ctx) {
     const trimmed = line.trim();
+    // §2.2 — the `!` gesture is the COMPOSER's alone. A piped session, `-p`
+    // and `--task-file` keep `!` as ordinary text: those lines are content,
+    // and a headless run that shelled out because a prompt began with `!`
+    // would be executing its input.
+    if (dock.active && !trimmed.includes("\n")) {
+        if (trimmed.startsWith("\\!")) {
+            // the ONE escape: `\!` sends the literal text starting with `!`.
+            ctx.submitTurn(line.replace("\\!", "!"));
+            return;
+        }
+        const bang = parseBang(trimmed);
+        if (bang !== null) {
+            const { command, send } = bang;
+            if (command === "") {
+                ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+                    bodyLog("!<command> runs it and sends the result · !!<command> runs it and shows it here · \\! sends a literal !");
+                    ctx.input.prompt();
+                });
+                return;
+            }
+            runBang(command, send, ctx);
+            return;
+        }
+    }
     if (trimmed === "/help") {
         // KC3.5 slice ⓪ (the extraction): the ROWS moved to the terminal
         // layer's strings module (helpRows — the KC3 §1 pattern: what the
@@ -133,6 +262,75 @@ export function dispatch(line, ctx) {
         ctx.input.prompt();
         return;
     }
+    if (trimmed === "\x07editor") {
+        // §2.4 — ctrl+g hands the composer to the human's own editor.
+        //
+        // The split: the EDITOR owns the terminal handover (raw mode, the
+        // mouse, bracketed paste — see `externalEdit`), and this owns the
+        // spawn, because the tui package is pure terminal and spawning is
+        // not. Neither reaches into the other.
+        //
+        // $VISUAL before $EDITOR — VISUAL is the variable for a full-screen
+        // editor and EDITOR is the fallback — and NO guess beyond them. In
+        // an environment that sets neither, dropping someone into an editor
+        // they did not choose is the product deciding for them.
+        //
+        // It never SUBMITS. What comes back is text in the composer and
+        // enter is still the human's: one key that both opens an editor and
+        // sends is a gesture with no way back.
+        const bin = process.env.VISUAL ?? process.env.EDITOR ?? "";
+        if (bin.trim() === "") {
+            ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+                bodyLog("no editor configured — set $VISUAL or $EDITOR to open one with ctrl+g");
+                ctx.input.prompt();
+            });
+            return;
+        }
+        // The process spawn lives in its own module, reached HERE and not
+        // imported at the top. The PTY manifest gate classifies a test by
+        // the RESOURCE closure of what it imports, so a static process
+        // import in the dispatcher moves every test that imports the
+        // dispatcher into the single-file-serial pool — it took `!cmd`'s
+        // millisecond-long parser test with it. Loading the module at the
+        // key makes the closure honest: importing the dispatcher cannot
+        // start a process.
+        //
+        // (The gate scans SOURCE, comments included, so naming the node
+        // module here in prose would reclassify this file just as surely as
+        // importing it. Deliberately over-wide — see the gate's own note.)
+        //
+        // Joining the chain is a FIX, not the price of that. Handing the
+        // terminal to a full-screen editor while a turn is streaming rows
+        // into that same terminal gives the child a screen kiso is still
+        // painting over. An idle chain resolves on the next microtask, so
+        // the press that is not mid-turn is unchanged.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const { runExternalEditor } = await import("./external-editor.js");
+            const root = join(kisoHome(), "tmp");
+            ctx.input.externalEdit?.((text) => runExternalEditor(bin, root, text, (msg) => body.notice(msg)));
+            // the external program drew over the screen; the model is the only
+            // authority on what should be there (R14).
+            body.reprint();
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "\x14think") {
+        // §2.3 — ctrl+t folds the committed thinking blocks, and folds them
+        // back. DC-50's mechanism, not a second one: one boolean, then the
+        // session is reprinted, so the blocks already on screen obey the
+        // switch rather than only the next ones.
+        //
+        // The folded row is `foldThinking`'s, which is what the PIPE writes
+        // — so thinking has two renderings in the product and not three,
+        // and the pipe's byte-identity gate is this row's gate too.
+        //
+        // The live `thinking…` placeholder is NOT touched: it belongs to
+        // the live region, and this switch is about committed blocks.
+        body.toggleThinking();
+        ctx.input.prompt();
+        return;
+    }
     if (trimmed === "\x18copy" || trimmed === "/copy") {
         // E1 §3 — the last answer onto the clipboard, as RAW MARKDOWN.
         //
@@ -316,13 +514,17 @@ export function dispatch(line, ctx) {
             // surface and this round moves no bytes on one.
             if (arg === "" && dock.active && ctx.input.panelAsk !== undefined) {
                 const names = Object.keys(configModels);
+                let pickedLevel;
                 const picked = await new Promise((resolve) => {
                     ctx.input.panelAsk(modelPickView({
                         header: `model — current: ${agentModel}`,
                         options: names.map((name) => {
                             const profile = configModels[name];
-                            const marks = [`profile: ${name}`, ...(profileAvailable(profile) ? [] : ["unavailable"]), ...(profile.model === agentModel ? ["current"] : []), effortNote(profile)];
-                            return { label: `${profile.kind}/${profile.model}`, note: marks.join(" · ") };
+                            // the note keeps what tells two rows apart; the levels
+                            // left it for the axis below (they were being cut off
+                            // the end of the note column at 100 columns).
+                            const marks = [`profile: ${name}`, ...(profileAvailable(profile) ? [] : ["unavailable"]), ...(profile.model === agentModel ? ["current"] : [])];
+                            return { label: `${profile.kind}/${profile.model}`, note: marks.join(" · "), ...effortAxis(profile) };
                         }),
                         // PH-1a (finding PH-F4): the example must be a syntax
                         // directWriteProfile actually ACCEPTS — the old
@@ -337,14 +539,30 @@ export function dispatch(line, ctx) {
                     // DC-12 (design §4): a panel WAITING ON A HUMAN says ❯. The
                     // else-branch keeps ▸ — it names the current tier, which is
                     // what ▸ means everywhere else.
-                    ctx.isRunning() ? "❯ run paused" : `▸ ${getMode()}`), (v) => resolve(v.action === "picked" ? v.result : null));
+                    ctx.isRunning() ? "❯ run paused" : `▸ ${getMode()}`), (v) => {
+                        // OR-7: the level rides beside the result, so a pick
+                        // with no second axis is byte-for-byte the old one.
+                        if (v.action === "picked")
+                            pickedLevel = v.level;
+                        resolve(v.action === "picked" ? v.result : null);
+                    });
                 });
                 ctx.paintIdle();
                 if (picked === null) {
                     ctx.input.prompt();
                     return; // esc — nothing switched, nothing said
                 }
-                arg = "index" in picked ? names[picked.index] : picked.custom;
+                if ("index" in picked) {
+                    // OR-7: the panel hands back both axes and the command
+                    // string is where they meet — everything below is the
+                    // typed `/model <profile> <effort>` path, unchanged, so
+                    // the refusal wording and the durable revision are its.
+                    const name = names[picked.index];
+                    const level = pickedLevel === undefined ? undefined : effortAxis(configModels[name]).levels?.[pickedLevel];
+                    arg = level === undefined ? name : `${name} ${level}`;
+                }
+                else
+                    arg = picked.custom;
             }
             if (arg === "") {
                 bodyLog(`model: ${agentModel}`);
@@ -373,7 +591,13 @@ export function dispatch(line, ctx) {
                         bodyLog(`no such model profile: ${profName}`);
                     }
                     else if (!profileAvailable(profile)) {
-                        bodyLog(unavailableReason(arg, profile));
+                        // the PROFILE name, not the whole argument: what is
+                        // unavailable is the credential, and an effort token
+                        // riding along ("claude high: unavailable") reads as
+                        // though the level were part of the problem. The panel
+                        // began producing that token in OR-7; the typed path
+                        // could always produce it too.
+                        bodyLog(unavailableReason(profName, profile));
                     }
                     else {
                         const auth = authForProfile(profName, profile);
@@ -430,6 +654,18 @@ export function dispatch(line, ctx) {
                             setLastBinding(binding);
                             setAgentModel(profile.model, profile.baseUrl);
                             setCurrentModelName(arg);
+                            // §2.5: the ONE source a reload reads for the model — a
+                            // switch made here must survive the rebuild.
+                            setModelChoice(arg);
+                            // OR-7 (owner, 2026-09-09): the status row is repainted BY the
+                            // switch — it used to keep the old model until the next
+                            // recap repainted it, so "takes effect on the next turn"
+                            // read as "did not take". Painted BEFORE the notice so the
+                            // frame that carries the notice already carries the row.
+                            // DF-0311-F1: repainted with NO meter — the 0.31.1 dogfood
+                            // (and the owner's) read `gpt-6-astra · CH 92%`, the new
+                            // model beside the previous model's figure.
+                            ctx.modelSwitched();
                             body.notice(`model → ${profName} (${profile.model}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
                         }
                     }
@@ -565,6 +801,21 @@ export function dispatch(line, ctx) {
         ctx.requestSwitch(newSessionId(sessionsDir()));
         return;
     }
+    if (trimmed === "/reload") {
+        // §2.5: extensions, skills and config, read again into a session that
+        // keeps its conversation. It is a REBUILD — the tool registry is
+        // built in the agent's constructor and has no unregister, so nothing
+        // short of constructing the agent again can drop a tool or add one.
+        // The durable log is untouched: a reload is invisible in the record,
+        // because nothing the model said or did changes.
+        if (ctx.isRunning()) {
+            body.notice("[/reload] a run is in flight — let it finish (esc stops it), then reload");
+            ctx.input.prompt();
+            return;
+        }
+        ctx.requestReload();
+        return;
+    }
     if (trimmed === "/resume" || trimmed.startsWith("/resume ")) {
         // the mini-spec: the in-session door to the durable sessions —
         // /resume <id> switches directly; bare /resume opens the SAME

package/dist/external-editor.d.ts

@@ -0,0 +1,30 @@
+/**
+ * §2.4 — the RUN half of ctrl+g.
+ *
+ * The dispatcher routes and this runs: it owns the temp file and the
+ * spawn, and knows nothing about the composer, the body or the session.
+ * Everything it needs arrives as an argument, which is what lets the
+ * dispatcher reach it through `await import(...)` at the call rather than
+ * a static import.
+ *
+ * That laziness is load-bearing, not stylistic. The PTY manifest gate
+ * classifies a test by the RESOURCE closure of what it imports, so a
+ * static `node:child_process` anywhere in dispatch.ts reclassifies every
+ * test that imports dispatch — a millisecond-long parser test for `!cmd`
+ * was moved into the single-file-serial pool by this module's first
+ * shape. A module the dispatcher only loads when the key is pressed is
+ * honestly outside that closure: nothing that merely imports the
+ * dispatcher can spawn anything.
+ *
+ * The failure contract is the whole point of the return type: `null`
+ * means KEEP WHAT WAS THERE. A failed edit must not eat what the human
+ * had already written.
+ */
+/**
+ * Run `bin` on `text` and return what came back, or `null` when the edit
+ * failed — in which case `onFailure` has already been told, in one line,
+ * what went wrong.
+ *
+ * @param root  the directory temp files live under (`$KISO_HOME/tmp`)
+ */
+export declare function runExternalEditor(bin: string, root: string, text: string, onFailure: (line: string) => void): string | null;

package/dist/external-editor.js

@@ -0,0 +1,55 @@
+/**
+ * §2.4 — the RUN half of ctrl+g.
+ *
+ * The dispatcher routes and this runs: it owns the temp file and the
+ * spawn, and knows nothing about the composer, the body or the session.
+ * Everything it needs arrives as an argument, which is what lets the
+ * dispatcher reach it through `await import(...)` at the call rather than
+ * a static import.
+ *
+ * That laziness is load-bearing, not stylistic. The PTY manifest gate
+ * classifies a test by the RESOURCE closure of what it imports, so a
+ * static `node:child_process` anywhere in dispatch.ts reclassifies every
+ * test that imports dispatch — a millisecond-long parser test for `!cmd`
+ * was moved into the single-file-serial pool by this module's first
+ * shape. A module the dispatcher only loads when the key is pressed is
+ * honestly outside that closure: nothing that merely imports the
+ * dispatcher can spawn anything.
+ *
+ * The failure contract is the whole point of the return type: `null`
+ * means KEEP WHAT WAS THERE. A failed edit must not eat what the human
+ * had already written.
+ */
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Run `bin` on `text` and return what came back, or `null` when the edit
+ * failed — in which case `onFailure` has already been told, in one line,
+ * what went wrong.
+ *
+ * @param root  the directory temp files live under (`$KISO_HOME/tmp`)
+ */
+export function runExternalEditor(bin, root, text, onFailure) {
+    // per INVOCATION, not per run: a directory per call is how the tree
+    // grew 400,000 of them once.
+    mkdirSync(root, { recursive: true });
+    const dir = mkdtempSync(join(root, "compose-"));
+    const file = join(dir, "message.md"); // .md so the editor lights it up
+    try {
+        writeFileSync(file, text, "utf8");
+        const r = spawnSync(bin, [file], { stdio: "inherit", shell: false });
+        if (r.error !== undefined || (r.status !== null && r.status !== 0)) {
+            onFailure(`[ctrl+g] ${bin} exited ${r.status ?? "abnormally"} — the composer is unchanged`);
+            return null;
+        }
+        return readFileSync(file, "utf8").replace(/\n+$/, "");
+    }
+    catch (err) {
+        onFailure(`[ctrl+g] ${err instanceof Error ? err.message : String(err)} — the composer is unchanged`);
+        return null;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}