@vincemakes/kiso-code 0.39.0 → 0.39.2

package/dist/chat.js

@@ -12,6 +12,7 @@ import { echoText } from "@vincemakes/kiso-tui-cells/render";
 import { canonicalizeUsage } from "@vincemakes/kiso-runtime";
 import { canonicalizeUsageForModel, requestBudget } from "@vincemakes/kiso-runtime/internal";
 import { dispatch, abortBangCommand } from "./dispatch.js";
+import { paintWindowTitle } from "./window-title.js";
 import { agentBaseUrl, agentModel, body, bodyLog, configuredWindow, dock } from "./state.js";
 import { attachImages } from "./attachments.js";
 import { lookupModelMetadata } from "@vincemakes/kiso-runtime/internal";
@@ -781,6 +782,13 @@ submitTurn) {
             // construction (ADR-0040).
             switch (ev.type) {
                 case "user_input":
+                    // The window title is re-derived here because THIS is when a
+                    // session stops being nameless: the tab opened as `kiso —
+                    // <workspace>` and the first substantive prompt is what gives
+                    // it a name. Re-derived rather than set, so the opener rule is
+                    // `sessionTitle`'s and a greeting-first session upgrades when
+                    // the real prompt lands instead of keeping "hi" forever.
+                    paintWindowTitle(session.log.all);
                     // TV-1B: a system-sourced input is PRODUCT MACHINERY — visible
                     // (every durable input renders) but never painted as the
                     // user's words. Provenance is honest on screen, not only in

package/dist/config.js

@@ -102,6 +102,19 @@ export function parseConfig(text, source) {
                 fail(`models.${name}.promptCaching`, "expected a boolean");
             if (p.streamIdleMs !== undefined && (typeof p.streamIdleMs !== "number" || !Number.isFinite(p.streamIdleMs) || p.streamIdleMs < 0))
                 fail(`models.${name}.streamIdleMs`, "expected a non-negative number of milliseconds (0 disables the stream watchdog)");
+            // 0.39.2: `contextWindow` was DECLARED on this type, VALIDATED at
+            // the top level, and CONSUMED by resolveContextWindow — which
+            // prefers it over the global figure, with a comment saying why —
+            // and it was never copied here. So it never reached anything: 70
+            // of 70 profiles that declared one lost it in this object
+            // literal. The cost was not the `ctx ?` on the status row but the
+            // compaction threshold, which fell through to the 200k default
+            // for every model the registry does not carry — a 1M-window model
+            // compacting as though it had a fifth of its window. The
+            // documented workaround for exactly that ("set contextWindow in
+            // your profile") had never done anything.
+            if (p.contextWindow !== undefined && (typeof p.contextWindow !== "number" || !Number.isFinite(p.contextWindow) || p.contextWindow <= 0))
+                fail(`models.${name}.contextWindow`, "expected a positive token count");
             models[name] = {
                 kind: p.kind,
                 model: p.model,
@@ -109,6 +122,7 @@ export function parseConfig(text, source) {
                 ...(typeof p.baseUrl === "string" ? { baseUrl: p.baseUrl } : {}),
                 ...(typeof p.promptCaching === "boolean" ? { promptCaching: p.promptCaching } : {}),
                 ...(typeof p.streamIdleMs === "number" ? { streamIdleMs: p.streamIdleMs } : {}),
+                ...(typeof p.contextWindow === "number" ? { contextWindow: p.contextWindow } : {}),
             };
         }
         out.models = models;

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, displayVerb, escapeTerminal, helpRows, kUnit, modePickView, modelPickView, palette } from "@vincemakes/kiso-tui";
+import { contextRows, contextUnavailableRows, displayVerb, escapeTerminal, helpRows, kUnit, modePickView, modelPickView, palette, renderEvent, settledLabel, slashCommandNames } from "@vincemakes/kiso-tui";
 import { newSessionId } from "./session-id.js";
 import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveReasoning } from "@vincemakes/kiso-runtime/internal";
 import { MODES, MODE_NOTE, getMode, setMode } from "./mode.js";
@@ -19,6 +19,17 @@ import { join } from "node:path";
  *  — kiso never silently drops a level, and now it shows the ones it takes.
  *  A model the registry does not know shows `unknown` (nothing is guessed);
  *  it must not read `none`, which is a REAL level since the Responses rows. */
+/** A context figure for a NOTICE, in the status row's own form.
+ *
+ *  `displayCtxRatio` returns NaN as its honest "nobody states this model's
+ *  window", and the status row renders that as `ctx ?`. The `/compact`
+ *  recap multiplied it and interpolated the result, so the same unknown
+ *  reached the screen as `ctx NaN% → NaN%`: one value with a contract, and
+ *  a second consumer that had not read it. The `%` moves inside, because
+ *  the unknown form does not carry one. */
+function ctxPercent(ratio) {
+    return Number.isFinite(ratio) ? `${Math.round(ratio * 100)}%` : "?";
+}
 function effortNote(p) {
     const reasoning = lookupModelMetadata(p.model, p.baseUrl)?.capabilities.reasoning ?? null;
     const effort = reasoning?.effort ?? null;
@@ -732,7 +743,7 @@ export function dispatch(line, ctx) {
             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);
+                ctxBefore = ctxPercent(ctx.estimateCtx());
                 dock.setStatus(text(0), "esc to cancel");
                 compactTimer = setInterval(() => {
                     dock.setStatus(text(Math.round((Date.now() - compactStart) / 1000)), "esc to cancel");
@@ -745,6 +756,12 @@ export function dispatch(line, ctx) {
                 const focus = trimmed.slice(8).trim();
                 const result = await ctx.session.summarize({
                     signal: abort.signal,
+                    // 0.39.2: the gesture gets the measured output budget and
+                    // thinking off where the registry can vouch for turning it
+                    // off. A fixed 4,000 was failing live sessions with "the
+                    // summary turn ended with max_tokens"; a complete checkpoint
+                    // of the reported size measured 18,837.
+                    manualBudget: true,
                     ...(focus !== "" ? { focus } : {}),
                     onStart: (info) => {
                         compactInfo = info;
@@ -760,11 +777,29 @@ export function dispatch(line, ctx) {
                     // 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) : "?";
+                    const ctxAfter = ctxPercent(ctx.estimateCtx());
+                    const elapsed = compactStart > 0 ? settledLabel((Date.now() - compactStart) / 1000) : "?s";
                     // 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`);
+                    body.notice(`[/compact] ✦ compacted · ${compactInfo?.rounds ?? "?"} rounds → 1 summary · saved ~${kUnit(result.savedTokens)} · ctx ${ctxBefore ?? "?"} → ${ctxAfter} · ${elapsed}`);
+                    // 0.39.1 — the boundary row, under the recap.
+                    //
+                    // `summarized` is appended OFF-LOOP: session.summarize()
+                    // writes it to the log and persists it, and no hook
+                    // carries it to a renderer. So the row that marks where
+                    // the transcript was cut had exactly one producer — a
+                    // `case "summarized"` in lines.ts whose own comment says
+                    // it is there "for the switch's completeness only" — and
+                    // zero callers. The durable log said a compaction
+                    // happened at seq N; no screen ever did.
+                    //
+                    // Rendered THROUGH that case rather than written again
+                    // here: the line a resumed or replayed view would draw is
+                    // the line drawn now, by construction, and the row cannot
+                    // drift into two spellings of one fact.
+                    const boundary = renderEvent({ type: "summarized", coversToSeq: result.coversToSeq });
+                    if (boundary.text !== "")
+                        body.raw(boundary.text.replace(/\n$/, "").split("\n"));
                 }
             }
             catch (err) {
@@ -774,7 +809,22 @@ export function dispatch(line, ctx) {
                     body.notice("[/compact] cancelled — nothing was persisted");
                 }
                 else {
-                    body.notice(`[/compact] failed: ${err instanceof Error ? err.message : String(err)}`);
+                    // 0.39.1 — two repairs on one line. A failure the ADAPTER
+                    // classified is a plain object, not an Error: `String(err)`
+                    // rendered it `[object Object]`, which became reachable the
+                    // moment the adapters started THROWING the
+                    // transport-failure class instead of stopping with it. And
+                    // a transport failure is worth saying so about: summarize
+                    // already retried it once (it has no kernel behind it to do
+                    // that), so a second failure means the gateway is still
+                    // dropping the stream — the run is fine and the gesture is
+                    // worth repeating. A permanent failure is not, and must not
+                    // be dressed up as one that is.
+                    const e = err;
+                    const classified = typeof e.code === "string" && typeof e.message === "string";
+                    const detail = classified ? String(e.message) : err instanceof Error ? err.message : String(err);
+                    const again = classified && e.retryable === true ? " — the connection dropped again; /compact is worth another try" : "";
+                    body.notice(`[/compact] failed: ${escapeTerminal(detail)}${again}`);
                 }
             }
             finally {
@@ -902,7 +952,21 @@ export function dispatch(line, ctx) {
     // still submits.
     if (trimmed.startsWith("/") && !trimmed.includes("\n")) {
         ctx.chainRef.current = ctx.chainRef.current.then(async () => {
-            bodyLog(`unknown command: ${escapeTerminal(trimmed.split(" ")[0] ?? trimmed)} — /help lists the commands`);
+            // The word, not the line: a command that EXISTS but was handed an
+            // argument it does not take reaches here too, and calling it
+            // unknown is a lie the user cannot get past — `/help` lists it,
+            // they typed what `/help` said, and kiso answers that there is no
+            // such command. (Reported on `/reload extensions`, 0.39.1.) The
+            // commands that DO take an argument matched on their own prefix
+            // far above, so a known word arriving here means exactly one
+            // thing: it takes none. `slashCommandNames` is the help sheet's
+            // own table, so this line cannot drift from the list the user was
+            // reading when they typed it.
+            const word = trimmed.split(/\s+/)[0] ?? trimmed;
+            const known = slashCommandNames().includes(word);
+            bodyLog(known
+                ? `${escapeTerminal(word)} takes no arguments — /help says what it does`
+                : `unknown command: ${escapeTerminal(word)} — /help lists the commands`);
             ctx.input.prompt();
         });
         return;

package/dist/index.js

@@ -47,6 +47,7 @@ import { loadProjectConfig, loadUserConfig, mergeConfigs, resolveAutoCompact, re
 import { checkForUpdate, knownUpdate, updateCardLines } from "./update-check.js";
 import { tmuxMouseHint } from "./tmux-hint.js";
 import { resume } from "./resume.js";
+import { paintWindowTitle } from "./window-title.js";
 import { resumeTail } from "./resume-tail.js";
 import { armByteTrace } from "./byte-trace.js";
 import { tmpdir, homedir } from "node:os";
@@ -1125,6 +1126,11 @@ async function chatLoop(first, firstId, input, autoCompact) {
         bindRestoredSession(session);
         setCurrentModelName(session.model);
         paintBootStatus(session);
+        // The terminal's window title, HERE for the same reason the three
+        // lines above are here: this is the one step all three entry points
+        // share (first start, `/resume <id>`, a switch), so a tab can never
+        // be left naming the session the user just left.
+        paintWindowTitle(session.log.all);
         const nav = {
             sessions: () => agent.sessions().map((m) => m.id),
             ...(process.stdin.isTTY ? { pick: () => pickSession(agent, input) } : {}),

package/dist/window-title.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The terminal's window title (0.39.1, the owner's call).
+ *
+ * kiso set none, so a tab read whatever the shell left there — the
+ * directory the shell happened to be in and the absolute path of a node
+ * binary, identically for every kiso in every tab. The title is the one
+ * place a terminal shows which session a tab holds without the user
+ * switching to it, and it was the only screen kiso never wrote to.
+ *
+ * `kiso — <workspace>` at the start, `kiso — <session title> —
+ * <workspace>` once the session has one. The session's title is
+ * `sessionTitle`'s — the SAME projection the resume picker and `kiso
+ * sessions` print, so a tab and the picker can never disagree about what
+ * a session is called. That is also why an opener does not become the
+ * title: the rule for "substantive" lives in one place and this is a
+ * consumer of it, not a second opinion.
+ *
+ * WHAT IT WRITES. OSC 0, BEL-terminated — icon name and window title in
+ * one sequence, the form every terminal that supports either accepts. It
+ * goes STRAIGHT to stdout, deliberately outside the compositor: a title
+ * occupies no cell and no column, so it is not in the width accounting
+ * and must not be a cell that the repaint could move, cut, or scroll.
+ *
+ * WHAT IT NEVER WRITES. Anything at all when stdout is not a TTY. An OSC
+ * into a pipe is bytes in someone's output, and the pipe-identity gates
+ * exist because that has been a real defect before.
+ *
+ * NO RESTORE ON EXIT. Putting back what was there first requires reading
+ * it, which no terminal reliably answers; the shell repaints its own
+ * title on the next prompt anyway. A guess written on the way out would
+ * be a title kiso invented, which is worse than one it left.
+ *
+ * AND NO `process.title`. The reference implementation sets one; kiso
+ * does not, because two gates in this repo said no and the benefit was
+ * that `ps` would print `kiso` instead of a node path.
+ *
+ *  - It overwrites the process's ARGV memory, so a renamed process shows
+ *    as `kiso` with its arguments simply gone. The subagent's
+ *    concurrency probe counts live children by matching `chat
+ *    sub-parent-` in the command column; six renamed children were
+ *    indistinguishable from each other and from nothing.
+ *  - Setting it is not free on this platform: 14 ms measured for the
+ *    first assignment on the machine this was written on, 7 ms for the
+ *    second. A synchronous stall of that size on the main thread while a
+ *    3,000-line paste is arriving wedges the PTY in both directions —
+ *    the UD-1 byte-exact paste gate deadlocked reproducibly and passed
+ *    the moment the assignment was removed.
+ *
+ * The window title is what was asked for; the process name was a detail
+ * that came with it, and it costs more than it is worth.
+ */
+import type { Event } from "@vincemakes/kiso-core";
+/** OSC 0 — "set icon name and window title". */
+export declare const OSC_TITLE_PREFIX = "\u001B]0;";
+/** BEL, the terminator the reference form uses (ST works too; BEL is the
+ *  one older terminals accept without argument). */
+export declare const OSC_TITLE_SUFFIX = "\u0007";
+/**
+ * The text of the title, with no IO — the whole rule, testable.
+ *
+ * Every part is passed through `escapeTerminal` before it can reach the
+ * sequence. A title is whatever a human typed or PASTED: a BEL in it
+ * would end the sequence early and an ESC would begin another one, and
+ * the title would stop being a title and start being commands to the
+ * terminal. The same stripper the rendered surfaces use — one definition
+ * of "what is safe to put on a terminal", not a second.
+ */
+export declare function windowTitleText(events: readonly Event[], workspace: string): string;
+/**
+ * Write the title for this session's state. Called where the session is
+ * BOUND (which is one place for all three entry points — first start,
+ * `/resume <id>`, and a switch) and again as the session's own title
+ * becomes knowable, so a tab named before the first prompt is renamed by
+ * it rather than keeping a name that was only ever a placeholder.
+ */
+export declare function paintWindowTitle(events: readonly Event[], cwd?: string): void;

package/dist/window-title.js

@@ -0,0 +1,114 @@
+/**
+ * The terminal's window title (0.39.1, the owner's call).
+ *
+ * kiso set none, so a tab read whatever the shell left there — the
+ * directory the shell happened to be in and the absolute path of a node
+ * binary, identically for every kiso in every tab. The title is the one
+ * place a terminal shows which session a tab holds without the user
+ * switching to it, and it was the only screen kiso never wrote to.
+ *
+ * `kiso — <workspace>` at the start, `kiso — <session title> —
+ * <workspace>` once the session has one. The session's title is
+ * `sessionTitle`'s — the SAME projection the resume picker and `kiso
+ * sessions` print, so a tab and the picker can never disagree about what
+ * a session is called. That is also why an opener does not become the
+ * title: the rule for "substantive" lives in one place and this is a
+ * consumer of it, not a second opinion.
+ *
+ * WHAT IT WRITES. OSC 0, BEL-terminated — icon name and window title in
+ * one sequence, the form every terminal that supports either accepts. It
+ * goes STRAIGHT to stdout, deliberately outside the compositor: a title
+ * occupies no cell and no column, so it is not in the width accounting
+ * and must not be a cell that the repaint could move, cut, or scroll.
+ *
+ * WHAT IT NEVER WRITES. Anything at all when stdout is not a TTY. An OSC
+ * into a pipe is bytes in someone's output, and the pipe-identity gates
+ * exist because that has been a real defect before.
+ *
+ * NO RESTORE ON EXIT. Putting back what was there first requires reading
+ * it, which no terminal reliably answers; the shell repaints its own
+ * title on the next prompt anyway. A guess written on the way out would
+ * be a title kiso invented, which is worse than one it left.
+ *
+ * AND NO `process.title`. The reference implementation sets one; kiso
+ * does not, because two gates in this repo said no and the benefit was
+ * that `ps` would print `kiso` instead of a node path.
+ *
+ *  - It overwrites the process's ARGV memory, so a renamed process shows
+ *    as `kiso` with its arguments simply gone. The subagent's
+ *    concurrency probe counts live children by matching `chat
+ *    sub-parent-` in the command column; six renamed children were
+ *    indistinguishable from each other and from nothing.
+ *  - Setting it is not free on this platform: 14 ms measured for the
+ *    first assignment on the machine this was written on, 7 ms for the
+ *    second. A synchronous stall of that size on the main thread while a
+ *    3,000-line paste is arriving wedges the PTY in both directions —
+ *    the UD-1 byte-exact paste gate deadlocked reproducibly and passed
+ *    the moment the assignment was removed.
+ *
+ * The window title is what was asked for; the process name was a detail
+ * that came with it, and it costs more than it is worth.
+ */
+import { basename } from "node:path";
+import { sessionTitle } from "@vincemakes/kiso-runtime/internal";
+import { displayWidth, widthCut } from "@vincemakes/kiso-tui-cells/width";
+import { escapeTerminal } from "@vincemakes/kiso-tui-cells/render";
+/** OSC 0 — "set icon name and window title". */
+export const OSC_TITLE_PREFIX = "\u001b]0;";
+/** BEL, the terminator the reference form uses (ST works too; BEL is the
+ *  one older terminals accept without argument). */
+export const OSC_TITLE_SUFFIX = "\u0007";
+/** The session title's share of the tab, in CELLS. A tab strip gives a
+ *  title far less than a row, and the workspace — which says WHERE, the
+ *  thing a human scanning tabs is usually after — must survive the cut. */
+const TITLE_CELLS = 40;
+/** The title a session with no title yet has. `sessionTitle` returns this
+ *  when nothing has been asked; it is not a label, so it is not shown. */
+const NO_TITLE = "(no prompt)";
+/**
+ * The text of the title, with no IO — the whole rule, testable.
+ *
+ * Every part is passed through `escapeTerminal` before it can reach the
+ * sequence. A title is whatever a human typed or PASTED: a BEL in it
+ * would end the sequence early and an ESC would begin another one, and
+ * the title would stop being a title and start being commands to the
+ * terminal. The same stripper the rendered surfaces use — one definition
+ * of "what is safe to put on a terminal", not a second.
+ */
+export function windowTitleText(events, workspace) {
+    const place = escapeTerminal(workspace);
+    // Filtered BEFORE the wrap, so the cost is one object per user turn
+    // rather than one per event — this is re-derived on every turn of a
+    // session whose log may hold thousands. `sessionTitle` filters again;
+    // it is the authority on what counts and this is not a second opinion.
+    const inputs = events.filter((e) => e.type === "user_input");
+    const raw = sessionTitle(inputs.map((event) => ({ runId: "", ts: 0, event })));
+    if (raw === NO_TITLE)
+        return `kiso — ${place}`;
+    const safe = escapeTerminal(raw);
+    // Cut by CELLS, not code points: a title of wide characters counts
+    // two columns each, and a count of characters would overflow the tab
+    // by as much again. The mark is inside the budget, never added to it.
+    const shown = displayWidth(safe) > TITLE_CELLS ? `${widthCut(safe, TITLE_CELLS - 1)}…` : safe;
+    return `kiso — ${shown} — ${place}`;
+}
+/** What was last written, so a repaint of the same title writes nothing.
+ *  The title is re-derived on every bind and every user turn; most of
+ *  those derive what is already on screen. */
+let shown = null;
+/**
+ * Write the title for this session's state. Called where the session is
+ * BOUND (which is one place for all three entry points — first start,
+ * `/resume <id>`, and a switch) and again as the session's own title
+ * becomes knowable, so a tab named before the first prompt is renamed by
+ * it rather than keeping a name that was only ever a placeholder.
+ */
+export function paintWindowTitle(events, cwd = process.cwd()) {
+    if (process.stdout.isTTY !== true)
+        return;
+    const text = windowTitleText(events, basename(cwd) || cwd);
+    if (text === shown)
+        return;
+    shown = text;
+    process.stdout.write(`${OSC_TITLE_PREFIX}${text}${OSC_TITLE_SUFFIX}`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.39.0",
+	"version": "0.39.2",
 	"description": "kiso-code \u2014 the coding agent on kiso, the durable runtime for AI agents: kiso chat / kiso resume / kiso sessions.",
 	"type": "module",
 	"license": "MIT",
@@ -18,20 +18,20 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-ask-ext": "0.39.0",
-		"@vincemakes/kiso-core": "0.39.0",
-		"@vincemakes/kiso-evals": "0.39.0",
-		"@vincemakes/kiso-mcp-ext": "0.39.0",
-		"@vincemakes/kiso-provider-anthropic": "0.39.0",
-		"@vincemakes/kiso-provider-openai": "0.39.0",
-		"@vincemakes/kiso-provider-openai-responses": "0.39.0",
-		"@vincemakes/kiso-runtime": "0.39.0",
-		"@vincemakes/kiso-skills-ext": "0.39.0",
-		"@vincemakes/kiso-subagent-ext": "0.39.0",
-		"@vincemakes/kiso-task-ext": "0.39.0",
-		"@vincemakes/kiso-tools-node": "0.39.0",
-		"@vincemakes/kiso-tui": "0.39.0",
-		"@vincemakes/kiso-tui-cells": "0.39.0"
+		"@vincemakes/kiso-ask-ext": "0.39.2",
+		"@vincemakes/kiso-core": "0.39.2",
+		"@vincemakes/kiso-evals": "0.39.2",
+		"@vincemakes/kiso-mcp-ext": "0.39.2",
+		"@vincemakes/kiso-provider-anthropic": "0.39.2",
+		"@vincemakes/kiso-provider-openai": "0.39.2",
+		"@vincemakes/kiso-provider-openai-responses": "0.39.2",
+		"@vincemakes/kiso-runtime": "0.39.2",
+		"@vincemakes/kiso-skills-ext": "0.39.2",
+		"@vincemakes/kiso-subagent-ext": "0.39.2",
+		"@vincemakes/kiso-task-ext": "0.39.2",
+		"@vincemakes/kiso-tools-node": "0.39.2",
+		"@vincemakes/kiso-tui": "0.39.2",
+		"@vincemakes/kiso-tui-cells": "0.39.2"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",