@vincemakes/kiso-code 0.8.0 → 0.10.0

package/dist/chat.d.ts

@@ -45,6 +45,10 @@ export interface UsageDelta {
      *  recovers on the next known event). */
     readonly total: number | null;
     readonly missed: number | null;
+    /** TUI2-R1 (E): the CANONICAL cost of this request — null when the
+     *  pricing table has no rate for the route (the R5b-④c absent stamp).
+     *  Null is carried, never zeroed: a missing rate is not a free call. */
+    readonly costUsd: number | null;
 }
 /**
  * The CLI's usage consumer (E2 1.3.0, the R2a-1 ruling 2026-08-13) — the
@@ -76,6 +80,7 @@ export declare function usageFromEvent(route: string | undefined, ev: import("@v
  *  is gone) — docked only, 200ms rotation between the request and the
  *  first event. */
 export declare function startStatusSpinner(onTick: (glyph: string) => void): () => void;
+export declare function startShellTail(sessionId: string, callId: string, command: string, startedAt: number): () => void;
 /**
  * Consume a run, answering approval pauses as they arrive. `resumeMode`
  * marks a session.resume() continuation. `faux` picks the status line's
@@ -84,7 +89,7 @@ export declare function startStatusSpinner(onTick: (glyph: string) => void): ()
  * echo is UI, the chip is the record; the momentary double-render is
  * the design's explicit point).
  */
