@vincemakes/kiso-code 0.46.2 → 0.47.1

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, taskWhatOf } 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,7 +1075,11 @@ 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
@@ -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,7 +1116,7 @@ async function chatLoop(first, firstId, input, autoCompact) {
             void announceUpdate();
         }
         else {
-            bodyLog(`session ${id} (switched — previous: ${prev}, /resume ${prev} returns)\n`);
+            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
@@ -1190,9 +1233,10 @@ async function readSecret(prompt) {
  */
 function showResumeTail(events, sessionId) {
     const W = process.stdout.columns ?? 80;
-    // Amendment 8: a lost task's replayed row names what it ran
+    // 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, taskWhatOf(sessionId));
+        replayInto(body, events, W, tasksForDisplay(tasksFor(sessionId)));
     else
         bodyLog(resumeTail(events, W).join("\n"));
 }
@@ -1509,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).
@@ -1533,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);
@@ -1787,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" +
@@ -1819,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
@@ -1857,6 +1914,9 @@ 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 — it may still be running`);
         if (tasksAtExit.left.length > 0)

package/dist/opening.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Graphite §7.10 — what the opening says loaded: the session, the
+ * project's rules, the skills, the MCP servers, and the extensions. The
+ * model, the mode and the folder are the status bar's (§8.9) and are not
+ * repeated here — except the faux model, which the bar names but cannot
+ * say how to leave.
+ *
+ * Pure over what the CLI already holds at startup; the banner lays the
+ * facts out and knows nothing of where they came from.
+ */
+import type { BannerFact } from "@vincemakes/kiso-tui";
+export interface OpeningInputs {
+    /** The session's id — the SESSION row names it (the last sweep: the
+     *  `session <id>` line above the opening retired on a dock). Null off a
+     *  dock, where that line still prints: the row keeps its old form. */
+    readonly sessionId: string | null;
+    /** The events a resumed session opened with; 0 for a new one. */
+    readonly resumedEvents: number;
+    /** No model resolved and on a dock: the scripted faux model answers
+     *  (off a dock the `[faux mode — …]` line still prints). */
+    readonly faux: boolean;
+    /** The instruction file the prompt reads (`projectInstructions`), or null. */
+    readonly rules: string | null;
+    /** The skills catalog's size, or null when no skills extension loaded. */
+    readonly skills: {
+        readonly count: number;
+        readonly broken: number;
+    } | null;
+    /** The MCP extension's tools as they stand, or null when it is not loaded. */
+    readonly mcp: {
+        readonly tools: readonly string[];
+        readonly connecting: boolean;
+    } | null;
+    /** The extensions — `extensionsFact`'s count and names, from the SAME
+     *  three lists the pipe's `[N extensions: …]` line is built from (so the
+     *  two still cannot disagree about what loaded, and the 0.40.0 `ask (off
+     *  in dontAsk)` note stays beside the tier that turns it off); null when
+     *  nothing loaded. The last sweep (owner, 2026-10-06): the row carried
+     *  the pipe's bracketed line verbatim — as it still does off a dock
+     *  (`{ value: <the line> }`). */
+    readonly extensions: {
+        readonly value: string;
+        readonly note?: string;
+    } | null;
+    /** DC-49 — the workspace is the home directory. */
+    readonly homeWorkspace: boolean;
+}
+export declare function openingFacts(o: OpeningInputs): BannerFact[];

package/dist/opening.js

@@ -0,0 +1,43 @@
+/**
+ * Graphite §7.10 — what the opening says loaded: the session, the
+ * project's rules, the skills, the MCP servers, and the extensions. The
+ * model, the mode and the folder are the status bar's (§8.9) and are not
+ * repeated here — except the faux model, which the bar names but cannot
+ * say how to leave.
+ *
+ * Pure over what the CLI already holds at startup; the banner lays the
+ * facts out and knows nothing of where they came from.
+ */
+const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
+export function openingFacts(o) {
+    const facts = [];
+    if (o.sessionId === null)
+        facts.push(o.resumedEvents > 0 ? { label: "SESSION", value: "resumed", note: plural(o.resumedEvents, "event") } : { label: "SESSION", value: "new", note: "resumable after kill -9" });
+    else
+        facts.push({ label: "SESSION", value: o.sessionId, note: o.resumedEvents > 0 ? `resumed \u00b7 ${plural(o.resumedEvents, "event")}` : "new \u00b7 resumable after kill -9" });
+    // the last sweep: no model resolved — the bar says `faux`, and this row
+    // says how to leave it (the line that said so was painted over at once)
+    // (as short as the RULES note: beside the wordmark a longer note is cut)
+    if (o.faux)
+        facts.push({ label: "MODEL", value: "faux", note: "set an API key, or add a model to config.json" });
+    facts.push(o.rules !== null ? { label: "RULES", value: o.rules } : { label: "RULES", value: "none", note: "an AGENTS.md or CLAUDE.md here is read" });
+    if (o.skills !== null) {
+        facts.push({ label: "SKILLS", value: String(o.skills.count), note: o.skills.broken > 0 ? `${o.skills.broken} cannot load · /skills` : "/skills lists them" });
+    }
+    if (o.mcp !== null) {
+        // the status tool is the extension's own, not a server's
+        const served = o.mcp.tools.filter((t) => t.startsWith("mcp__") && t !== "mcp__status");
+        const servers = new Set(served.map((t) => /^mcp__(.+?)__/.exec(t)?.[1] ?? t)).size;
+        if (servers === 0)
+            facts.push({ label: "MCP", value: o.mcp.connecting ? "connecting…" : "none" });
+        else
+            facts.push({ label: "MCP", value: plural(servers, "server"), note: `${plural(served.length, "tool")}${o.mcp.connecting ? " · connecting…" : ""}` });
+    }
+    if (o.extensions !== null)
+        facts.push({ label: "EXTENSIONS", value: o.extensions.value, ...(o.extensions.note !== undefined ? { note: o.extensions.note } : {}) });
+    // DC-49: STATES the fact and names the remedy; it does not warn — the
+    // configuration is allowed (owner, 2026-09-06)
+    if (o.homeWorkspace)
+        facts.push({ label: "", value: "home directory as workspace — cd into a project to narrow it" });
+    return facts;
+}

package/dist/replay.d.ts

@@ -19,6 +19,8 @@
  *     summary (what the model sees next) and the turns it covers, read in
  *     the viewer — then any uncovered earlier turns folded as above.
  */
+import type { TaskInfo } from "@vincemakes/kiso-runtime/internal";
+import type { NoticeMark } from "@vincemakes/kiso-tui";
 /** The Body surface the replay drives — the live run's own mutations. */
 export interface ReplayBody {
     userLine(text: string): void;
@@ -34,6 +36,11 @@ export interface ReplayBody {
         untimed?: boolean;
     }): void;
     notice(text: string): void;
+    metaNotice(text: string, rows: readonly {
+        readonly label: string;
+        readonly sentence: string;
+        readonly mark?: NoticeMark;
+    }[]): void;
     endTurn(thoughtSeconds: number): void;
     fold(label: string, replay: () => void, summary?: string | null): void;
     raw(lines: string[]): void;
@@ -49,5 +56,5 @@ export declare function turnsOf(events: readonly Ev[]): Ev[][];
  * Replay a session's durable events into the body. Returns the number of
  * turns it found (0: a fresh session — nothing is drawn).
  */
-export declare function replayInto(body: ReplayBody, events: readonly Ev[], W?: number, what?: (taskId: string) => string | undefined): number;
+export declare function replayInto(body: ReplayBody, events: readonly Ev[], W?: number, tasks?: readonly TaskInfo[]): number;
 export {};