@vincemakes/kiso-code 0.9.0 → 0.11.0

package/dist/chat.js

@@ -735,6 +735,19 @@ export async function chat(session, faux, input, autoCompact) {
             costUsd: spentUsd,
         }));
     };
+    // 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);

package/dist/dispatch.js

@@ -3,7 +3,7 @@
  * turns. The bodies moved verbatim from chat()'s closure; chat provides
  * the context (the chain, the run state, the prompt arming).
  */
-import { contextRows, contextUnavailableRows, 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, readContextLedger, setAgentModel, setCurrentModelName } from "./state.js";
@@ -56,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();
@@ -162,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) {
@@ -200,6 +207,7 @@ function makeLineInput() {
         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 }));
@@ -357,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);
@@ -442,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
@@ -527,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);
                 }
@@ -541,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;
             }
@@ -556,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;
             }
@@ -594,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)
@@ -83,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. */
@@ -107,6 +113,16 @@ 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, 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

@@ -163,6 +163,14 @@ export function setBody(value) {
 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";
 export function setAgentModel(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.9.0",
+  "version": "0.11.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.9.0",
-    "@vincemakes/kiso-core": "0.9.0",
-    "@vincemakes/kiso-evals": "0.9.0",
-    "@vincemakes/kiso-mcp-ext": "0.9.0",
-    "@vincemakes/kiso-provider-anthropic": "0.9.0",
-    "@vincemakes/kiso-provider-openai": "0.9.0",
-    "@vincemakes/kiso-runtime": "0.9.0",
-    "@vincemakes/kiso-skills-ext": "0.9.0",
-    "@vincemakes/kiso-subagent-ext": "0.9.0",
-    "@vincemakes/kiso-task-ext": "0.9.0",
-    "@vincemakes/kiso-tools-node": "0.9.0",
-    "@vincemakes/kiso-tui": "0.9.0",
-    "@vincemakes/kiso-tui-cells": "0.9.0"
+    "@vincemakes/kiso-ask-ext": "0.11.0",
+    "@vincemakes/kiso-core": "0.11.0",
+    "@vincemakes/kiso-evals": "0.11.0",
+    "@vincemakes/kiso-mcp-ext": "0.11.0",
+    "@vincemakes/kiso-provider-anthropic": "0.11.0",
+    "@vincemakes/kiso-provider-openai": "0.11.0",
+    "@vincemakes/kiso-runtime": "0.11.0",
+    "@vincemakes/kiso-skills-ext": "0.11.0",
+    "@vincemakes/kiso-subagent-ext": "0.11.0",
+    "@vincemakes/kiso-task-ext": "0.11.0",
+    "@vincemakes/kiso-tools-node": "0.11.0",
+    "@vincemakes/kiso-tui": "0.11.0",
+    "@vincemakes/kiso-tui-cells": "0.11.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",