@vincemakes/kiso-code 0.46.1 → 0.47.0

package/dist/floor.d.ts

@@ -63,6 +63,27 @@ export declare function innerLines(argv: readonly LooseWord[], home: string): {
     readonly lines: readonly string[];
     readonly subshell: boolean;
 } | null;
+/** How deep command lines inside command lines are followed — `sh -c`,
+ *  `eval` — and how many are read in all: eval's two readings would
+ *  otherwise double at every level. */
+export declare const MAX_INNER_DEPTH = 16;
+export declare const MAX_INNER_LINES = 256;
+/** git's global options, read to the subcommand. Shared by the floor and
+ *  the remote boundary (remote-boundary.ts), which must find the same
+ *  subcommand the floor does: an option without a value is one word
+ *  skipped, whatever it is, so `git --no-pager push` reads as push. */
+export interface GitInvocation {
+    readonly sub: string | undefined;
+    readonly rest: readonly LooseWord[];
+    /** B7: several -C compose, each relative to the one before */
+    readonly cds: readonly LooseWord[];
+    /** B7: --work-tree X IS the tree a whole-tree command works on */
+    readonly workTree: LooseWord | undefined;
+    /** B7: --git-dir X is a target in itself (space and = forms both) */
+    readonly gitDirs: readonly LooseWord[];
+}
+/** `args` is git's argv without `git`. */
+export declare function gitInvocation(args: readonly LooseWord[]): GitInvocation;
 /**
  * Would the floor refuse this command line? `workspaceRoot` is where the
  * shell runs it.

package/dist/floor.js

@@ -344,8 +344,8 @@ export function innerLines(argv, home) {
 /** How deep command lines inside command lines are followed — `sh -c`,
  *  `eval` — and how many are read in all: eval's two readings would
  *  otherwise double at every level. */