-export declare function consumeRun(session: AgentSession, run: Run, input: LineInput, turnNo: number, faux: boolean, statusCb: ((usage: RunUsage, ctxRatio: number) => void) | null, 
+export declare function consumeRun(session: AgentSession, run: Run, input: LineInput, turnNo: number, faux: boolean, statusCb: ((usage: RunUsage, ctxRatio: number, costUsd?: number | null) => void) | null, 
 /** W21: the amend words ("Yes + feedback") ride the NEXT user turn —
  *  threaded from chat's submitTurn; absent in the recovery flow
  *  (resume) where a dropped amend is noticed instead. */

package/dist/chat.js

@@ -4,10 +4,10 @@
  * approval-moment mini-diff, the status spinner, and the context
  * estimates. All bodies moved verbatim from index.ts.
  */
-import { readFileSync } from "node:fs";
-import { escapeTerminal, idleStatus, palette, renderEvent, renderRecap, runningStatus, toolTarget, STATUS_GLYPHS, } from "@vincemakes/kiso-tui";
+import { readFileSync, statSync } from "node:fs";
+import { escapeTerminal, cacheHitPct, idleStatus, palette, renderEvent, renderRecap, runningStatus, toolTarget, STATUS_GLYPHS, } from "@vincemakes/kiso-tui";
 import { editFileDiff, writeFileDiff } from "@vincemakes/kiso-tui";
-import { canonicalTargetPath } from "@vincemakes/kiso-tools-node";
+import { canonicalTargetPath, shellProgressPath } from "@vincemakes/kiso-tools-node";
 import { canonicalizeUsage } from "@vincemakes/kiso-runtime";
 import { dispatch } from "./dispatch.js";
 import { agentModel, body, bodyLog, configuredWindow, dock } from "./state.js";
@@ -89,7 +89,7 @@ export function usageFromEvent(route, ev, prevTotal) {
         const m = Math.min(prevTotal, total) - c.cacheRead;
         missed = m > CACHE_MISS_FLOOR ? m : null;
     }
-    return { usage: { in: c.input, out: c.output, cache: c.cacheRead, known: ev.known }, total, missed };
+    return { usage: { in: c.input, out: c.output, cache: c.cacheRead, known: ev.known }, total, missed, costUsd: c.costUsd };
 }
 /** v2b: the spinner merged into the STATUS BAR (the v2a standalone glyph
  *  is gone) — docked only, 200ms rotation between the request and the
@@ -105,6 +105,45 @@ export function startStatusSpinner(onTick) {
     timer.unref();
     return () => clearInterval(timer);
 }
+/**
+ * TUI2-R1 (C) — the shell tailer: the READER half of the progress
+ * sidecar (the writer is the shell tool, tools-node).
+ *
+ * The CLI is the only place that holds both facts the derived key needs
+ * — the session's id and the running call's command — so the tail is
+ * read here and handed to the cell. A poll, not a watcher: fs.watch's
+ * behaviour on a file being appended to differs by platform, and the
+ * one thing this must never do is misbehave in a way that costs the run.
+ *
+ * THE FRESHNESS GUARD is the part that makes a kill -9 leftover
+ * harmless. A sidecar the writer never got to remove keeps its old
+ * mtime; a tail is read only from a file modified AT OR AFTER the call
+ * started. A ghost from a previous process cannot be shown as this
+ * call's output — and since the tail is display-only, showing nothing is
+ * always the safe answer.
+ */
+const TAIL_POLL_MS = 250;
+const TAIL_BYTES = 4096; // the last lines are all the window can hold
+export function startShellTail(sessionId, callId, command, startedAt) {
+    const path = shellProgressPath(sessionId, command);
+    const read = () => {
+        try {
+            const stat = statSync(path);
+            if (stat.mtimeMs + 1000 < startedAt)
+                return; // a ghost from a killed run — never this call's
+            const text = readFileSync(path, "utf8");
+            body.toolProgress(callId, text.slice(-TAIL_BYTES).trimEnd());
+        }
+        catch {
+            // no sidecar yet, removed at settle, or unreadable — the tail
+            // is an observation, and its absence is never an error
+        }
+    };
+    read();
+    const timer = setInterval(read, TAIL_POLL_MS);
+    timer.unref();
+    return () => clearInterval(timer);
+}
 /** v2e: the approval-moment mini-diff — edit_file/write_file changes as
  *  ± lines; other tools get null (no diff, no cost). The file read is
  *  best-effort: an unreadable file yields NO diff, never a failure —
@@ -128,7 +167,9 @@ function approvalDiff(name, input) {
             const replace = typeof input.replace === "string" ? input.replace : "";
             if (search === "")
                 return null;
-            return editFileDiff(oldContent ?? "", search, replace);
+            // TUI2-R1.5 ② (VD-2): the path rides along so a miss can name the
+            // file in its honest note instead of fabricating a diff.
+            return editFileDiff(oldContent ?? "", search, replace, path);
         }
         const content = typeof input.content === "string" ? input.content : "";
         return writeFileDiff(oldContent, content);
@@ -268,6 +309,16 @@ submitTurn) {
     // at the first non-thinking event (the fold needs the seconds).
     let thoughtSeconds = 0;
     let thinkingSince = null;
+    // TUI2-R1 (C): the shell commands seen this run, and the tailers
+    // running for them. A tailer is started when the execution starts and
+    // stopped at the call's result — and the finally below stops any that
+    // an abort left behind, so a poller can never outlive its run.
+    const shellCommands = new Map();
+    const tailers = new Map();
+    const stopTail = (callId) => {
+        tailers.get(callId)?.();
+        tailers.delete(callId);
+    };
     try {
         for await (const ev of run) {
             last = ev;
@@ -295,10 +346,18 @@ submitTurn) {
                     if (ev.name === "edit_file")
                         editCount += 1;
                     body.toolStart(ev.name, ev.callId, ev.input ?? {});
+                    // TUI2-R1 (C): the command is the sidecar key's other half —
+                    // remembered here, used when the execution actually starts.
+                    if (ev.name === "shell" && typeof ev.input?.command === "string")
+                        shellCommands.set(ev.callId, ev.input.command);
                     break;
-                case "tool_execution_started":
+                case "tool_execution_started": {
                     body.toolRunning(ev.callId);
+                    const command = shellCommands.get(ev.callId);
+                    if (command !== undefined)
+                        tailers.set(ev.callId, startShellTail(session.id, ev.callId, command, Date.now()));
                     break;
+                }
                 case "tool_execution_succeeded":
                     body.toolSucceeded(ev.callId);
                     break;
@@ -306,6 +365,9 @@ submitTurn) {
                     body.toolFailed(ev.callId, ev.error);
                     break;
                 case "tool_result": {
+                    // TUI2-R1 (C): the observation window closes the instant the
+                    // real result exists — the tail must never race it.
+                    stopTail(ev.callId);
                     const text = typeof ev.content === "string" ? ev.content : "";
                     // W19: a DENIED call carries its reason — extracted from the
                     // result's "[Permission denied] " prefix, keyed on the
@@ -340,7 +402,9 @@ submitTurn) {
                     usage = delta.usage;
                     prevTotal = delta.total;
                     missed = delta.missed;
-                    statusCb?.(usage, estimateCtxRatio(session));
+                    // TUI2-R1 (E): the request's canonical cost rides the same
+                    // callback the usage does — one settled request, one addition.
+                    statusCb?.(usage, estimateCtxRatio(session), delta.costUsd);
                     break;
                 }
                 case "uncertain_pending":
@@ -471,6 +535,11 @@ submitTurn) {
         body.thinkingEnd(); // a trailing thinking block folds at the run's end
     }
     finally {
+        // TUI2-R1 (C): an abort or a throw leaves the loop without a
+        // tool_result — every tailer stops here regardless, so no poller
+        // outlives the run that started it.
+        for (const callId of [...tailers.keys()])
+            stopTail(callId);
     }
     return last;
 }
@@ -639,6 +708,11 @@ export async function chat(session, faux, input, autoCompact) {
     // glyph (▖▘▝▗ — the spinner drives it) + wall seconds + ↓ out tokens
     // + the interrupt hint. ctx left is the live estimate everywhere.
     let runUsage = { in: null, out: null, cache: null, known: false };
+    // TUI2-R1 (E): the session's spend so far — the CANONICAL cost of every
+    // request this process has seen, summed. Null stays null: a route with
+    // no rate in the pricing table contributes nothing and the row shows no
+    // $ at all, because a partial total presented as a total is a lie.
+    let spentUsd = null;
     let runGlyph = "▖";
     let runStart = Date.now();
     // KC2 §5: the STATE (the glyph, the run's start, the usage, the dock)
@@ -651,13 +725,42 @@ export async function chat(session, faux, input, autoCompact) {
     // parentheses idiom names the read-only constraint. The tier is the
     // CALLER's word (the recovery flow passes the bare mode).
     const paintIdle = () => {
-        if (dock.active)
-            dock.setStatus(idleStatus(getMode() === "plan" ? "plan (read-only)" : getMode(), agentModel, estimateCtxRatio(session)));
+        if (!dock.active)
+            return;
+        // TUI2-R1 (E): the meter rides the idle row — both fields omitted
+        // when unknown, so a session that has not called the model paints
+        // exactly the pre-round row.
+        dock.setStatus(idleStatus(getMode() === "plan" ? "plan (read-only)" : getMode(), agentModel, estimateCtxRatio(session), {
+            cacheHitPct: cacheHitPct(runUsage),
+            costUsd: spentUsd,
+        }));
     };
-    const statusCb = (u, ctx) => {
+    // TUI2-R2 ⑥ — the BOOT status line. The row is the product's one
+    // persistent claim about itself (the tier, how to change it, the model,
+    // the context left), and it used to appear after turn ONE: the
+    // idle-fresh screen — the screen every session opens on — showed an
+    // empty row where all of that belongs.
+    //
+    // Nothing had to be computed to fix it. paintIdle already had every
+    // field at this point: the mode is set before the agent is built, the
+    // model is resolved inside it, and an unstarted session's context
+    // estimate is a perfectly good 100%. It was simply never called until
+    // a turn ended. One call, and the SAME formatter — a boot-time copy of
+    // the row would drift from the real one the moment either changed.
+    paintIdle();
+    const statusCb = (u, ctx, costUsd) => {
         runUsage = u;
+        addCost(costUsd ?? null);
         paintRunning();
     };
+    // TUI2-R1 (E): the canonical cost of one settled request, added to the
+    // session's running total. A null cost (no rate for the route) adds
+    // nothing and leaves the total as it was.
+    const addCost = (usd) => {
+        if (usd === null)
+            return;
+        spentUsd = (spentUsd ?? 0) + usd;
+    };
     const submitTurn = (line) => {
         const slot = { line, cancelled: false };
         pendingTurns.push(slot);
@@ -717,6 +820,7 @@ export async function chat(session, faux, input, autoCompact) {
         paintIdle,
         submitTurn,
         estimateCtx: () => estimateCtxRatio(session),
+        contextWindow: () => contextWindowTokens(),
     };
     // the ergonomics batch C8: the auto-compact check — the /compact FULL path via the
     // shared dispatch (same notices, same chain ordering, same mid-run
@@ -756,6 +860,15 @@ export async function chat(session, faux, input, autoCompact) {
         const recoveryRun = session.resume();
         currentRun = recoveryRun;
         turnNo += 1;
+        // TUI2-R1.5 ③ (VD-3 family): stamp the run's start AT the run's
+        // entry. Every other run path does; this one inherited the value
+        // from the process's own startup, so its "working Ns" was the
+        // session's age rather than the recovery's. The drift is small
+        // today (recovery follows startup closely) and unbounded in
+        // principle — a slow MCP connect is seconds the recovery never
+        // spent, reported as seconds it did.
+        runStart = Date.now();
+        runUsage = { in: null, out: null, cache: null, known: false };
         const last = await consumeRun(session, recoveryRun, input, turnNo, faux, statusCb, submitTurn);
         currentRun = null;
         failOnFauxExhaustion(last, faux, input);

package/dist/dispatch.d.ts

@@ -22,6 +22,9 @@ export interface DispatchCtx {
     readonly submitTurn: (line: string) => void;
     /** the /status context estimate. */
     readonly estimateCtx: () => number;
+    /** TUI2-R1 (E): the model's context window, as the session is
+     *  configured — the /context ledger's denominator. */
+    readonly contextWindow: () => number;
 }
 /** The ONE dispatcher — slash commands, exit, and turns. The recovery
  *  replay routes through it too — a queued "/last" must never become a

package/dist/dispatch.js

@@ -3,10 +3,10 @@
  * turns. The bodies moved verbatim from chat()'s closure; chat provides
  * the context (the chain, the run state, the prompt arming).
  */
