@vincemakes/kiso-code 0.1.36 → 0.1.38

package/dist/chat.js

@@ -177,9 +177,23 @@ export async function consumeRun(session, run, input, turnNo, faux, liveInput, s
     const turnStart = Date.now();
     let toolCount = 0;
     let editCount = 0;
+    // W14: the thinking event carries NO timestamp — the CLI wall-clocks
+    // the thinking window: it opens at the first thinking event and closes
+    // at the first non-thinking event (the fold needs the seconds).
+    let thoughtSeconds = 0;
+    let thinkingSince = null;
     try {
         for await (const ev of run) {
             last = ev;
+            if (ev.type !== "thinking") {
+                if (thinkingSince !== null) {
+                    thoughtSeconds += (Date.now() - thinkingSince) / 1000;
+                    thinkingSince = null;
+                }
+            }
+            else if (thinkingSince === null) {
+                thinkingSince = Date.now();
+            }
             // v2a (the double echo): the interactive echo was already rendered by the
             // input source — rendering the event again is the double echo.
             // v2b: DOCKED — the echo lives in the input row (H), NOT the body;
@@ -218,7 +232,18 @@ export async function consumeRun(session, run, input, turnNo, faux, liveInput, s
                     break;
                 case "tool_result": {
                     const text = typeof ev.content === "string" ? ev.content : "";
-                    body.toolResult(ev.callId, { content: text, isError: ev.isError });
+                    // W19: a DENIED call carries its reason — extracted from the
+                    // result's "[Permission denied] " prefix, keyed on the
+                    // "denied" tag (the parseChecklist discipline: the tag
+                    // declares, the prefix confirms). The ToolCell renders the
+                    // pinned row (full name, target, reason, no timing).
+                    let reason = null;
+                    if ((ev.tags ?? []).includes("denied")) {
+                        const m = /^\[Permission denied\] (.*)$/.exec(text);
+                        if (m !== null)
+                            reason = m[1];
+                    }
+                    body.toolResult(ev.callId, { content: text, isError: ev.isError, reason });
                     // round 6 (the todo round): a result tagged do-not-compact whose content
                     // follows the checklist shape also renders as the durable
                     // checklist cell (the CLI translates Event → the tui's own
@@ -271,12 +296,19 @@ export async function consumeRun(session, run, input, turnNo, faux, liveInput, s
                     // events (zero tokens). The dock's status bar still paints.
                     statusCb?.(usage, estimateCtxRatio(session));
                     const ratio = estimateCtxRatio(session);
+                    // W14: the turn record closes HERE — before the recap logs, so
+                    // the commit loop folds the quiet turn's held cells first (the
+                    // fold line lands above the recap, natural cell order).
+                    body.endTurn(Math.round(thoughtSeconds));
                     bodyLog(renderRecap({
                         seconds: Math.round((Date.now() - turnStart) / 1000),
                         tools: toolCount,
                         edits: editCount,
                         usage,
                         ctxLeftPct: Number.isFinite(ratio) ? (1 - ratio) * 100 : null,
+                        // W19: under plan the recap becomes the way-forward row
+                        // (the /mode hints are the mode's exits).
+                        mode: getMode(),
                     }));
                     break;
                 }
@@ -436,7 +468,10 @@ export async function chat(session, faux, input, autoCompact) {
             return;
         const ratio = estimateCtxRatio(session);
         const pct = Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
-        dock.setStatus(`▸ ${getMode()} · /mode to switch · ${agentModel} · ctx left ~${pct}%`);
+        // W19: under plan the idle row makes the posture unmistakable —
+        // the W4 parentheses idiom names the read-only constraint.
+        const tier = getMode() === "plan" ? "plan (read-only)" : getMode();
+        dock.setStatus(`▸ ${tier} · /mode to switch · ${agentModel} · ctx left ~${pct}%`);
     };
     const statusCb = (u, ctx) => {
         runUsage = u;
@@ -479,6 +514,10 @@ export async function chat(session, faux, input, autoCompact) {
         }
         dispatch(line, dispatchCtx);
     });
+    // W15: the expand key — the editor forwards ctrl+r; dispatch runs the
+    // chain action (the sentinel's control char marks the key, so a typed
+    // "expand" turn is never intercepted).
+    input.onExpand(() => dispatch("\x12expand", dispatchCtx));
     // Recovery first: a session with a dangling pause or uncertain
     // executions must resolve them BEFORE the REPL accepts new turns —
     // otherwise the interrupted run dangles while a new one starts.

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, palette } from "@vincemakes/kiso-tui";
+import { escapeTerminal, kUnit, palette } from "@vincemakes/kiso-tui";
 import { buildAdapter } from "@vincemakes/kiso-runtime";
 import { MODES, getMode, setMode } from "./mode.js";
-import { agentModel, body, bodyLog, configModels, setAgentModel, setCurrentModelName } from "./state.js";
+import { agentModel, body, bodyLog, configModels, dock, 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
@@ -66,6 +66,35 @@ export function dispatch(line, ctx) {
         });
         return;
     }
+    if (trimmed === "\x12expand") {
+        // W15: the expand key (ctrl+r) — /last aimed at a chosen cell.
+        // The TARGET is picked at press time: a LIVE tool cell toggles
+        // IMMEDIATELY in place (the compositor owns those rows and
+        // redraws them — the approval pause is exactly when the user
+        // reads a cut diff, and the key must answer then, never after
+        // the run). A COMMITTED cell can never toggle — history is never
+        // rewritten (ADR-0046) — so its expanded block and the empty
+        // answer queue on the chain like /last: the block lands as new
+        // content after any in-flight turn. The sentinel carries the
+        // control char so a typed "expand" turn is never intercepted.
+        const r = body.expandNext();
+        if (r.kind === "toggled") {
+            ctx.input.prompt(); // in place — the frame already repainted
+            return;
+        }
+        const land = async () => {
+            if (r.kind === "appended") {
+                for (const line of r.lines)
+                    bodyLog(line);
+            }
+            else if (r.kind === "none") {
+                bodyLog("[nothing to expand]");
+            }
+            ctx.input.prompt();
+        };
+        ctx.chainRef.current = ctx.chainRef.current.then(land);
+        return;
+    }
     if (trimmed === "/status") {
         // B area: session id, durable event count, and the ~ context
         // estimate — all read straight from the live session, nothing
@@ -164,19 +193,76 @@ export function dispatch(line, ctx) {
             return;
         }
         ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            // W18: the compaction indicator — the whole call runs under
+            // a live status row (the INDETERMINATE form: the summary is
+            // ONE adapter call, no fraction exists — kiso never invents
+            // a percentage), with a REAL cancel: esc aborts the signal,
+            // which the runtime observes at every phase boundary.
+            const abort = new AbortController();
+            let compactCancelled = false;
+            const onEscape = () => {
+                if (abort.signal.aborted)
+                    return;
+                compactCancelled = true;
+                abort.abort();
+            };
+            ctx.input.onEscape(onEscape);
+            let compactStart = 0;
+            let compactTimer = null;
+            // the `as` on the initializer keeps the flow type the full union —
+            // onStart fills this during the call, but a closure assignment
+            // never re-narrows the outer scope (it would read `never`)
+            let compactInfo = null;
+            // the ctx estimate BEFORE the summarized event lands (the used
+            // fraction — the recap's "ctx 91% → 34%" drops after compacting)
+            let ctxBefore = null;
+            const compacting = (info) => {
+                const text = (elapsed) => `▘ compacting · ${info.rounds} rounds · ~${kUnit(info.tokens)} tokens · ${Math.max(0, elapsed)}s`;
+                compactStart = Date.now();
+                ctxBefore = Math.round(ctx.estimateCtx() * 100);
+                dock.setStatus(text(0), "esc to cancel");
+                compactTimer = setInterval(() => {
+                    dock.setStatus(text(Math.round((Date.now() - compactStart) / 1000)), "esc to cancel");
+                }, 1000);
+            };
             try {
-                const result = await ctx.session.summarize();
+                const result = await ctx.session.summarize({
+                    signal: abort.signal,
+                    onStart: (info) => {
+                        compactInfo = info;
+                        compacting(info);
+                    },
+                });
                 if (result === null) {
                     body.notice("[/compact] nothing to compact — fewer than 5 rounds yet");
                 }
                 else {
-                    body.notice(`[/compact] saved ~${result.savedTokens.toLocaleString("en-US")} tokens`);
+                    // W18: the settled RECAP replaces the bare saved-token
+                    // notice — it names what actually happened: the covered
+                    // rounds, the one summary, the savings, the ctx drop
+                    // (the estimate BEFORE vs AFTER — the same chars/4
+                    // proxy the status bar shows, marked ~), and the time.
+                    const ctxAfter = Math.round(ctx.estimateCtx() * 100);
+                    const elapsed = compactStart > 0 ? ((Date.now() - compactStart) / 1000).toFixed(1) : "?";
+                    // a non-null result implies onStart ran — the "?" is
+                    // reachable only at the type level
+                    body.notice(`[/compact] ▞ compacted · ${compactInfo?.rounds ?? "?"} rounds → 1 summary · saved ~${kUnit(result.savedTokens)} · ctx ${ctxBefore ?? "?"}% → ${ctxAfter}% · ${elapsed}s`);
                 }
             }
             catch (err) {
                 // Honest failure: nothing was persisted, the session
                 // is unchanged (ADR-0044 crash semantics).
-                body.notice(`[/compact] failed: ${err instanceof Error ? err.message : String(err)}`);
+                if (compactCancelled) {
+                    body.notice("[/compact] cancelled — nothing was persisted");
+                }
+                else {
+                    body.notice(`[/compact] failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            finally {
+                if (compactTimer !== null)
+                    clearInterval(compactTimer);
+                ctx.paintIdle();
             }
             ctx.input.prompt();
         });

package/dist/index.js

@@ -25,7 +25,7 @@
 import { readFileSync, rmSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { join } from "node:path";
-import { Body, Editor, PROMPT as EDITOR_PROMPT, bannerLines, palette, renderSessionLine } from "@vincemakes/kiso-tui";
+import { Body, Editor, bannerLines, palette, renderSessionLine } from "@vincemakes/kiso-tui";
 import { escapeTerminal } from "@vincemakes/kiso-tui";
 import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions, SessionStore, } from "@vincemakes/kiso-runtime";
 import { createFauxProvider } from "@vincemakes/kiso-evals";
@@ -40,24 +40,6 @@ import { resume } from "./resume.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";
-/** The banner: the block-letter logo (design fixed). TTY only — pipes, e2e
- *  drivers, and CI see byte-for-byte the old output; the extensions line
- *  merges into the third row on TTY and stays a standalone line off-TTY.
- *  v2a: the logo rows stay dim; the TAGLINE (row 2) is the blue identity
- *  accent. */
-function startupBanner() {
-    // v3 §01: the banner is block-split — three independent logo rows
-    // (TOP / tagline / BOTTOM), then TWO info rows (version,
-    // extensions), each truncated at the window width; < 40 columns
-    // skips the logo. The historical `[N extensions: names]` text rides
-    // the extensions row verbatim (the e2e assertions keep matching).
-    const p = palette();
-    // A pty without a winsize reports columns = 0 (not undefined) — treat
-    // it as the default width, never as a 0-column truncation.
-    const W = process.stdout.columns ?? 0;
-    const rows = bannerLines(W > 0 ? W : 80, VERSION, bannerExtensionText().replace(/^ · /, ""));
-    return `${rows.map((r) => `${p.dim}${r}${p.reset}`).join("\n")}\n`;
-}
 /** The v2b behavior, unchanged: readline owns the line, SIGINT, and the
  *  prompt. Only ever constructed when stdin is NOT a TTY. The rl starts
  *  consuming stdin at construction (main), so 'line' events are buffered
@@ -88,6 +70,10 @@ function readlineInput(rl) {
         onEscape() {
             /* readline has no bare-Esc semantics — ignored. */
         },
+        onExpand() {
+            /* readline has no ctrl+r binding — ignored (W15 rides the
+             * editor path only). */
+        },
         question(query, cb) {
             rl.question(query, cb);
         },
@@ -130,6 +116,9 @@ function editorInput(editor) {
         onEscape(cb) {
             editor.onEscape(cb);
         },
+        onExpand(cb) {
+            editor.onExpand(cb);
+        },
         question(query, cb) {
             editor.question(query, cb);
         },
@@ -163,8 +152,10 @@ function makeLineInput() {
     if (process.stdin.isTTY) {
         const editor = new Editor(() => (dock.active ? dock.redraw() : editor.selfRender()));
         editor.enter();
-        const p = palette();
-        dock.bindInput(() => editor.dockState(), `${p.bold}${EDITOR_PROMPT}${p.reset}`);
+        // W6: the box's prompt goes light — "› " (the box already says
+        // "input lives here"; the line-mode path keeps the brick ▌, so
+        // pipe bytes do not change)
+        dock.bindInput(() => editor.dockState(), "› ");
         dock.bindMenu(() => editor.menuState()); // v3 §04: the slash-command menu
         return editorInput(editor);
     }
@@ -187,11 +178,13 @@ function bannerExtensionText() {
         parts.push(`project: ${projectExtensions.map(label).join(", ")}`);
     return ` · [${total} extension${total === 1 ? "" : "s"}: ${parts.join(" · ")}]`;
 }
-/** E1: the startup banner line(s) — TTY: logo + merged extensions; off-TTY:
- *  the historical `[N extensions: ...]` standalone line (zero change). */
-function extensionsBanner() {
+/** E1: the startup banner line(s) — TTY: logo + merged extensions + the
+ *  W5 resume list as a LIVE banner cell (W1: the tier re-derives on
+ *  resize; the resume list re-gates with the tier); off-TTY: the
+ *  historical `[N extensions: ...]` standalone line (zero change). */
+function extensionsBanner(resume = []) {
     if (process.stdout.isTTY) {
-        bodyLog(startupBanner());
+        body.banner(VERSION, bannerExtensionText().replace(/^ · /, ""), resume);
         return;
     }
     const text = bannerExtensionText();
@@ -199,6 +192,19 @@ function extensionsBanner() {
         return;
     bodyLog(`${text}\n`);
 }
+/** W5: the opening-screen resume list — up to 3 recent sessions, newest
+ *  first, the CURRENT session excluded (it is not something to pick back
+ *  up). Every field already exists behind the store's SessionMeta (the
+ *  `kiso sessions` line shows the same data) — only the projection and
+ *  the sort live here. */
+function recentSessions(id, agent) {
+    return agent
+        .sessions()
+        .filter((m) => m.id !== id)
+        .sort((a, b) => b.updatedAt - a.updatedAt)
+        .slice(0, 3)
+        .map(({ title, events, runs, updatedAt }) => ({ title, events, runs, updatedAt }));
+}
 /**
  * A area: the coding-agent system prompt — ONE constant, byte-stable for the
  * session's lifetime (D area). Kept under ~80 lines; no template engine.
@@ -409,7 +415,7 @@ async function main() {
                 applyConfigMode();
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
-                extensionsBanner();
+                extensionsBanner(recentSessions(id, agent));
                 faux = currentFaux;
                 await chat(session, faux, input, resolveAutoCompact(mergedConfig));
                 break;
@@ -439,7 +445,7 @@ async function main() {
             }
             case "help": {
                 const p = palette();
-                console.log(`${p.dim}${bannerLines(80, VERSION, "").join("\n")}${p.reset}\n\n` +
+                console.log(`${p.dim}${bannerLines(80, process.stdout.rows ?? 0, VERSION, "").join("\n")}${p.reset}\n\n` +
                     "kiso — the coding agent that survives kill -9\n\n" +
                     "  kiso [sessionId]         interactive session (default command)\n" +
                     "  kiso chat [sessionId]    same as above\n" +
@@ -457,7 +463,7 @@ async function main() {
                 const agent = await makeAgent(fauxSkip(id));
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
-                extensionsBanner();
+                extensionsBanner(recentSessions(id, agent));
                 await chat(session, faux, input, autoCompactFromEnv());
                 break;
             }

package/dist/state.d.ts

@@ -27,6 +27,9 @@ export interface LineInput {
     onSigint(cb: () => void): void;
     onEot(cb: () => void): void;
     onEscape(cb: () => void): void;
+    /** W15: the expand key (ctrl+r) — the chain-level action, never the
+     *  editor's own interpretation. */
+    onExpand(cb: () => void): void;
     question(query: string, cb: (answer: string) => void): void;
     cancelQuestion(): void;
     emitLine(line: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "kiso CLI — the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,7 @@
     "@vincemakes/kiso-provider-openai": "0.1.31",
     "@vincemakes/kiso-runtime": "0.1.31",
     "@vincemakes/kiso-tools-node": "0.1.31",
-    "@vincemakes/kiso-tui": "0.1.36"
+    "@vincemakes/kiso-tui": "0.1.38"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",