-const MAX_INNER_DEPTH = 16;
-const MAX_INNER_LINES = 256;
+export const MAX_INNER_DEPTH = 16;
+export const MAX_INNER_LINES = 256;
 const SELECTING = new Set([
     "-name", "-iname", "-path", "-ipath", "-wholename", "-iwholename", "-regex", "-iregex", "-newer", "-mtime", "-mmin", "-atime",
     "-amin", "-ctime", "-cmin", "-size", "-empty", "-user", "-group", "-perm", "-samefile", "-links",
@@ -355,6 +355,38 @@ const SELECTING = new Set([
 const pathShaped = (t) => t === "." || t === "./" || t.startsWith("/") || t.startsWith("~") || t.includes("/") || t.startsWith(":") || (hostDialect().msys && (t.includes("\\") || /^[A-Za-z]:/.test(t)));
 /** B7: pathspec magic from the top of the repository */
 const topMagic = (t) => t.startsWith(":/") || t.startsWith(":(top");
+/** `args` is git's argv without `git`. */
+export function gitInvocation(args) {
+    let i = 0;
+    const cds = [];
+    let workTree;
+    const gitDirs = [];
+    while (i < args.length && args[i].text.startsWith("-")) {
+        const t = args[i].text;
+        const eq = /^--(work-tree|git-dir)=(.*)$/.exec(t);
+        if (eq !== null) {
+            const value = { ...args[i], text: eq[2], unknownAt: -1, tilde: eq[2].startsWith("~") };
+            if (eq[1] === "work-tree")
+                workTree = value;
+            else
+                gitDirs.push(value);
+        }
+        if ((t === "-C" || t === "--work-tree" || t === "--git-dir") && i + 1 < args.length) {
+            if (t === "-C")
+                cds.push(args[i + 1]);
+            else if (t === "--work-tree")
+                workTree = args[i + 1];
+            else
+                gitDirs.push(args[i + 1]);
+            i += 2;
+        }
+        else if (t === "-c" || t === "--namespace" || t === "--exec-path")
+            i += 2;
+        else
+            i += 1;
+    }
+    return { sub: args[i]?.text, rest: args.slice(i + 1), cds, workTree, gitDirs };
+}
 /** The destructive command's targets, or null when it is not destructive. */
 function destructiveTargets(argv) {
     const name = basename(argv[0]?.text ?? "");
@@ -398,39 +430,7 @@ function destructiveTargets(argv) {
     }
     if (name !== "git")
         return null;
-    let i = 0;
-    // B7: several -C compose, each relative to the one before
-    const cds = [];
-    // B7: --work-tree X IS the tree a whole-tree command works on; --git-dir
-    // X is a target in itself (space and = forms both)
-    let workTree;
-    const gitDirs = [];
-    while (i < args.length && args[i].text.startsWith("-")) {
-        const t = args[i].text;
-        const eq = /^--(work-tree|git-dir)=(.*)$/.exec(t);
-        if (eq !== null) {
-            const value = { ...args[i], text: eq[2], unknownAt: -1, tilde: eq[2].startsWith("~") };
-            if (eq[1] === "work-tree")
-                workTree = value;
-            else
-                gitDirs.push(value);
-        }
-        if ((t === "-C" || t === "--work-tree" || t === "--git-dir") && i + 1 < args.length) {
-            if (t === "-C")
-                cds.push(args[i + 1]);
-            else if (t === "--work-tree")
-                workTree = args[i + 1];
-            else
-                gitDirs.push(args[i + 1]);
-            i += 2;
-        }
-        else if (t === "-c" || t === "--namespace" || t === "--exec-path")
-            i += 2;
-        else
-            i += 1;
-    }
-    const sub = args[i]?.text;
-    const rest = args.slice(i + 1);
+    const { sub, rest, cds, workTree, gitDirs } = gitInvocation(args);
     const flags = new Set(rest.filter((a) => a.text.startsWith("-")).map((a) => a.text));
     const as = (targets) => ({
         targets: [...targets.map((t) => (t === "repo" && workTree !== undefined ? workTree : t)), ...gitDirs],

package/dist/git-branch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Graphite §8.9 — the branch the status bar names.
+ *
+ * Read from `.git/HEAD`, walking up from the working directory — no git
+ * process is spawned, because the status bar paints on every idle frame.
+ * A `.git` FILE (a worktree, a submodule) points at the real git
+ * directory with `gitdir: <path>`, and that is followed. A detached HEAD
+ * shows its short sha. Outside a repository, or on any read error, there
+ * is no branch and the bar says nothing about one.
+ *
+ * The answer is cached per HEAD file and re-read only when HEAD's mtime
+ * moves — a checkout the model runs mid-session is picked up on the next
+ * paint, and an idle session reads one stat per paint.
+ */
+/** What a HEAD file's contents name: the branch, or a detached sha's head. */
+export declare function branchOf(head: string): string | null;
+export declare function currentBranch(dir: string): string | null;

package/dist/git-branch.js

@@ -0,0 +1,69 @@
+/**
+ * Graphite §8.9 — the branch the status bar names.
+ *
+ * Read from `.git/HEAD`, walking up from the working directory — no git
+ * process is spawned, because the status bar paints on every idle frame.
+ * A `.git` FILE (a worktree, a submodule) points at the real git
+ * directory with `gitdir: <path>`, and that is followed. A detached HEAD
+ * shows its short sha. Outside a repository, or on any read error, there
+ * is no branch and the bar says nothing about one.
+ *
+ * The answer is cached per HEAD file and re-read only when HEAD's mtime
+ * moves — a checkout the model runs mid-session is picked up on the next
+ * paint, and an idle session reads one stat per paint.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+const cache = new Map();
+/** The HEAD file of the repository `dir` is inside, or null. */
+function headFile(dir) {
+    let d = resolve(dir);
+    for (;;) {
+        const dotGit = join(d, ".git");
+        try {
+            const st = statSync(dotGit);
+            if (st.isDirectory())
+                return join(dotGit, "HEAD");
+            if (st.isFile()) {
+                const m = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, "utf8"));
+                if (m !== null)
+                    return join(resolve(d, m[1].trim()), "HEAD");
+                return null;
+            }
+        }
+        catch {
+            // no .git here — keep walking
+        }
+        const up = dirname(d);
+        if (up === d)
+            return null;
+        d = up;
+    }
+}
+/** What a HEAD file's contents name: the branch, or a detached sha's head. */
+export function branchOf(head) {
+    const text = head.trim();
+    const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(text);
+    if (ref !== null)
+        return ref[1];
+    if (/^[0-9a-f]{7,64}$/i.test(text))
+        return text.slice(0, 7);
+    return null;
+}
+export function currentBranch(dir) {
+    try {
+        const head = headFile(dir);
+        if (head === null)
+            return null;
+        const mtimeMs = statSync(head).mtimeMs;
+        const hit = cache.get(head);
+        if (hit !== undefined && hit.mtimeMs === mtimeMs)
+            return hit.branch;
+        const branch = branchOf(readFileSync(head, "utf8"));
+        cache.set(head, { mtimeMs, branch });
+        return branch;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/in-run-compaction.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The compaction round (owner, 2026-10-06) — a summary call inside a run,
+ * as the screen sees it.
+ *
+ * The runtime tells the CLI when an in-run summary starts, how far its
+ * output has come, and how it ended (`contextPolicy.tiers.onSummary`). The
+ * running row reads `current()` on every repaint: while a summary is in
+ * flight it is the `compacting · auto` row `/compact` draws, not `working`
+ * with a clock that runs while nothing arrives. When the summary is kept,
+ * its sizes wait here for the `summarized` event, whose COMPACTED row says
+ * them (`takeKept`).
+ */
+import type { CompactingProgress } from "@vincemakes/kiso-tui";
+export interface InRunCompaction {
+    /** when the summary call started (ms) */
+    readonly since: number;
+    /** the covered user rounds and their estimated tokens */
+    readonly rounds: number;
+    readonly tokens: number;
+    /** the latest report against the output budget; null before the first */
+    progress: CompactingProgress | null;
+}
+type SummaryEvent = {
+    readonly phase: "start";
+    readonly reason: string;
+    readonly info: {
+        readonly rounds: number;
+        readonly tokens: number;
+    };
+} | {
+    readonly phase: "progress";
+    readonly progress: {
+        readonly produced: number;
+        readonly budget: number | null;
+        readonly reasoningUnseen: boolean;
+    };
+} | {
+    readonly phase: "end";
+    readonly outcome: "kept" | "discarded" | "failed";
+    readonly pre: number;
+    readonly post: number;
+};
+/** The runtime's callback (create-coding-agent passes it to the tiers). */
+export declare function onInRunSummary(event: SummaryEvent): void;
+/** The summary in flight, or null — what the running row draws. */
+export declare function current(): InRunCompaction | null;
+/** The kept summary's sizes, once: the `summarized` event's row says them. */
+export declare function takeKept(): {
+    readonly pre: number;
+    readonly post: number;
+} | null;
+/** A run that ends mid-summary (an abort) leaves nothing behind. */
+export declare function clearInRunSummary(): void;
+export {};

package/dist/in-run-compaction.js

@@ -0,0 +1,44 @@
+/**
+ * The compaction round (owner, 2026-10-06) — a summary call inside a run,
+ * as the screen sees it.
+ *
+ * The runtime tells the CLI when an in-run summary starts, how far its
+ * output has come, and how it ended (`contextPolicy.tiers.onSummary`). The
+ * running row reads `current()` on every repaint: while a summary is in
+ * flight it is the `compacting · auto` row `/compact` draws, not `working`
+ * with a clock that runs while nothing arrives. When the summary is kept,
+ * its sizes wait here for the `summarized` event, whose COMPACTED row says
+ * them (`takeKept`).
+ */
+let live = null;
+let kept = null;
+/** The runtime's callback (create-coding-agent passes it to the tiers). */
+export function onInRunSummary(event) {
+    if (event.phase === "start") {
+        live = { since: Date.now(), rounds: event.info.rounds, tokens: event.info.tokens, progress: null };
+        kept = null;
+    }
+    else if (event.phase === "progress") {
+        if (live !== null)
+            live.progress = { produced: event.progress.produced, budget: event.progress.budget, reasoningUnseen: event.progress.reasoningUnseen };
+    }
+    else {
+        live = null;
+        kept = event.outcome === "kept" ? { pre: event.pre, post: event.post } : null;
+    }
+}
+/** The summary in flight, or null — what the running row draws. */
+export function current() {
+    return live;
+}
+/** The kept summary's sizes, once: the `summarized` event's row says them. */
+export function takeKept() {
+    const k = kept;
+    kept = null;
+    return k;
+}
+/** A run that ends mid-summary (an abort) leaves nothing behind. */
+export function clearInRunSummary() {
+    live = null;
+    kept = null;
+}

package/dist/index.js

@@ -30,9 +30,9 @@ import { createInterface } from "node:readline";
 import { Readable } from "node:stream";
 import { fileURLToPath } from "node:url";
 import { basename, join } from "node:path";
-import { Body, Editor, PROMPT, bannerLines, currentGround, resolveGround, setGround, escapeTerminal, extensionsBannerText, idColumn, idleStatus, interactivePrompt, palette, renderSessionLine, sessionListFooter, sessionListHeader, sessionListRow, sessionListUnknownLine, slashCommandNames } from "@vincemakes/kiso-tui";
+import { Body, Editor, PROMPT, bannerLines, currentGround, currentGroundRgb, parseOscColor, resolveGround, setGround, escapeTerminal, extensionsBannerText, extensionsFact, idColumn, interactivePrompt, palette, renderSessionLine, sessionListFooter, sessionListHeader, sessionListRow, sessionListUnknownLine, slashCommandNames } from "@vincemakes/kiso-tui";
 import { disposeExtensions, SessionStore } from "@vincemakes/kiso-runtime";
-import { listSessionSidecars, migrateSummaries, readProfile, summaryMigrationPending } from "@vincemakes/kiso-runtime/internal";
+import { listSessionSidecars, migrateSummaries, readProfile, readSessionName, summaryMigrationPending } from "@vincemakes/kiso-runtime/internal";
 import { skillMenuItems } from "./skill-invoke.js";
 import { canonicalPath, hasSession, locateSession, projectLayoutActive, sessionFolders } from "./projects.js";
 import { reverseMigration } from "./session-migration.js";
@@ -43,15 +43,18 @@ import { isProtectedPath, protectedIdentity, PROTECTED_REFUSAL } from "@vincemak
 import { OFFERED_MODES, applyModeState, envModeLayer, getDontAsk, modeDisplay, parseMode, resolveModeLayers } from "./mode.js";
 import { activeStoreDir, setActiveStoreDir, agentModel, atFiles, body, bodyLog, kisoHome, workspaceRoot, projectRoot, ownSessionsDir, setOpenSessionFolder, builtInExtensions, currentFaux, dock, loadedExtensions, mergedConfig, mergedTempPaths, modelChoice, projectExtensions, configModels, configuredWindow, agentBaseUrl, currentModelName, currentAgentExtensions, sessionStoreRef, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentAgentExtensions, setCurrentFaux, setCurrentModelName, setCurrentProfileName, setExtensionLists, protectedFiles, setMergedConfig, setModelChoice, setSessionStore, userExtensions, VERSION, lastBinding, acceptDrift, setAcceptDrift, loadedSkillsCatalog, queuedSwitchLines } from "./state.js";
 import { fauxSkip, readFauxScript } from "./faux-glue.js";
-import { chat, contextWindowTokens, displayCtxRatio, microcompactThresholdFor, statusModelLabel } from "./chat.js";
+import { barFor, chat, contextWindowTokens, displayCtxRatio, microcompactThresholdFor, statusModelLabel } from "./chat.js";
 import { preferences, usePreferences } from "./preferences.js";
-import { settingsLayers, setChildTurnBudget, stopAllTasks } from "./state.js";
+import { settingsLayers, setChildTurnBudget, stopAllTasks, tasksFor } from "./state.js";
+import { tasksForDisplay } from "./task-notice.js";
 import { finishChild } from "./child-result.js";
 import { loadUserConfig, resolveAutoCompact } from "./config.js";
 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 { paintWindowTitle, setTitleName, setTitleState } from "./window-title.js";
+import { projectInstructions } from "./coding-prompt.js";
+import { openingFacts } from "./opening.js";
 import { resumeTail } from "./resume-tail.js";
 import { replayInto } from "./replay.js";
 import { armByteTrace } from "./byte-trace.js";
@@ -316,6 +319,15 @@ function editorInput(editor) {
         panelCancel() {
             editor.cancelPanel();
         },
+        // Graphite R3e: a read-only sheet over the input (`/status`,
+        // `/context`, `/skills`)
+        openSheet(rows) {
+            editor.openSheet(rows);
+        },
+        // the sheets round: `/help` opens the command list
+        openCommands() {
+            editor.openCommands();
+        },
         // 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.
@@ -410,20 +422,30 @@ function makeLineInput() {
         let osc;
         let colorScheme;
         const theme = () => process.env.KISO_THEME ?? userTheme;
+        const sameRgb = (a, b) => a === b || (a !== null && b !== null && a.r === b.r && a.g === b.g && a.b === b.b);
         const rewalk = () => {
             const next = resolveGround({ theme: theme(), colorScheme, osc, colorfgbg: process.env.COLORFGBG });
+            // Graphite §3.4: the colour the terminal reported rides along,
+            // whichever rung decided the ground — the surfaces are derived
+            // from it when it is of the same kind (graphite.ts decides).
+            const rgb = osc === undefined ? null : parseOscColor(osc);
             // DC-3/DC-14's model: the first frame never waits for a reply.
             // A reply that changes nothing repaints nothing — which is also
             // why two answers that AGREE cost one repaint and not two.
-            if (next === currentGround())
+            if (next === currentGround() && sameRgb(rgb, currentGroundRgb()))
                 return;
-            setGround(next);
+            setGround(next, rgb);
             body.onGroundChange();
         };
         setGround(resolveGround({ theme: theme(), colorfgbg: process.env.COLORFGBG }));
         // the reply, when there is one, re-walks the ladder WITH it — and
         // `theme` goes in first again, so an explicit answer still wins.
         editor.onOsc((reply) => {
+            // Only the answer to the question asked (OSC 11, the background
+            // colour) is the ground: any other OSC a terminal sends would
+            // otherwise overwrite it.
+            if (!reply.startsWith("11;"))
+                return;
             osc = reply;
             rewalk();
         });
@@ -455,6 +477,9 @@ function makeLineInput() {
         // OR-11 (a): ONE literal. The compositor draws this lead and the
         // editor measures its rows against it; two copies is how they came
         // to disagree by two columns in the first place.
+        // Graphite §7.8 (owner, 2026-09-29): no prompt glyph — R2's ruling
+        // stands again after R1c's `›`; the caret is the terminal's own
+        // ink, at column 0, as in 0.44.
         const COMPOSER_LEAD = "";
         dock.bindInput(() => editor.dockState(), COMPOSER_LEAD);
         // …and BOTH renderers are live: the dock draws this row while it is
@@ -470,7 +495,7 @@ 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.bindSheet(() => editor.sheetContent()); // TUI2-R1 (D): the ? keys sheet; R3e: /status
         dock.bindPick(() => editor.pickState()); // TUI2-R2 ②: the resume picker's band
         // R5: the transcript viewer. The editor reports whether it is up and
         // forwards the commands; the STATE lives in the compositor, because
@@ -496,11 +521,15 @@ function bannerExtensionText() {
     // terminal layer (extensionsBannerText — a pure function of the three
     // name lists, including the "(connecting…)" in-flight label). Which
     // lists exist is the CLI's fact and stays here.
-    // 0.40.0: with the don't-ask switch on the ask extension is loaded but
-    // offers no tool (builtin.ts offInDontAsk) — the banner says so, rather
-    // than listing it as if it could ask.
+    return extensionsBannerText(...extensionLists());
+}
+/** The three lists both forms are built from — the pipe's line and the
+ *  opening's EXTENSIONS row. 0.40.0: with the don't-ask switch on the ask
+ *  extension is loaded but offers no tool (builtin.ts offInDontAsk) — the
+ *  banner says so, rather than listing it as if it could ask. */
+function extensionLists() {
     const builtIn = builtInExtensions.map((e) => (e.name === "ask" && getDontAsk() ? { name: e.name, note: "off in dontAsk" } : e));
-    return extensionsBannerText(builtIn, userExtensions, projectExtensions);
+    return [builtIn, userExtensions, projectExtensions];
 }
 /** 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
@@ -549,19 +578,15 @@ async function announceUpdate() {
         // did, a version check is not a reason to disturb a session.
     }
 }
-function extensionsBanner(resume = []) {
+function extensionsBanner(sessionId, resumedEvents = 0) {
     const text = bannerExtensionText();
     if (!process.stdout.isTTY) {
         if (text !== "")
             bodyLog(`${text}\n`);
         return;
     }
-    // R2: the opening answers the three questions a first screen is asked.
-    // The model and the tier come from the same state the status line reads
-    // (one source, so the two can never disagree); the workspace is the
-    // home-relative cwd, because `~/Desktop/devv/kiso` is what a human
-    // calls the place and `/Users/vinve/Desktop/devv/kiso` is what a
-    // filesystem calls it.
+    // Graphite §7.10: the opening states what loaded. The model, the mode
+    // and the folder are the status bar's now (§8.9) and are not repeated.
     const home = homedir();
     const cwd = process.cwd();
     /** DC-49: realpath, falling back to the raw path when it cannot be
@@ -575,15 +600,26 @@ function extensionsBanner(resume = []) {
             return dir;
         }
     };
-    body.banner(VERSION, text.replace(/^ · /, ""), resume, {
-        model: agentModel,
-        mode: modeDisplay(),
-        cwd: cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd,
-        // DC-49 — REALPATH on both sides. A symlinked HOME (or a symlinked
-        // cwd) compares unequal as raw strings while being the same
-        // directory, and the row would then be absent exactly where it is
-        // most needed.
-        homeWorkspace: realOf(cwd) === realOf(home),
+    const skills = loadedSkillsCatalog();
+    const mcp = loadedExtensions.find((e) => e.name === "mcp");
+    body.banner(VERSION, text.replace(/^ · /, ""), [], {
+        resumed: resumedEvents > 0,
+        facts: openingFacts({
+            // the last sweep: the new rows are the dock's; off one the
+            // `session <id>` and `[faux mode — …]` lines still print
+            sessionId: dock.active ? sessionId : null,
+            resumedEvents,
+            faux: dock.active && currentFaux,
+            rules: projectInstructions(cwd, protectedFiles())?.name ?? null,
+            skills: skills === null ? null : { count: skills.entries.length, broken: skills.broken.length },
+            mcp: mcp === undefined ? null : { tools: (mcp.tools ?? []).map((t) => t.name), connecting: mcp.connecting === true },
+            extensions: dock.active ? extensionsFact(...extensionLists()) : text === "" ? null : { value: text.replace(/^ · /, "") },
+            // DC-49 — REALPATH on both sides. A symlinked HOME (or a symlinked
+            // cwd) compares unequal as raw strings while being the same
+            // directory, and the row would then be absent exactly where it is
+            // most needed.
+            homeWorkspace: realOf(cwd) === realOf(home),
+        }),
     });
 }
 export { workspaceRoot } from "./state.js";
@@ -814,9 +850,10 @@ function bindRestoredSession(session) {
 function paintBootStatus(session) {
     if (!dock.active)
         return;
-    // DF-0330-F1: the BOOT row gets the budget too — it is the same row, and
-    // the opening screen is where a long model id is first seen.
-    dock.setStatus(idleStatus(modeDisplay(), statusModelLabel(session), displayCtxRatio(session), undefined, process.stdout.columns > 0 ? process.stdout.columns : 80));
+    // Graphite §8.9: the boot row is the status bar — the same builder the
+    // idle and running rows use (it used to drop `floor off`, the one fact
+    // the boot row most needs when it is true).
+    dock.setBar(barFor(session));
 }
 /** PH-1a (finding PH-F12): a usage error raised from inside the TUI —
  *  main's finally still runs (dock teardown, agent close, temp cleanup)
@@ -933,7 +970,7 @@ async function reloadAgent(old, id, input, announce = true) {
             delete process.env.KISO_DELEGATION_CONFIG_JSON;
         else
             process.env.KISO_DELEGATION_CONFIG_JSON = oldCfg.delegation;
-        bodyLog(`[reload] ${err instanceof Error ? err.message : String(err)} — nothing changed, the previous set is still in force`);
+        body.notice(`[reload] ${err instanceof Error ? err.message : String(err)} — nothing changed, the previous set is still in force`);
         return old;
     }
     // The new set is built and sound; only now does the old one go.
@@ -948,7 +985,7 @@ async function reloadAgent(old, id, input, announce = true) {
         }
     }
     if (announce)
-        bodyLog(`[reload] ${loadedExtensions.length} extensions, ${skillCount()} skills — the conversation is unchanged`);
+        body.notice(`[reload] ${loadedExtensions.length} extensions, ${skillCount()} skills — the conversation is unchanged`);
     return next;
 }
 async function chatLoop(first, firstId, input, autoCompact) {
@@ -1038,13 +1075,17 @@ async function chatLoop(first, firstId, input, autoCompact) {
             refused = false; // back in the session that was already on screen
         }
         else if (prev === null) {
-            bodyLog(`session ${id}\n`);
+            // the last sweep (owner, 2026-10-06): on the terminal the opening's
+            // SESSION row names the id — this line stood above the opening at
+            // column 0. A pipe keeps it.
+            if (!dock.active)
+                bodyLog(`session ${id}\n`);
             // REL-0152-D5: a session with history says what that history WAS.
             // Resuming used to print this one line and drop you at an empty
             // prompt inside a conversation with thousands of events — the
             // durable log was right there and none of it was shown. Empty for
             // a fresh session, so `kiso chat` is byte-identical.
-            showResumeTail(session.log.all);
+            showResumeTail(session.log.all, session.id);
             // R2 (owner, 2026-08-27): the resume list is NOT on the opening
             // screen. `/resume` is where you go looking for a session; the
             // opening's job is to say what THIS one is.
@@ -1053,7 +1094,7 @@ async function chatLoop(first, firstId, input, autoCompact) {
             // recent sessions just to draw a badge, and `agent.session()`
             // throws on profile drift — so one drifted session anywhere in the
             // history stopped kiso from starting at all.
-            extensionsBanner();
+            extensionsBanner(id, session.log.all.length);
             // OR-9 (owner, 2026-09-09): the update card under the banner, at
             // EVERY start while a newer version is known — §7.10's once-only
             // line is superseded. What the cache knows is painted NOW, with
@@ -1075,8 +1116,8 @@ async function chatLoop(first, firstId, input, autoCompact) {
             void announceUpdate();
         }
         else {
-            bodyLog(`session ${id} (switched — previous: ${prev}, /resume ${prev} returns)\n`);
-            showResumeTail(session.log.all);
+            body.notice(`session ${id} (switched — previous: ${prev}, /resume ${prev} returns)\n`);
+            showResumeTail(session.log.all, session.id);
             if (currentFaux)
                 session.setAdapter(createFauxProvider(readFauxScript().slice(fauxSkip(id))));
         }
@@ -1105,7 +1146,9 @@ async function chatLoop(first, firstId, input, autoCompact) {
         // 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);
+        // Graphite R3d: the session's own name, when the person gave it one
+        setTitleName(readSessionName(activeStoreDir, session.id));
+        paintWindowTitle();
         const nav = {
             // 0.40.0 dogfood: the ids only — agent.sessions() read every log whole
             // (seconds on the owner's 118 sessions) before /resume could open
@@ -1188,10 +1231,12 @@ async function readSecret(prompt) {
  * there is no viewer and no cell renderer, so the plain text tail stays
  * (DC-51: one call, one cell).
  */
-function showResumeTail(events) {
+function showResumeTail(events, sessionId) {
     const W = process.stdout.columns ?? 80;
+    // the tasks round: a task notice in the history reads its task's journal
+    // (Amendment 8: a lost task's row names what it ran — from the same list)
     if (dock.active)
-        replayInto(body, events, W);
+        replayInto(body, events, W, tasksForDisplay(tasksFor(sessionId)));
     else
         bodyLog(resumeTail(events, W).join("\n"));
 }
@@ -1508,6 +1553,10 @@ async function main() {
                 const id = arg ?? newSessionId(sessionsDir());
                 // v2b: the dock (TTY only) wraps the whole session — the
                 // trust question, the banner, the body, and the input line.
+                // the tasks round (owner, 2026-10-06): the first frames, before the
+                // bar is bound, offer no key ladder (§7.8 retired it) — set while
+                // the dock is not yet up, so nothing is drawn until enter() paints
+                dock.setStatus("", "");
                 dock.enter();
                 // E area: a resumed session continues the script at its durable
                 // position — never restarts it (fauxSkip).
@@ -1532,6 +1581,10 @@ async function main() {
                 // argv[4] is the optional prompt; argv[3] is the session id
                 // (argv = [node, script, resume, id, prompt?]).
                 const prompt = process.argv[4];
+                // the tasks round (owner, 2026-10-06): the first frames, before the
+                // bar is bound, offer no key ladder (§7.8 retired it) — set while
+                // the dock is not yet up, so nothing is drawn until enter() paints
+                dock.setStatus("", "");
                 dock.enter();
                 const routeLine = arg !== undefined ? enterRouted(arg) : null;
                 agent = await createCodingAgent(arg, input, modelFlag);
@@ -1575,7 +1628,7 @@ async function main() {
                     session.setAdapter(createFauxProvider(readFauxScript().slice(fauxSkip(id))));
                 // REL-0152-D5 — the same tail on the explicit-id form. NOT on
                 // the -p path above: that one's stdout is a machine's input.
-                showResumeTail(session.log.all);
+                showResumeTail(session.log.all, session.id);
                 await resume(session, prompt, faux, input);
                 break;
             }
@@ -1786,8 +1839,9 @@ async function main() {
                 // stopped, so a new user could never learn from the tool
                 // itself how to hand it a key.
                 const p = palette();
-                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" +
+                console.log(
+                // Graphite §7.10: the opening's head says the tagline already
+                `${p.dim}${bannerLines(80, process.stdout.rows ?? 0, VERSION, "").join("\n")}${p.reset}\n\n` +
                     "  kiso [sessionId]         interactive session (default command)\n" +
                     "  kiso chat [sessionId]    same as above\n" +
                     "  kiso resume              pick a session to continue (TTY picker)\n" +
@@ -1818,6 +1872,10 @@ async function main() {
                 // A area: no subcommand (or any non-command first argument) IS
                 // chat — the first argument is the session id.
                 const id = command ?? newSessionId(sessionsDir());
+                // the tasks round (owner, 2026-10-06): the first frames, before the
+                // bar is bound, offer no key ladder (§7.8 retired it) — set while
+                // the dock is not yet up, so nothing is drawn until enter() paints
+                dock.setStatus("", "");
                 dock.enter();
                 // R-I-p2 (finding R-I-p-2): the bare command passes the SAME
                 // input source and model flag as chat/resume — the pre-patch
@@ -1856,8 +1914,11 @@ async function main() {
         // scroll region, the cursor lands at the input line, no broken
         // terminal (kill -9 excepted; `reset` saves it).
         dock.exit();
+        // Graphite §8.10: a closed session never leaves a working or
+        // waiting mark in the tab
+        setTitleState("ready");
         for (const id of tasksAtExit.unconfirmed)
-            console.error(`${id}: stop unconfirmed — outcome unknown`);
+            console.error(`${id}: stop unconfirmed — it may still be running`);
         if (tasksAtExit.left.length > 0)
             console.error(`left running: ${tasksAtExit.left.join(", ")} — reopen this session to hear how ${tasksAtExit.left.length === 1 ? "it ends" : "they end"}`);
         // finding #8 (P1): extension dispose runs on the same exit path — a