-import { escapeTerminal, helpRows, kUnit, palette } from "@vincemakes/kiso-tui";
+import { contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpRows, kUnit, modelPickView, palette } from "@vincemakes/kiso-tui";
 import { buildAdapter } from "@vincemakes/kiso-runtime/internal";
 import { MODES, getMode, setMode } from "./mode.js";
-import { agentModel, body, bodyLog, configModels, dock, setAgentModel, setCurrentModelName } from "./state.js";
+import { agentModel, body, bodyLog, configModels, dock, readContextLedger, setAgentModel, setCurrentModelName } from "./state.js";
 import { directWriteProfile, profileAvailable } from "./config.js";
 /** The ONE dispatcher — slash commands, exit, and turns. The recovery
  *  replay routes through it too — a queued "/last" must never become a
@@ -23,8 +23,10 @@ export function dispatch(line, ctx) {
         // the last one still carries its own \n, so `exit` and `keys`
         // land as two rows from one call (bodyLog splits on \n).
         ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            // TUI2-R1.5 9 (VD-10): /help is sentences for a human — the keys
+            // row in particular is one long line that hard-folded mid-word.
             for (const row of helpRows())
-                bodyLog(row);
+                bodyLog(row, "words");
             ctx.input.prompt();
         });
         return;
@@ -54,9 +56,21 @@ export function dispatch(line, ctx) {
                 bodyLog("[no tool call yet]");
             }
             else {
-                bodyLog(`--- ${tool.name} input ---`);
+                // TUI2-R2pre ④: the SECTION HEADERS say the act ("--- read
+                // input ---") on the interactive SCREEN; the two payloads
+                // between them are the RAW input JSON and the RAW result
+                // content and are byte-identical either way.
+                //
+                // The dock check is the round's one conditional, and it is
+                // deliberate: /last is a single code path serving two
+                // surfaces, and the ruling covers the screen while the pipe
+                // is a machine-readable log whose bytes other things (the
+                // e2e gates, anyone's script) already depend on. Without the
+                // dock, this is that log — so it keeps the call's own name.
+                const verb = dock.active ? displayVerb(tool.name) : tool.name;
+                bodyLog(`--- ${verb} input ---`);
                 bodyLog(escapeTerminal(JSON.stringify(tool.input, null, 2)));
-                bodyLog(`--- ${tool.name} output${tool.result.isError ? " (error)" : ""} ---`);
+                bodyLog(`--- ${verb} output${tool.result.isError ? " (error)" : ""} ---`);
                 bodyLog(escapeTerminal(tool.result.content));
             }
             ctx.input.prompt();
@@ -92,6 +106,30 @@ export function dispatch(line, ctx) {
         ctx.chainRef.current = ctx.chainRef.current.then(land);
         return;
     }
+    if (trimmed === "/context") {
+        // TUI2-R1 (E): the rent-ledger attribution — where the context went,
+        // read from the session's TRACE SIDECAR (the observation file E1/E3
+        // already write, per request).
+        //
+        // THE PURITY GATE IS UNTOUCHED and this is why: the trace surface is
+        // an OBSERVATION surface (ADR-0051 §6, ruling R7) and correctness
+        // never reads it. /context is a DISPLAY command — nothing it reads
+        // reaches a recovery plan, a projection, or a request. The read is
+        // best-effort by construction: a missing, partial or unparseable
+        // ledger renders the honest fallback, never an error and never a
+        // guess. recovery-purity.test.ts's probes are unaffected: the
+        // derivation still does zero I/O and still ignores trace-shaped data.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const ledger = readContextLedger(ctx.session.id, ctx.contextWindow());
+            for (const row of ledger === null
+                ? contextUnavailableRows("the ledger is written per request — run a turn, then ask again")
+                : contextRows(ledger)) {
+                bodyLog(row);
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
     if (trimmed === "/status") {
         // B area: session id, durable event count, and the ~ context
         // estimate — all read straight from the live session, nothing
@@ -136,7 +174,39 @@ export function dispatch(line, ctx) {
         // session's adapter — the NEXT turn uses it (session.setAdapter),
         // the notice cell leaves the audit line in the body.
         ctx.chainRef.current = ctx.chainRef.current.then(async () => {
-            const arg = trimmed.slice(6).trim();
+            let arg = trimmed.slice(6).trim();
+            // TUI2-R2 ④ — bare /model PICKS. It used to print a list and a
+            // sentence telling you to go and edit a JSON file: everything
+            // needed to make it a choice was already on screen, and only the
+            // choosing was missing. The panel adds the choosing and nothing
+            // else — what a switch MEANS is unchanged below, and the printed
+            // list survives verbatim wherever there is no panel to draw (a
+            // pipe, a dock-less TTY), because that is a machine-readable
+            // surface and this round moves no bytes on one.
+            if (arg === "" && dock.active && ctx.input.panelAsk !== undefined) {
+                const names = Object.keys(configModels);
+                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"] : [])];
+                            return { label: `${profile.kind}/${profile.model}`, note: marks.join(" · ") };
+                        }),
+                        typeHint: names.length === 0 ? "type provider/model directly (e.g. openai/deepseek-reasoner)" : "type provider/model directly",
+                        // the zero-profile copy is TODAY'S, verbatim: the
+                        // user who sees it is exactly the user who needs
+                        // the path spelled out
+                        ...(names.length === 0 ? { emptyNote: "no profiles — define models in ~/.kiso/config.json" } : {}),
+                    }, ctx.isRunning() ? "▸ run paused" : `▸ ${getMode()}`), (v) => 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 (arg === "") {
                 bodyLog(`model: ${agentModel}`);
                 const names = Object.keys(configModels);

package/dist/index.js

@@ -26,19 +26,20 @@ import { readFileSync, realpathSync, rmSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
 import { join } from "node:path";
-import { Body, Editor, bannerLines, escapeTerminal, extensionsBannerText, interactivePrompt, palette, renderSessionLine } from "@vincemakes/kiso-tui";
+import { Body, Editor, bannerLines, escapeTerminal, extensionsBannerText, idColumn, idleStatus, interactivePrompt, palette, renderSessionLine, sessionListFooter, sessionListRow } from "@vincemakes/kiso-tui";
 import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions, SessionStore, } from "@vincemakes/kiso-runtime";
 import { createFauxProvider } from "@vincemakes/kiso-evals";
 import { createCodingTools } from "@vincemakes/kiso-tools-node";
-import { MODES, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
+import { MODES, getMode, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
 import { builtInLayer } from "./builtin.js";
-import { atFiles, body, bodyLog, builtInExtensions, currentFaux, dock, extensionsDir, loadedExtensions, mergedConfig, mergedTempPaths, projectExtensions, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentAgentExtensions, setCurrentFaux, setCurrentModelName, setExtensionLists, setMergedConfig, userExtensions, VERSION } from "./state.js";
+import { agentModel, atFiles, body, bodyLog, builtInExtensions, currentFaux, dock, extensionsDir, loadedExtensions, mergedConfig, mergedTempPaths, projectExtensions, sessionStoreRef, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentAgentExtensions, setCurrentFaux, setCurrentModelName, setExtensionLists, setMergedConfig, setSessionStore, userExtensions, VERSION } from "./state.js";
 import { askUi, resolveProjectTrust } from "./trust-ui.js";
 import { isFirstRun, scaffoldFirstRun } from "./first-run.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
-import { autoCompactFromEnv, chat, contextWindowTokens } from "./chat.js";
+import { autoCompactFromEnv, chat, contextWindowTokens, estimateCtxRatio } from "./chat.js";
 import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, resolveContextWindow, resolveModel } from "./config.js";
 import { resume } from "./resume.js";
+import { collectSessionCards } from "./session-cards.js";
 // The moved exports stay reachable from this entry — the test imports
 // (project-trust, coding-agent) never change (B4: zero assertion changes).
 export { applyProjectMerges } from "./trust-ui.js";
@@ -159,6 +160,12 @@ function editorInput(editor) {
         panelCancel() {
             editor.cancelPanel();
         },
+        // TUI2-R2 ②: the session picker — the editor owns the keys (the
+        // selection walk, the filter, enter/esc), the compositor draws the
+        // band, and the id comes back here.
+        pick(cards, onPick) {
+            editor.beginPick(cards, onPick);
+        },
         // W22: the pending-turn queue — the ↑ pop walk (the keys); the
         // chips are the compositor's bindQueue (the dock side).
         bindQueue(state, pop) {
@@ -199,6 +206,8 @@ function makeLineInput() {
         editor.bindAtItems(atFiles); // KC3 §5: the file source — listed per OPEN
         dock.bindAt(() => editor.atState()); // KC3 §4: the picker's band
         dock.bindApproval(() => editor.panelState()); // W21: the panel's bound state
+        dock.bindSheet(() => editor.sheetOpen()); // TUI2-R1 (D): the ? keys sheet
+        dock.bindPick(() => editor.pickState()); // TUI2-R2 ②: the resume picker's band
         return editorInput(editor);
     }
     return readlineInput(createInterface({ input: process.stdin, output: process.stdout }));
@@ -356,6 +365,9 @@ async function makeAgent(sessionId, input, modelFlag) {
     if (isFirstRun())
         scaffoldFirstRun();
     const store = new SessionStore(sessionsDir());
+    // TUI2-R2 ②/③: the navigation surfaces read through THIS store — one
+    // store per process, and the picker/listing never write through it.
+    setSessionStore(store);
     // E area: the durable script position — computed AFTER the verdict
     // (fauxSkip's session-log read is a home read: pre-trust zero-read).
     const fauxSkipTurns = sessionId === undefined ? 0 : fauxSkip(sessionId);
@@ -441,6 +453,74 @@ async function makeAgent(sessionId, input, modelFlag) {
     };
     return createAgent(definition);
 }
+/** TUI2-R2 ② — the picker's affordance row: the keys, said where the
+ *  keys are useful. */
+const PICKER_HINT = "↑↓ pick · ⏎ resumes · type filters · esc";
+/**
+ * TUI2-R2 ①–③ — the listing's cards. The projection consumes the
+ * runtime's own accessors (see session-cards.ts); this is only the
+ * plumbing that hands it the store's read side.
+ */
+async function sessionCards(agent) {
+    const store = sessionStoreRef;
+    if (store === null)
+        return []; // unreachable: makeAgent builds the store first
+    return collectSessionCards(agent, (id) => store.load(id));
+}
+/**
+ * TUI2-R2 ② — the resume picker: the band, the keys, the id.
+ *
+ * The status row carries the picker's own affordance while it is up
+ * (a surface teaches its keys where the keys are useful), and the
+ * promise settles on the editor's commit — the id the human took, or
+ * null when they left. The picker path WRITES NOTHING: the cards are a
+ * projection over what is already on disk.
+ */
+async function pickSession(agent, input) {
+    const cards = await sessionCards(agent);
+    if (cards.length === 0) {
+        bodyLog("no sessions yet \u2014 `kiso` starts one");
+        return null;
+    }
+    // a dock-less TTY (rows < 4) has no band to draw the picker in, so the
+    // honest answer is the usage line this command has always printed.
+    if (input.pick === undefined || !dock.active) {
+        console.error('usage: kiso resume <sessionId> ["prompt"]');
+        process.exit(2);
+    }
+    dock.setStatus("", PICKER_HINT);
+    const picked = await new Promise((resolve) => {
+        input.pick(() => cards, resolve);
+    });
+    dock.setStatus("", null);
+    return picked;
+}
+/**
+ * TUI2-R2 ⑥ — the BOOT status row.
+ *
+ * The status line is the product's one persistent claim about itself,
+ * and it used to appear after turn ONE: the idle-fresh screen — the
+ * screen every session opens on, and the only screen a first-time user
+ * sees before deciding whether to type — showed an empty row where the
+ * tier, the /mode hint, the model and the remaining context belong.
+ *
+ * It is painted HERE, at the first moment every field is TRUE: after
+ * makeAgent, because that is where the model is resolved. Painting it at
+ * dock.enter() — the literally-first frame — would have to name a model
+ * nobody had chosen yet, and a status row that guesses is worse than a
+ * status row that waits two hundred milliseconds.
+ *
+ * The meter fields (cache rate, cost) are deliberately absent: an
+ * unstarted session has made no requests, and an unmeasured cache is not
+ * a 0% cache. chat()'s own paintIdle takes over from here with the same
+ * formatter — never a boot-time copy, which would drift from the real
+ * row the moment either changed.
+ */
+function paintBootStatus(session) {
+    if (!dock.active)
+        return;
+    dock.setStatus(idleStatus(getMode() === "plan" ? "plan (read-only)" : getMode(), agentModel, estimateCtxRatio(session)));
+}
 async function main() {
     // E group (the graceful-exit gate ③, R-G 0.1.48): a terminal closing
     // turns the in-flight stdout/stderr writes into EIO, and node's
@@ -526,11 +606,17 @@ async function main() {
                 bodyLog(`session ${id}\n`);
                 extensionsBanner(recentSessions(id, agent));
                 faux = currentFaux;
+                paintBootStatus(session); // TUI2-R2 ⑥: the idle-fresh screen says what it is
                 await chat(session, faux, input, resolveAutoCompact(mergedConfig));
                 break;
             }
             case "resume": {
-                if (!arg) {
+                // TUI2-R2 ② — bare `kiso resume` opens the PICKER, but only
+                // where there is a human to pick: a pipe keeps today's usage
+                // error and today's exit 2, byte for byte. Finding an id used
+                // to mean running `kiso sessions` and copying one out by eye;
+                // the picker is that step, done by the product.
+                if (!arg && !process.stdin.isTTY) {
                     console.error("usage: kiso resume <sessionId> [\"prompt\"]");
                     process.exit(2);
                 }
@@ -540,8 +626,25 @@ async function main() {
                 dock.enter();
                 agent = await makeAgent(arg, input, modelFlag);
                 applyConfigMode();
-                const session = await agent.session({ id: arg });
+                let id = arg;
+                if (id === undefined) {
+                    const picked = await pickSession(agent, input);
+                    // esc: the human looked and chose not to resume. That is a
+                    // normal outcome, so it exits 0 with nothing said — never
+                    // an error, never a session started behind their back.
+                    if (picked === null)
+                        break;
+                    id = picked;
+                }
+                const session = await agent.session({ id });
                 faux = currentFaux;
+                // E area: the durable script position is computed from the
+                // session id, and on the picker path the id did not exist when
+                // makeAgent ran. Re-arm the scripted adapter at the PICKED
+                // session's position so a picked resume continues its script
+                // exactly where `kiso resume <id>` would have.
+                if (faux && arg === undefined)
+                    session.setAdapter(createFauxProvider(readFauxScript().slice(fauxSkip(id))));
                 await resume(session, prompt, faux, input);
                 break;
             }
@@ -555,8 +658,23 @@ async function main() {
                 // exists so the gate's ask can be answered; the listing
                 // itself never touches it.
                 agent = await makeAgent(undefined, input, modelFlag);
-                for (const meta of agent.sessions()) {
-                    console.log(renderSessionLine(meta));
+                // TUI2-R2 ③ — the same projection the picker renders, printed.
+                // The PIPE keeps today's bytes exactly: `kiso sessions` is
+                // something scripts read, and a badge column is a TTY-render
+                // concern, not a change to a machine interface.
+                if (process.stdout.isTTY) {
+                    const cards = await sessionCards(agent);
+                    const W = process.stdout.columns ?? 80;
+                    const col = idColumn(cards);
+                    const now = Date.now();
+                    for (const card of cards)
+                        console.log(sessionListRow(card, W, now, col));
+                    console.log(sessionListFooter(cards.length, W));
+                }
+                else {
+                    for (const meta of agent.sessions()) {
+                        console.log(renderSessionLine(meta));
+                    }
                 }
                 break;
             }
@@ -593,6 +711,7 @@ async function main() {
                 // session surfaced as "[faux mode] the scripted model failed:
                 // <real error>" (a false accusation of the keyless demo).
                 faux = currentFaux;
+                paintBootStatus(session); // TUI2-R2 ⑥: the same row on the bare command
                 await chat(session, faux, input, autoCompactFromEnv());
                 break;
             }

package/dist/session-cards.d.ts

@@ -0,0 +1,100 @@
+/**
+ * TUI2-R2 slice ① — the state projection: a session's durable log →
+ * the card the picker and the listing both render.
+ *
+ * The card is a PURE PROJECTION and this file adds no facts. Every field
+ * comes from a durable event the product already writes, read through the
+ * runtime's OWN accessors:
+ *
+ *   openRunId(records)        — recovery's own "is a run still open?"
+ *                               (the ▌ brick: no terminal event)
+ *   executionLedger(events)   — the L2 ledger's own uncertain status
+ *                               (started, no receipt — the crash window)
+ *   pendingApprovals()        — the session's own live-ask accessor
+ *                               (decided/expired/dead-run all excluded)
+ *   the `terminal` event      — its outcome kind, read as written
+ *
+ * Nothing here re-implements any of them. That is the point: a badge is a
+ * claim about what `kiso resume` will do, and the only way it can never
+ * lie is for it to be derived from the same facts the resume derives
+ * from. A second derivation — however careful — is a second source of
+ * truth, and two sources of truth about durability is none.
+ *
+ * The projection is read-only by construction: it loads and it counts.
+ * The R-I-p2 rule (a listing never writes) holds trivially — there is no
+ * write call in this file, and the accessors it calls have none either.
+ *
+ * What a human READS about a card is presentation and lives in the
+ * terminal layer (sessionNote — the KC3 §1 split); this file owns the
+ * FACTS.
+ */
+import { type StoreRecord } from "@vincemakes/kiso-runtime/internal";
+/** The five durable states, in the order the projection resolves them. */
+export type SessionBadge = "uncertain" | "ask" | "interrupted" | "completed" | "failed";
+export interface SessionCard {
+    readonly id: string;
+    readonly badge: SessionBadge;
+    /** The human's unit: one user_input is one turn. (SessionMeta.runs
+     *  counts runIds, which a resume increments without the human having
+     *  said anything — that is a different number and not the one a
+     *  picker row means.) */
+    readonly turns: number;
+    /** The last record's own stamp — the store's `updatedAt`, never a
+     *  file mtime (a copied home would lie about every age). */
+    readonly updatedAt: number;
+    /** The uncertain ledger's size — the ? badge's count. */
+    readonly uncertain: number;
+    /** The unanswered permission requests — the ◌ badge's count. */
+    readonly asks: number;
+    /** The terminal outcome's kind, when the run ended; null while it is
+     *  open. The ✗ note names it rather than inventing one word for six
+     *  different endings. */
+    readonly outcome: string | null;
+}
+/**
+ * The projection. `asks` arrives as DATA because its accessor lives on
+ * the session object (pendingApprovals) rather than on the record list —
+ * passing the count keeps this function pure and unit-testable over a
+ * fixture the real writer produced.
+ *
+ * The precedence, and why it is this one:
+ *
+ *   1. uncertain — the spec's explicit override. An interrupted run that
+ *      also holds an undecided side effect cannot resume until a human
+ *      rules on it, so the badge must show the blocking condition, not
+ *      the recoverable one.
+ *   2. ask — an unanswered question is likewise the thing standing
+ *      between the session and its own continuation.
+ *   3. interrupted — no terminal event: the run was cut mid-flight.
+ *   4/5. the terminal's own verdict.
+ */
+export declare function projectSessionCard(input: {
+    readonly id: string;
+    readonly updatedAt: number;
+    readonly records: readonly StoreRecord[];
+    readonly asks: number;
+}): SessionCard;
+/** The shapes this module needs from the agent — structural, so the
+ *  projection is testable without standing up a provider. */
+interface CardSource {
+    sessions(): readonly {
+        readonly id: string;
+        readonly updatedAt: number;
+    }[];
+    session(options: {
+        id: string;
+    }): Promise<{
+        pendingApprovals(): readonly unknown[];
+    }>;
+}
+/**
+ * The listing's cards, newest first — the order both the picker and
+ * `kiso sessions` want (the thing you just left is the thing you are
+ * most likely coming back for).
+ *
+ * The session object exists ONLY to read pendingApprovals(): opening one
+ * loads its records and builds an event log, and writes nothing (no
+ * lock, no file creation) — the read-only listing rule holds.
+ */
+export declare function collectSessionCards(agent: CardSource, load: (id: string) => readonly StoreRecord[]): Promise<SessionCard[]>;
+export {};

package/dist/session-cards.js

@@ -0,0 +1,95 @@
+/**
+ * TUI2-R2 slice ① — the state projection: a session's durable log →
+ * the card the picker and the listing both render.
+ *
+ * The card is a PURE PROJECTION and this file adds no facts. Every field
+ * comes from a durable event the product already writes, read through the
+ * runtime's OWN accessors:
+ *
+ *   openRunId(records)        — recovery's own "is a run still open?"
+ *                               (the ▌ brick: no terminal event)
+ *   executionLedger(events)   — the L2 ledger's own uncertain status
+ *                               (started, no receipt — the crash window)
+ *   pendingApprovals()        — the session's own live-ask accessor
+ *                               (decided/expired/dead-run all excluded)
+ *   the `terminal` event      — its outcome kind, read as written
+ *
+ * Nothing here re-implements any of them. That is the point: a badge is a
+ * claim about what `kiso resume` will do, and the only way it can never
+ * lie is for it to be derived from the same facts the resume derives
+ * from. A second derivation — however careful — is a second source of
+ * truth, and two sources of truth about durability is none.
+ *
+ * The projection is read-only by construction: it loads and it counts.
+ * The R-I-p2 rule (a listing never writes) holds trivially — there is no
+ * write call in this file, and the accessors it calls have none either.
+ *
+ * What a human READS about a card is presentation and lives in the
+ * terminal layer (sessionNote — the KC3 §1 split); this file owns the
+ * FACTS.
+ */
+import { executionLedger, openRunId } from "@vincemakes/kiso-runtime/internal";
+/**
+ * The projection. `asks` arrives as DATA because its accessor lives on
+ * the session object (pendingApprovals) rather than on the record list —
+ * passing the count keeps this function pure and unit-testable over a
+ * fixture the real writer produced.
+ *
+ * The precedence, and why it is this one:
+ *
+ *   1. uncertain — the spec's explicit override. An interrupted run that
+ *      also holds an undecided side effect cannot resume until a human
+ *      rules on it, so the badge must show the blocking condition, not
+ *      the recoverable one.
+ *   2. ask — an unanswered question is likewise the thing standing
+ *      between the session and its own continuation.
+ *   3. interrupted — no terminal event: the run was cut mid-flight.
+ *   4/5. the terminal's own verdict.
+ */
+export function projectSessionCard(input) {
+    const events = input.records.map((r) => r.event);
+    // the ledger's own expression — the same one the recovery plan and the
+    // session's uncertainExecutions() use, so the three can never disagree
+    const uncertain = [...executionLedger(events).values()].filter((r) => r.status === "uncertain").length;
+    const open = openRunId(input.records) !== undefined;
+    // the LAST terminal is the session's verdict — an older run's ending
+    // says nothing about where the session stands now
+    let outcome = null;
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (ev.type === "terminal") {
+            outcome = ev.outcome.kind;
+            break;
+        }
+    }
+    const turns = events.filter((e) => e.type === "user_input").length;
+    const badge = uncertain > 0
+        ? "uncertain"
+        : input.asks > 0
+            ? "ask"
+            : // a log with no terminal at all leaves openRunId undefined only
+                // when it is empty; either way nothing durable says it ended
+                open || outcome === null
+                    ? "interrupted"
+                    : outcome === "completed"
+                        ? "completed"
+                        : "failed";
+    return { id: input.id, badge, turns, updatedAt: input.updatedAt, uncertain, asks: input.asks, outcome };
+}
+/**
+ * The listing's cards, newest first — the order both the picker and
+ * `kiso sessions` want (the thing you just left is the thing you are
+ * most likely coming back for).
+ *
+ * The session object exists ONLY to read pendingApprovals(): opening one
+ * loads its records and builds an event log, and writes nothing (no
+ * lock, no file creation) — the read-only listing rule holds.
+ */
+export async function collectSessionCards(agent, load) {
+    const cards = [];
+    for (const meta of [...agent.sessions()].sort((a, b) => b.updatedAt - a.updatedAt)) {
+        const session = await agent.session({ id: meta.id });
+        cards.push(projectSessionCard({ id: meta.id, updatedAt: meta.updatedAt, records: load(meta.id), asks: session.pendingApprovals().length }));
+    }
+    return cards;
+}

package/dist/state.d.ts

@@ -5,8 +5,8 @@
  * creates the mutable ones (setBody / setAgentModel / setExtensionLists);
  * the moved modules read and mutate at call time.
  */
-import { Dock, type AtItem, type Body, type PanelVerdict, type PanelView } from "@vincemakes/kiso-tui";
-import type { KisoExtension } from "@vincemakes/kiso-runtime";
+import { Dock, type AtItem, type Body, type PanelVerdict, type PanelView, type SessionCardView } from "@vincemakes/kiso-tui";
+import type { KisoExtension, StoreRecord } from "@vincemakes/kiso-runtime";
 /** finding #11: KISO_HOME is the ONE root — every default path derives from
  *  it (sessions, trust, extensions, mcp config, skills). The dedicated
  *  env vars (KISO_EXTENSIONS_DIR / KISO_MCP_CONFIG / KISO_SKILLS_DIR)
@@ -15,6 +15,22 @@ export declare function kisoHome(): string;
 export declare function sessionsDir(): string;
 /** E1: the extension scan directory — KISO_EXTENSIONS_DIR overrides. */
 export declare function extensionsDir(): string;
+/**
+ * TUI2-R1 (E) — the /context ledger, read from the session's TRACE
+ * SIDECAR (<sessions>/traces/<id>.jsonl).
+ *
+ * THE PURITY GATE (ADR-0051 §6, ruling R7) IS UNTOUCHED. The trace
+ * surface is an observation surface; correctness never reads it, and
+ * this reader is on the DISPLAY path only — nothing it returns reaches a
+ * recovery plan, a projection or a request. The proof of that is the
+ * shape of this function: it is best-effort end to end, and its failure
+ * mode is `null`, which renders a sentence rather than a number.
+ *
+ * The LAST request line is the one that matters: rent is per request,
+ * and what the reader wants to know is what the NEXT request will cost,
+ * which is what the previous one cost.
+ */
+export declare function readContextLedger(sessionId: string, window: number): import("@vincemakes/kiso-tui").ContextLedger | null;
 /**
  * KC3 §5 — the @ picker's file source. Computed PER OPEN: no index, no
  * daemon, no watcher, nothing to invalidate and nothing to go stale.
@@ -67,6 +83,12 @@ export interface LineInput {
     panelAsk(view: PanelView, onCommit: (v: PanelVerdict) => void): void;
     /** W21: cancel the panel — the SIGINT pair to panelAsk. */
     panelCancel(): void;
+    /** TUI2-R2 ②: open the session picker — the editor takes the keys
+     *  (the selection walk, the filter, enter/esc) and hands back the
+     *  picked id, or null when the human leaves without picking.
+     *  OPTIONAL: only the raw-mode editor has it, and the picker only
+     *  ever opens on a TTY (a pipe has nobody to pick). */
+    pick?(cards: () => readonly SessionCardView[], onPick: (id: string | null) => void): void;
     /** W22: bind the pending-turn queue — the ↑ pop walks the CLI's
      *  live slots (each pop cancels the turn), esc ends the walk after
      *  one more pop. The chips are the compositor's own bindQueue. */
@@ -90,7 +112,17 @@ export declare let body: Body;
 export declare function setBody(value: Body): void;
 /** v2d: body output routes through the cell renderer — the single writer.
  *  bodyLog adds the trailing newline; internal newlines are preserved. */
-export declare function bodyLog(text: string): void;
+export declare function bodyLog(text: string, wrap?: "words"): void;
+/** TUI2-R2 ②/③: the session store makeAgent built — the ONE store per
+ *  process. The navigation surfaces need its read side (load) to project
+ *  the badges, and a second store on the same root would be a second
+ *  lock manager for a job that never writes. */
+export declare let sessionStoreRef: {
+    load(id: string): readonly StoreRecord[];
+} | null;
+export declare function setSessionStore(value: {
+    load(id: string): readonly StoreRecord[];
+}): void;
 /** The model name for the status bar — set by makeAgent. */
 export declare let agentModel: string;
 export declare function setAgentModel(value: string): void;

package/dist/state.js

@@ -25,6 +25,71 @@ export function sessionsDir() {
 export function extensionsDir() {
     return process.env.KISO_EXTENSIONS_DIR ?? join(kisoHome(), "extensions");
 }
+/**
+ * TUI2-R1 (E) — the /context ledger, read from the session's TRACE
+ * SIDECAR (<sessions>/traces/<id>.jsonl).
+ *
+ * THE PURITY GATE (ADR-0051 §6, ruling R7) IS UNTOUCHED. The trace
+ * surface is an observation surface; correctness never reads it, and
+ * this reader is on the DISPLAY path only — nothing it returns reaches a
+ * recovery plan, a projection or a request. The proof of that is the
+ * shape of this function: it is best-effort end to end, and its failure
+ * mode is `null`, which renders a sentence rather than a number.
+ *
+ * The LAST request line is the one that matters: rent is per request,
+ * and what the reader wants to know is what the NEXT request will cost,
+ * which is what the previous one cost.
+ */
+export function readContextLedger(sessionId, window) {
+    let last = null;
+    try {
+        const text = readFileSync(join(sessionsDir(), "traces", `${sessionId}.jsonl`), "utf8");
+        for (const line of text.split("\n")) {
+            if (line === "")
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.kind === "request")
+                    last = parsed;
+            }
+            catch {
+                // a torn last line (the writer was mid-append) — the ledger is
+                // an observation, and a partial one is simply not the answer
+            }
+        }
+    }
+    catch {
+        return null; // no sidecar — a session that has not called the model
+    }
+    if (last === null)
+        return null;
+    const rent = Array.isArray(last.rent) ? last.rent : [];
+    if (rent.length === 0)
+        return null; // a v1/v2 sidecar carries no rent block (R2-1)
+    const sum = (pred) => rent.filter((l) => typeof l.surface === "string" && pred(l.surface)).reduce((a, l) => a + (l.estTokens ?? 0), 0);
+    const count = (pred) => rent.filter((l) => typeof l.surface === "string" && pred(l.surface)).length;
+    // the skills index is broken out: it is an INDEX of workspace content,
+    // not an instruction, and it is the one append whose size is the
+    // reader's own doing.
+    const isSkills = (s) => s === "system:ext:skills";
+    const manifest = Array.isArray(last.contextManifest) ? last.contextManifest : [];
+    const turnSegments = manifest.filter((s) => s.role === "turn" || s.role === "current_turn");
+    return {
+        window,
+        systemPrompt: sum((s) => s === "system:base" || (s.startsWith("system:ext:") && !isSkills(s))),
+        systemBase: sum((s) => s === "system:base"),
+        appends: count((s) => s.startsWith("system:ext:") && !isSkills(s)),
+        toolTable: sum((s) => s.startsWith("tool:")),
+        tools: count((s) => s.startsWith("tool:")),
+        skillsIndex: sum(isSkills),
+        // the ledger records the SURFACE, never its contents — the number
+        // of skills is not in it, and 0 tells the renderer to say so.
+        skills: 0,
+        envelope: sum((s) => s === "envelope"),
+        messages: turnSegments.reduce((a, s) => a + (s.estTokens ?? 0), 0),
+        turns: turnSegments.length,
+    };
+}
 /**
  * KC3 §5 — the @ picker's file source. Computed PER OPEN: no index, no
  * daemon, no watcher, nothing to invalidate and nothing to go stale.
@@ -95,8 +160,16 @@ export function setBody(value) {
 }
 /** v2d: body output routes through the cell renderer — the single writer.
  *  bodyLog adds the trailing newline; internal newlines are preserved. */
-export function bodyLog(text) {
-    body.raw(text.split("\n"));
+export function bodyLog(text, wrap) {
+    body.raw(text.split("\n"), wrap);
+}
+/** TUI2-R2 ②/③: the session store makeAgent built — the ONE store per
+ *  process. The navigation surfaces need its read side (load) to project
+ *  the badges, and a second store on the same root would be a second
+ *  lock manager for a job that never writes. */
+export let sessionStoreRef = null;
+export function setSessionStore(value) {
+    sessionStoreRef = value;
 }
 /** The model name for the status bar — set by makeAgent. */
 export let agentModel = "faux";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "kiso CLI — the durable coding agent that survives kill -9: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
@@ -18,19 +18,19 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@vincemakes/kiso-ask-ext": "0.8.0",
-    "@vincemakes/kiso-core": "0.8.0",
-    "@vincemakes/kiso-evals": "0.8.0",
-    "@vincemakes/kiso-mcp-ext": "0.8.0",
-    "@vincemakes/kiso-provider-anthropic": "0.8.0",
-    "@vincemakes/kiso-provider-openai": "0.8.0",
-    "@vincemakes/kiso-runtime": "0.8.0",
-    "@vincemakes/kiso-skills-ext": "0.8.0",
-    "@vincemakes/kiso-subagent-ext": "0.8.0",
-    "@vincemakes/kiso-task-ext": "0.8.0",
-    "@vincemakes/kiso-tools-node": "0.8.0",
-    "@vincemakes/kiso-tui": "0.8.0",
-    "@vincemakes/kiso-tui-cells": "0.8.0"
+    "@vincemakes/kiso-ask-ext": "0.10.0",
+    "@vincemakes/kiso-core": "0.10.0",
+    "@vincemakes/kiso-evals": "0.10.0",
+    "@vincemakes/kiso-mcp-ext": "0.10.0",
+    "@vincemakes/kiso-provider-anthropic": "0.10.0",
+    "@vincemakes/kiso-provider-openai": "0.10.0",
+    "@vincemakes/kiso-runtime": "0.10.0",
+    "@vincemakes/kiso-skills-ext": "0.10.0",
+    "@vincemakes/kiso-subagent-ext": "0.10.0",
+    "@vincemakes/kiso-task-ext": "0.10.0",
+    "@vincemakes/kiso-tools-node": "0.10.0",
+    "@vincemakes/kiso-tui": "0.10.0",
+    "@vincemakes/kiso-tui-cells": "0.10.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",