@vincemakes/kiso-code 0.46.2 → 0.47.0

package/dist/replay.js

@@ -20,7 +20,8 @@
  *     the viewer — then any uncovered earlier turns folded as above.
  */
 import { echoText } from "@vincemakes/kiso-tui-cells/render";
-import { taskNoticeLines } from "./task-notice.js";
+import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
+import { taskNoticeLines, taskNoticeRows, taskWhat } from "./task-notice.js";
 /** How many turns stay on screen in full. */
 const FULL_TURNS = 2;
 /** A user turn's opening line, or null when this input does not open one
@@ -48,7 +49,7 @@ export function turnsOf(events) {
 }
 /** One turn through the Body — consumeRun's mapping, minus everything that
  *  needs the live process (clocks, tailers, usage, the recap). */
-function replayTurn(body, turn, what) {
+function replayTurn(body, turn, tasks) {
     let thinking = false;
     let said = false;
     const results = new Set();
@@ -62,9 +63,17 @@ function replayTurn(body, turn, what) {
                 const ask = askOf(e);
                 if (ask !== null)
                     body.userLine(ask);
-                else if (e.via?.kind === "tasks")
-                    for (const row of taskNoticeLines(e.via.items, what))
-                        body.notice(row);
+                else if (e.via?.kind === "tasks") {
+                    // the tasks round: the same rows a live session drew, from the
+                    // journal; the pipe's lines are taskNoticeLines' (Amendment 8: a
+                    // lost task's line names what it ran)
+                    const items = e.via.items;
+                    const what = (taskId) => {
+                        const t = tasks.find((x) => x.id === taskId);
+                        return t === undefined ? undefined : taskWhat(t);
+                    };
+                    body.metaNotice(taskNoticeLines(items, what).join("\n"), taskNoticeRows(items, tasks));
+                }
                 else if (e.source === "system") {
                     body.notice("verification pass");
                     body.notice(`  ${typeof e.content === "string" ? e.content : ""}`);
@@ -125,7 +134,7 @@ const plural = (n, one) => `${n} ${one}${n === 1 ? "" : "s"}`;
  * Replay a session's durable events into the body. Returns the number of
  * turns it found (0: a fresh session — nothing is drawn).
  */
-export function replayInto(body, events, W = 80, what) {
+export function replayInto(body, events, W = 80, tasks = []) {
     // The latest checkpoint: the turns it covers are what the model will
     // read as its summary, not as turns.
     let checkpoint = null;
@@ -141,22 +150,24 @@ export function replayInto(body, events, W = 80, what) {
     const shown = rest.slice(-FULL_TURNS);
     const earlier = rest.slice(0, rest.length - shown.length);
     const label = total > shown.length ? `resuming · ${plural(total, "turn")}, showing the last ${shown.length}` : `resuming · ${plural(total, "turn")}`;
-    const head = `─── ${label} `;
-    body.raw([`${head}${"─".repeat(Math.max(1, W - head.length))}`.slice(0, Math.max(1, W))]);
+    // Graphite §8.1 (R3b): the resumed history opens like every band — the
+    // hairline with its name, `resuming` bold gold, the counts dim (the same
+    // words the dim rule carried)
+    body.raw([bandHeader(label, Math.max(1, W))]);
     if (checkpoint !== null) {
         const summary = checkpoint.summary;
         body.fold(`checkpoint · summarizes ${plural(covered.length, "earlier turn")} · ctrl+r to read`, () => {
             for (const t of covered)
-                replayTurn(body, t, what);
+                replayTurn(body, t, tasks);
         }, summary);
     }
     if (earlier.length > 0) {
         body.fold(`${plural(earlier.length, "earlier turn")} · ctrl+r to read`, () => {
             for (const t of earlier)
-                replayTurn(body, t, what);
+                replayTurn(body, t, tasks);
         });
     }
     for (const t of shown)
-        replayTurn(body, t, what);
+        replayTurn(body, t, tasks);
     return total;
 }

package/dist/resume.js

@@ -2,12 +2,12 @@
  * The ergonomics batch B4 (pure move) — resume: the RECOVERY flow (Area 2/7). The body
  * moved verbatim from index.ts.
  */
-import { idleStatus, runningStatus } from "@vincemakes/kiso-tui";
-import { modeDisplay } from "./mode.js";
-import { agentModel, dock, retryOnRow, floorOn } from "./state.js";
+import { STATUS_GLYPHS, workingRow } from "@vincemakes/kiso-tui";
+import { dock, retryOnRow } from "./state.js";
 import { pendingAsk, resolveUncertains } from "./trust-ui.js";
 import { failOnFauxExhaustion } from "./faux-glue.js";
-import { consumeRun, estimateCtxRatio, startStatusSpinner } from "./chat.js";
+import { setTitleState } from "./window-title.js";
+import { barFor, consumeRun, estimateCtxRatio, startStatusSpinner } from "./chat.js";
 /**
  * Resume = the RECOVERY flow (Area 2/7): uncertain executions are decided,
  * the interrupted run is continued via session.resume() — never faked with
@@ -21,23 +21,26 @@ export async function resume(session, prompt, faux, input) {
     let turnNo = 0;
     // v3 §03: the two-state status bar (see chat — same shapes).
     let runUsage = { in: null, out: null, cache: null, known: false };
-    let runGlyph = "▖";
+    let runGlyph = STATUS_GLYPHS[0];
     let runStart = Date.now();
     // KC2 §5: the rows the REPL and this flow used to build separately are
-    // ONE formatter now — the running row was duplicated verbatim.
-    const statusCb = (u, ctx) => {
+    // ONE formatter now. Graphite §8.7 / §8.9: the running turn's facts ride
+    // the live row, the session's the status bar — the chat's own two
+    // (barFor), so the recovery flow now spells plan's posture the same way.
+    const width = () => (process.stdout.columns > 0 ? process.stdout.columns : 80);
+    const statusCb = (u, _ctx) => {
         runUsage = u;
-        if (dock.active)
-            dock.setStatus(runningStatus(runGlyph, runStart, u.out, ctx, null, process.stdout.columns > 0 ? process.stdout.columns : 80, retryOnRow()));
+        if (!dock.active)
+            return;
+        dock.setLive(workingRow(runGlyph, runStart, u.out, null, width(), retryOnRow()));
+        dock.setBar(barFor(session, { tokPerSec: null }));
     };
-    // the recovery flow prints the BARE mode (chat spells plan's posture) —
-    // the extraction keeps that difference, it was not asked to settle it.
     const paintIdle = () => {
-        // DF-0330-F1: the recovery flow paints the same row, so it gets the
-        // same budget. It has no meter, so nothing here can be dropped that
-        // was not already at risk of being cut.
-        if (dock.active)
-            dock.setStatus(idleStatus(modeDisplay(), agentModel, estimateCtxRatio(session), undefined, process.stdout.columns > 0 ? process.stdout.columns : 80, !floorOn));
+        setTitleState("ready");
+        if (!dock.active)
+            return;
+        dock.setLive(null);
+        dock.setBar(barFor(session, { tokPerSec: null }));
     };
     const withRun = async (run) => {
         currentRun = run;
@@ -47,6 +50,8 @@ export async function resume(session, prompt, faux, input) {
             runGlyph = g;
             statusCb(runUsage, estimateCtxRatio(session));
         });
+        statusCb(runUsage, estimateCtxRatio(session)); // the live row from the run's first frame
+        setTitleState("working");
         try {
             turnNo += 1;
             const last = await consumeRun(session, run, input, turnNo, faux, statusCb);

package/dist/session-cards.d.ts

@@ -88,6 +88,8 @@ export declare function projectSessionCard(input: {
     readonly asks: number;
     readonly workspace?: string | null;
     readonly profileName?: string | null;
+    /** Graphite R3d: the session's `/name`, which wins over the derived title */
+    readonly name?: string | null;
 }): SessionCard;
 /** The shapes this module needs from the agent — structural, so the
  *  projection is testable without standing up a provider. */

package/dist/session-cards.js

@@ -76,7 +76,7 @@ export function projectSessionCard(input) {
                         : "failed";
     return {
         id: input.id,
-        title: sessionTitle(input.records),
+        title: input.name ?? sessionTitle(input.records),
         badge,
         turns,
         updatedAt: input.updatedAt,
@@ -128,11 +128,11 @@ export function cardFromListing(l) {
     const s = l.summary;
     const base = { id: l.id, workspace: l.workspace, profileName: l.profileName, ...(l.inferred === true ? { inferred: true } : {}) };
     if (s === null)
-        return { ...base, title: l.id, badge: "unknown", turns: null, updatedAt: l.mtime, uncertain: 0, asks: 0, outcome: "no summary" };
+        return { ...base, title: l.name ?? l.id, badge: "unknown", turns: null, updatedAt: l.mtime, uncertain: 0, asks: 0, outcome: "no summary" };
     const badge = s.uncertain > 0 ? "uncertain" : s.asks > 0 ? "ask" : s.state === "open" ? "interrupted" : s.state === "completed" ? "completed" : s.state === null ? "unknown" : "failed";
     return {
         ...base,
-        title: s.title ?? l.id,
+        title: l.name ?? s.title ?? l.id,
         badge,
         turns: s.turns,
         updatedAt: s.updatedAt,

package/dist/settings.d.ts

@@ -37,4 +37,23 @@ export interface SettingsInput {
     readonly thinkingRemembered: boolean;
     readonly version: string;
 }
+export interface Row {
+    readonly name: string;
+    readonly value: string;
+    readonly from: string;
+    readonly change: string;
+    /** Graphite P3: the value as a table cell (`on`, `1M`) where `value` is
+     *  a sentence; absent, the value is already short */
+    readonly brief?: string;
+    /** Graphite P3: what the sentence said that the cell does not — the
+     *  panel's opened row carries it */
+    readonly means?: string;
+}
+/** Graphite R3e: the settings as data — the /settings panel's rows and
+ *  the printed form below read the same list. */
+export declare function settingsFacts(i: SettingsInput): Row[];
+/** The printed form: one block per setting — what it is, where it came
+ *  from and how to change it (a pipe, a dock-less TTY, and a panel row's
+ *  enter). */
+export declare function settingRow(r: Row, width?: number): string;
 export declare function settingsRows(i: SettingsInput): string[];

package/dist/settings.js

@@ -40,7 +40,7 @@ function dontAskRow(i) {
     const on = i.dontAsk === true;
     const resolved = resolveModeLayers(modeLayers(i));
     const from = (resolved.dontAsk !== "off") === on ? dontAskFrom(i, resolved.from.dontAsk) : "set in this session";
-    return { name: "don't ask", value: on ? "on — what would ask is refused" : "off", from, change };
+    return { name: "don't ask", value: on ? "on — what would ask is refused" : "off", from, change, brief: on ? "on" : "off", ...(on ? { means: "what would ask is refused" } : {}) };
 }
 function modelRow(i) {
     const change = "/model; \"model\" in ~/.kiso/config.json";
@@ -73,7 +73,15 @@ function layered(i, key) {
         return { value: i.user[key], from: "user config" };
     return { value: undefined, from: "default" };
 }
-export function settingsRows(i) {
+/** The window's sentence as a cell and the rest (`1M` / `the registry's
+ *  for this endpoint`) — the window chain words it `<size>, <source>`. */
+function windowCells(window) {
+    const cut = window.indexOf(", ");
+    return cut < 0 ? {} : { brief: window.slice(0, cut), means: window.slice(cut + 2) };
+}
+/** Graphite R3e: the settings as data — the /settings panel's rows and
+ *  the printed form below read the same list. */
+export function settingsFacts(i) {
     const trust = layered(i, "projectTrust");
     const auto = i.env.KISO_AUTO_COMPACT !== undefined ? { value: i.env.KISO_AUTO_COMPACT, from: "env KISO_AUTO_COMPACT" } : layered(i, "autoCompact");
     const rows = [
@@ -86,9 +94,18 @@ export function settingsRows(i) {
             value: i.floorOn ? "on — irrecoverable deletes are refused in every mode" : "off",
             from: i.user?.floor !== undefined ? "user config" : "default",
             change: "\"floor\": \"off\" in ~/.kiso/config.json (user config only)",
+            brief: i.floorOn ? "on" : "off",
+            ...(i.floorOn ? { means: "irrecoverable deletes are refused in every mode" } : {}),
+        },
+        { name: "window", value: i.window, from: "the window chain (see /status)", change: "\"contextWindow\" on the profile; KISO_CONTEXT_WINDOW for one run", ...windowCells(i.window) },
+        {
+            name: "compaction",
+            value: "in-run: past half the window at a phase end, past 80% at once",
+            from: "built in",
+            change: "/compact on demand",
+            brief: "50% · 80%",
+            means: "past half the window at a phase end, past 80% at once",
         },
-        { name: "window", value: i.window, from: "the window chain (see /status)", change: "\"contextWindow\" on the profile; KISO_CONTEXT_WINDOW for one run" },
-        { name: "compaction", value: "in-run: past half the window at a phase end, past 80% at once", from: "built in", change: "/compact on demand" },
         {
             name: "auto-compact",
             value: auto.value === undefined ? "off" : typeof auto.value === "object" ? `at ${auto.value.thresholdRatio} of the window, at a run's start` : String(auto.value),
@@ -101,9 +118,21 @@ export function settingsRows(i) {
             value: i.thinkingHidden ? "hidden — one line per block" : "shown",
             from: i.thinkingRemembered ? "ctrl+t (remembered)" : "default",
             change: "ctrl+t",
+            brief: i.thinkingHidden ? "hidden" : "shown",
+            ...(i.thinkingHidden ? { means: "one line per block" } : {}),
         },
         { name: "version", value: i.version, from: "running", change: "kiso update" },
     ];
+    return rows;
+}
+/** The printed form: one block per setting — what it is, where it came
+ *  from and how to change it (a pipe, a dock-less TTY, and a panel row's
+ *  enter). */
+export function settingRow(r, width = r.name.length + 2) {
+    return `${r.name.padEnd(width)}${r.value}\n${" ".repeat(width)}from ${r.from} · change: ${r.change}`;
+}
+export function settingsRows(i) {
+    const rows = settingsFacts(i);
     const width = Math.max(...rows.map((r) => r.name.length)) + 2;
-    return rows.map((r) => `${r.name.padEnd(width)}${r.value}\n${" ".repeat(width)}from ${r.from} · change: ${r.change}`);
+    return rows.map((r) => settingRow(r, width));
 }

package/dist/skill-invoke.d.ts

@@ -44,6 +44,17 @@ export declare function nearest(name: string, names: readonly string[]): string[
  *  `model only` tag for `user-invocable: false`, then the broken entries
  *  with the loader's own reason. */
 export declare function skillsRows(catalog: SkillsCatalog | null, sourceOf: (dir: string) => string, userDir: string): string[];
+/**
+ * The sheets round (owner, 2026-10-06) — `/skills` on a dock is a sheet
+ * over the input, the shape `/status` has (§8.16). The band says how many,
+ * how many cannot load, and where they live when that is one place
+ * (`skills · 3 · 1 cannot load · ~/.kiso/skills`); each skill is one row,
+ * `/name` in ink in a measured column and its description dim, cut by
+ * cells; with more than one place, the place ends the row. A skill that
+ * cannot load says why, in the failure colour. How to run one is the
+ * closing row. On a pipe `/skills` prints `skillsRows`, unchanged.
+ */
+export declare function skillsSheetRows(catalog: SkillsCatalog | null, sourceOf: (dir: string) => string, userDir: string, W: number): string[];
 /**
  * 0.40.1 (owner's ruling, revoking the 0.41.0 deferral) — the installed
  * skills as `/` menu entries. The same rule the dispatcher follows, so the

package/dist/skill-invoke.js

@@ -14,6 +14,9 @@
  * one answer — the model's index and this door are one list), and every
  * outcome is data. The dispatcher does the printing and the submitting.
  */
+import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
+import { cutLine, escapeTerminal, palette } from "@vincemakes/kiso-tui-cells/render";
+import { visibleWidth, widthCut } from "@vincemakes/kiso-tui-cells/width";
 /**
  * What a submitted line asks of the skills, if anything. `null` means the
  * line is not a skill request, and the dispatcher goes on as before — which
@@ -120,6 +123,62 @@ export function skillsRows(catalog, sourceOf, userDir) {
     rows.push("/<name> [args] or /skill <name> [args] runs one · a built-in command wins a shared name");
     return rows;
 }
+/** The last `cells` cells of `text`, by display width. */
+function leftCut(text, cells) {
+    const chars = Array.from(text);
+    let out = "";
+    for (let i = chars.length - 1; i >= 0; i -= 1) {
+        if (visibleWidth(chars[i] + out) > cells)
+            break;
+        out = chars[i] + out;
+    }
+    return out;
+}
+/**
+ * The sheets round (owner, 2026-10-06) — `/skills` on a dock is a sheet
+ * over the input, the shape `/status` has (§8.16). The band says how many,
+ * how many cannot load, and where they live when that is one place
+ * (`skills · 3 · 1 cannot load · ~/.kiso/skills`); each skill is one row,
+ * `/name` in ink in a measured column and its description dim, cut by
+ * cells; with more than one place, the place ends the row. A skill that
+ * cannot load says why, in the failure colour. How to run one is the
+ * closing row. On a pipe `/skills` prints `skillsRows`, unchanged.
+ */
+export function skillsSheetRows(catalog, sourceOf, userDir, W) {
+    const p = palette();
+    const entries = catalog?.entries ?? [];
+    const broken = catalog?.broken ?? [];
+    const close = `  ${p.dim}/<name> runs one \u00b7 a built-in wins its name \u00b7 esc closes${p.reset}`;
+    if (entries.length === 0 && broken.length === 0) {
+        return [bandHeader("skills \u00b7 none", W), `  ${p.dim}add one as ${escapeTerminal(userDir)}/<name>/SKILL.md${p.reset}`, close].map((r) => cutLine(r, W));
+    }
+    const places = [...new Set([...entries.map((e) => sourceOf(e.dir)), ...broken.map((b) => sourceOf(b.dir))])];
+    const facts = [String(entries.length), ...(broken.length > 0 ? [`${broken.length} cannot load`] : [])];
+    // the place is cut from the LEFT when the band cannot hold it (P4's
+    // rule for a path in a band name): its end — the folder's own name —
+    // and the rule after it stay on screen
+    const head = `skills \u00b7 ${facts.join(" \u00b7 ")}`;
+    const where = places.length === 1 ? escapeTerminal(places[0]) : "";
+    const roomFor = Math.max(0, W - 8 - visibleWidth(head) - 3);
+    const shown = where === "" || roomFor < 2 ? "" : visibleWidth(where) <= roomFor ? where : `\u2026${leftCut(where, roomFor - 1)}`;
+    const rows = [bandHeader(shown === "" ? head : `${head} \u00b7 ${shown}`, W)];
+    const names = [...entries.map((e) => `/${escapeTerminal(e.name)}`), ...broken.map((b) => escapeTerminal(b.dir))];
+    const nw = Math.max(...names.map((n) => visibleWidth(n))) + 2;
+    const fit = (text, room) => (visibleWidth(text) <= room ? text : `${widthCut(text, Math.max(1, room - 1))}…`);
+    const place = (dir) => (places.length > 1 ? ` \u00b7 ${escapeTerminal(sourceOf(dir))}` : "");
+    const room = Math.max(1, W - 2 - nw - 1);
+    for (const e of entries) {
+        const name = `/${escapeTerminal(e.name)}`;
+        const what = `${escapeTerminal(e.description)}${e.userInvocable ? "" : " (model only)"}${place(e.dir)}`;
+        rows.push(`  ${name}${" ".repeat(nw - visibleWidth(name))}${p.dim}${fit(what, room)}${p.reset}`);
+    }
+    for (const b of broken) {
+        const name = escapeTerminal(b.dir);
+        rows.push(`  ${p.dim}${name}${" ".repeat(nw - visibleWidth(name))}${p.reset}${p.fail}${fit(`cannot load: ${escapeTerminal(b.reason)}${place(b.dir)}`, room)}${p.fgEnd}`);
+    }
+    rows.push(close);
+    return rows.map((r) => cutLine(r, W));
+}
 /**
  * 0.40.1 (owner's ruling, revoking the 0.41.0 deferral) — the installed
  * skills as `/` menu entries. The same rule the dispatcher follows, so the

package/dist/state.d.ts

@@ -196,6 +196,13 @@ export interface LineInput {
     panelAsk(view: PanelView, onCommit: (v: PanelVerdict) => void, opts?: {
         safer?: () => Promise<SaferAnswer>;
     }): void;
+    /** Graphite R3e: a read-only sheet over the input with the caller's rows
+     *  (`/status`, `/context`, `/skills`); any key closes it. Absent off a
+     *  dock. */
+    openSheet?(rows: (W: number) => string[]): void;
+    /** The sheets round: open the command list, as a typed `/` does
+     *  (`/help`). Absent off a dock. */
+    openCommands?(): void;
     /** W21: cancel the panel — the SIGINT pair to panelAsk. */
     panelCancel(): void;
     /** TUI2-R2 ②: open the session picker — the editor takes the keys

package/dist/task-notice.d.ts

@@ -1,5 +1,6 @@
 import type { TaskDeliveryItem } from "@vincemakes/kiso-core";
 import { type TaskInfo } from "@vincemakes/kiso-runtime/internal";
+import type { NoticeMark } from "@vincemakes/kiso-tui";
 /** The lines a delivery shows: today's `✦ task t1 exited · t2 failed` for
  *  the ordinary items, and one `✦ lost track of …` row per lost task. The
  *  shape is fixed (a design keys on it): the opening `✦ lost track of <id>
@@ -28,3 +29,35 @@ export declare function taskOutput(task: TaskInfo, lines?: number): string[];
 export declare function taskCounts(tasks: readonly TaskInfo[]): {
     readonly running: number;
 };
+/** The tasks round (owner, 2026-10-06) — how a task ended, in one word and
+ *  its colour: a shell `exited 0` (or `failed 1`), a child `answered` (or
+ *  `failed`), `stopped` dim, `lost track — may still be running` gold (the
+ *  main sync, Amendment 8's words; it read `◌ outcome unknown`), `ready`
+ *  when a long-running command said it was. Read from the task's own journal, so a
+ *  resumed session says what a live one did; with no journal entry, the
+ *  delivery's transition word, uncoloured. */
+export declare function taskOutcome(task: TaskInfo | undefined, transition: TaskDeliveryItem["transition"]): {
+    readonly word: string;
+    readonly tone: NoticeMark["tone"] | null;
+};
+/** The tasks round — a task delivery on the terminal: one meta row per
+ *  task, `TASK` once and the rows under it unlabelled, each `<id> <how it
+ *  ended> · <what ran>` with the outcome word marked; a lost task adds
+ *  where to look (`· /tasks shows it`). The pipe keeps `taskNoticeLines`'
+ *  lines, byte for byte. */
+export declare function taskNoticeRows(items: readonly TaskDeliveryItem[], tasks: readonly TaskInfo[]): {
+    readonly label: string;
+    readonly sentence: string;
+    readonly mark?: NoticeMark;
+}[];
+/** A session's tasks for display, or none: a journal that cannot be read
+ *  is reported where it is read on purpose (`/tasks`), never here. */
+export declare function tasksForDisplay(manager: {
+    list(): TaskInfo[];
+} | undefined): readonly TaskInfo[];
+/** The tasks round (owner, 2026-10-06) — `/tasks` → show its output, on a
+ *  dock: a sheet over the input, `/context`'s shape (§8.16). The band
+ *  names the task, which output it is, and how it ended; the lines at the
+ *  content edge, each cut to one row; the closing row. On a pipe the
+ *  printed lines stay. */
+export declare function taskOutputSheetRows(task: TaskInfo, lines: readonly string[], W: number): string[];

package/dist/task-notice.js

@@ -16,6 +16,8 @@ import { closeSync, fstatSync, openSync, readFileSync, readSync } from "node:fs"
 import { dirname, join } from "node:path";
 import { readRecords } from "@vincemakes/kiso-runtime/internal";
 import { elapsedLabel } from "@vincemakes/kiso-tui-cells";
+import { SHEET_CLOSE, bandHeader } from "@vincemakes/kiso-tui-cells/strings";
+import { cutLine, escapeTerminal, palette } from "@vincemakes/kiso-tui-cells/render";
 /** The lines a delivery shows: today's `✦ task t1 exited · t2 failed` for
  *  the ordinary items, and one `✦ lost track of …` row per lost task. The
  *  shape is fixed (a design keys on it): the opening `✦ lost track of <id>
@@ -121,3 +123,74 @@ export function taskCounts(tasks) {
             running += 1;
     return { running };
 }
+/** The tasks round (owner, 2026-10-06) — how a task ended, in one word and
+ *  its colour: a shell `exited 0` (or `failed 1`), a child `answered` (or
+ *  `failed`), `stopped` dim, `lost track — may still be running` gold (the
+ *  main sync, Amendment 8's words; it read `◌ outcome unknown`), `ready`
+ *  when a long-running command said it was. Read from the task's own journal, so a
+ *  resumed session says what a live one did; with no journal entry, the
+ *  delivery's transition word, uncoloured. */
+export function taskOutcome(task, transition) {
+    if (task === undefined)
+        return { word: transition, tone: null };
+    if (transition === "ready")
+        return { word: "ready", tone: "ok" };
+    const label = taskStateLabel(task);
+    if (label === "exited 0")
+        return { word: task.agent !== undefined ? "answered" : "exited 0", tone: "ok" };
+    if (label.startsWith("failed"))
+        return { word: task.agent !== undefined && label !== "failed to start" ? "failed" : label, tone: "fail" };
+    if (task.state.kind === "unknown")
+        return { word: label, tone: "gold" };
+    return { word: label, tone: null };
+}
+/** The tasks round — a task delivery on the terminal: one meta row per
+ *  task, `TASK` once and the rows under it unlabelled, each `<id> <how it
+ *  ended> · <what ran>` with the outcome word marked; a lost task adds
+ *  where to look (`· /tasks shows it`). The pipe keeps `taskNoticeLines`'
+ *  lines, byte for byte. */
+export function taskNoticeRows(items, tasks) {
+    // (a lost task adds `· /tasks shows it`, before what ran)
+    return items.map((item, i) => {
+        const task = tasks.find((t) => t.id === item.taskId);
+        const { word, tone } = item.transition === "unknown" && task === undefined ? { word: "lost track — may still be running", tone: "gold" } : taskOutcome(task, item.transition);
+        const what = task === undefined ? "" : ` · ${taskWhat(task)}`;
+        // where to look before what ran: the row is cut at the end
+        const where = item.transition === "unknown" ? " · /tasks shows it" : "";
+        return { label: i === 0 ? "TASK" : "", sentence: `${item.taskId} ${word}${where}${what}`, ...(tone !== null ? { mark: { text: word, tone } } : {}) };
+    });
+}
+/** A session's tasks for display, or none: a journal that cannot be read
+ *  is reported where it is read on purpose (`/tasks`), never here. */
+export function tasksForDisplay(manager) {
+    if (manager === undefined)
+        return [];
+    try {
+        return manager.list();
+    }
+    catch {
+        return [];
+    }
+}
+/** The tasks round (owner, 2026-10-06) — `/tasks` → show its output, on a
+ *  dock: a sheet over the input, `/context`'s shape (§8.16). The band
+ *  names the task, which output it is, and how it ended; the lines at the
+ *  content edge, each cut to one row; the closing row. On a pipe the
+ *  printed lines stay. */
+export function taskOutputSheetRows(task, lines, W) {
+    const p = palette();
+    const which = task.agent !== undefined ? "its answer" : "its last output";
+    const { word } = taskOutcome(task, "exited");
+    const rows = [bandHeader(`${task.id} · ${which} · ${task.state.kind === "running" || task.state.kind === "starting" ? taskStateLabel(task) : word}`, W)];
+    // the main sync (0.46.2, Amendment 8): a lost task says why, first, in
+    // gold — the printed form's `t1 — lost track: …` line
+    const why = lostReason(task);
+    if (why !== undefined)
+        rows.push(`  ${p.gold}lost track: ${escapeTerminal(why)}; it may still be running${p.gold === "" ? "" : p.fgEnd}`);
+    if (lines.length === 0)
+        rows.push(`  ${p.dim}nothing yet${p.reset}`);
+    for (const line of lines)
+        rows.push(`  ${p.ink2}${escapeTerminal(line)}${p.ink2 === "" ? "" : p.fgEnd}`);
+    rows.push(`  ${p.dim}${SHEET_CLOSE}${p.reset}`);
+    return rows.map((r) => cutLine(r, W));
+}

package/dist/trust-ui.d.ts

@@ -111,4 +111,11 @@ export declare function applyProjectMerges(artifacts: ProjectArtifacts): void;
  *  execution stays uncertain and durable — no rerun/abandoned is
  *  fabricated, round 10). The resolution feedback lands in the body —
  *  the body is the single stdout writer, never a stray console.log. */
+/** Graphite P1b — what an uncertain execution's panel quotes: a shell
+ *  command verbatim (every line of it), any other call's target as its
+ *  tool card names it. From the execution record's own input. */
+export declare function uncertainTarget(name: string, input: Readonly<Record<string, unknown>>): string[];
+/** Graphite P1b — an interrupted ask_user's questions, as the model wrote
+ *  them; empty when the input carries none (the panel then quotes the id). */
+export declare function askedQuestions(input: Readonly<Record<string, unknown>>): string[];
 export declare function resolveUncertains(session: AgentSession, input: LineInput, isCancelled: () => boolean): Promise<void>;

package/dist/trust-ui.js

@@ -9,10 +9,11 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, symlinkS
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { askDeclineAll, askView, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, unansweredAskView } from "@vincemakes/kiso-tui";
+import { askDeclineAll, askView, projectTrustRows, projectTrustView, projectUntrustedNote, toolTarget, uncertainView, unansweredAskView } from "@vincemakes/kiso-tui";
 import { projectArtifacts, recordTrust, trustFor } from "@vincemakes/kiso-runtime";
-import { bodyLog, currentAgentExtensions, dock, extensionsDir, kisoHome, mergedTempPaths, neverInherited } from "./state.js";
+import { body, bodyLog, currentAgentExtensions, dock, extensionsDir, kisoHome, mergedTempPaths, neverInherited } from "./state.js";
 import { guardSavedAllow } from "./protected-writes.js";
+import { setTitleState, titleState } from "./window-title.js";
 import { mergeDirPrefix } from "./temp-sweep.js";
 import { loadUserConfig, resolveProjectTrustPolicy } from "./config.js";
 import { getDontAsk } from "./mode.js";
@@ -50,7 +51,15 @@ opts) {
         console.log(`[non-interactive — no human to ask: ${view.fallbackQuestion}]`);
         return Promise.resolve({ action: "deny", reason: "no human to ask" });
     }
-    return new Promise((resolve) => {
+    // Graphite §8.10: while the person is asked, the title says so; the
+    // answer (or the cancel) puts back what it said before
+    const before = titleState();
+    setTitleState("needs-you");
+    return new Promise((settle) => {
+        const resolve = (v) => {
+            setTitleState(before);
+            settle(v);
+        };
         let settled = false;
         pendingAsk = () => {
             if (settled)
@@ -151,7 +160,7 @@ export function askUi(input) {
             // question the model puts is declined, recorded as unanswered,
             // exactly as a non-interactive session declines it.
             if (getDontAsk()) {
-                bodyLog("[dontAsk] the model's question was declined — nothing asks in dontAsk");
+                body.notice("[dontAsk] the model's question was declined — nothing asks in dontAsk");
                 return askDeclineAll(spec);
             }
             const verdict = await askPanel(input, askView(spec));
@@ -331,15 +340,33 @@ export async function resolveProjectTrust(input) {
     // carries the question, the args the artifact listing (the same rows
     // the bodyLog below records, verbatim — the listing still lands in
     // the scrollback; the panel is a bounded block, the record is not).
-    bodyLog(`[project .kiso] ${artifacts.root}`);
-    bodyLog(projectTrustRows(artifacts.files, "  ").join("\n")); // DC-51: one call, one cell
-    const verdict = await askPanel(input, projectTrustView(artifacts.root, artifacts.files));
+    // The tasks round (owner, 2026-10-06): on a dock the question lists the
+    // files itself, so nothing is printed above it; the record lands after
+    // the answer (below). Off a dock the listing is the record, as before.
+    if (!dock.active) {
+        bodyLog(`[project .kiso] ${artifacts.root}`);
+        bodyLog(projectTrustRows(artifacts.files, "  ").join("\n")); // DC-51: one call, one cell
+    }
+    const home = homedir();
+    const shownRoot = artifacts.root === home ? "~" : artifacts.root.startsWith(`${home}/`) ? `~${artifacts.root.slice(home.length)}` : artifacts.root;
+    const verdict = await askPanel(input, projectTrustView(artifacts.root, artifacts.files, shownRoot));
     // A cancel is a "no" HERE — refused is sticky, the project does not
     // load (re-evaluate by deleting the trust line or changing a file).
     // The non-TTY branch above returned WITHOUT a record so an interactive
     // run can still decide later.
     const granted = verdict.action === "allow";
     recordTrust({ root: artifacts.root, digest: artifacts.digest, decision: granted ? "granted" : "refused" });
+    // the record of what was trusted stays in the scrollback: ONE meta row,
+    // once the person has answered — `PROJECT  trusted · ~/w/.kiso · <files>`
+    if (dock.active) {
+        const word = granted ? "trusted" : "not trusted";
+        const files = projectTrustRows(artifacts.files, "").map((r) => r.trim().replace(/\s{2,}/g, " ")).join(", ");
+        // a long root outside home keeps its last two parts — the folder's
+        // own name — so the row still has room for what was trusted
+        const parts = shownRoot.split("/");
+        const where = shownRoot.length > 40 && !shownRoot.startsWith("~") && parts.length > 3 ? `\u2026/${parts.slice(-2).join("/")}` : shownRoot;
+        body.metaNotice(`[project .kiso] ${word} \u2014 ${artifacts.root}`, [{ label: "PROJECT", sentence: `${word} \u00b7 ${where} \u00b7 ${files}`, ...(granted ? { mark: { text: word, tone: "ok" } } : {}) }]);
+    }
     if (!granted)
         return null;
     applyProjectMerges(artifacts);
@@ -471,6 +498,22 @@ function readdirSyncSafe(dir) {
  *  execution stays uncertain and durable — no rerun/abandoned is
  *  fabricated, round 10). The resolution feedback lands in the body —
  *  the body is the single stdout writer, never a stray console.log. */
+/** Graphite P1b — what an uncertain execution's panel quotes: a shell
+ *  command verbatim (every line of it), any other call's target as its
+ *  tool card names it. From the execution record's own input. */
+export function uncertainTarget(name, input) {
+    if (name === "shell")
+        return String(input.command ?? "").split(/\r\n|\n|\r/);
+    return [toolTarget(name, { ...input })];
+}
+/** Graphite P1b — an interrupted ask_user's questions, as the model wrote
+ *  them; empty when the input carries none (the panel then quotes the id). */
+export function askedQuestions(input) {
+    const qs = input.questions;
+    if (!Array.isArray(qs))
+        return [];
+    return qs.flatMap((q) => (typeof q === "object" && q !== null && typeof q.question === "string" ? [q.question] : []));
+}
 export async function resolveUncertains(session, input, isCancelled) {
     // The lead's review of #63, B5: under dontAsk nothing asks, so the
     // uncertain executions are left exactly as a cancel leaves them —
@@ -478,8 +521,10 @@ export async function resolveUncertains(session, input, isCancelled) {
     // line says what to do. An unattended session must not sit on a panel.
     if (getDontAsk()) {
         const n = session.uncertainExecutions().length;
+        // Graphite P1b: a notice, so a dock draws it as the UNCERTAIN meta row
+        // (notice-meta.ts); a pipe prints the same line it always did
         if (n > 0)
-            bodyLog(`[dontAsk] ${n} uncertain execution${n === 1 ? "" : "s"} left unresolved — resolve them in an asking mode`);
+            body.notice(`[dontAsk] ${n} uncertain execution${n === 1 ? "" : "s"} left unresolved — resolve them in an asking mode`);
         return;
     }
     for (const uncertain of session.uncertainExecutions()) {
@@ -487,7 +532,7 @@ export async function resolveUncertains(session, input, isCancelled) {
         // have applied — it is a question nobody answered. The COPY says
         // so; the mechanism is untouched (allow → the runtime's own rerun
         // resolution, whose error-fill text this round never edits).
-        const view = uncertain.name === "ask_user" ? unansweredAskView(uncertain.executionId) : uncertainView(uncertain.name, uncertain.executionId);
+        const view = uncertain.name === "ask_user" ? unansweredAskView(uncertain.executionId, askedQuestions(uncertain.input)) : uncertainView(uncertain.name, uncertain.executionId, uncertainTarget(uncertain.name, uncertain.input));
         const verdict = await askPanel(input, view);
         if (isCancelled() || verdict.action === "cancel") {
             // round 10: a cancellation NEVER records a verdict — the execution