@cruxy/cli 1.11.0 → 1.11.2

package/dist/session/prune.js

@@ -4,6 +4,7 @@ import { INTERRUPTED, idKey, jobLogFilesByRecency, readJobLogTerminal, sessionKe
 import { SESSION_RETENTION_FLOOR, } from "../config/index.js";
 import { sessionFilesByRecency } from "./list.js";
 import { SESSION_FILE_EXT } from "./paths.js";
+import { removeOwnerFile, sessionHeldBy } from "./owner.js";
 /** `<sessionId>.jsonl` → `<sessionId>`. */
 function idOf(file) {
     return path.basename(file, SESSION_FILE_EXT);
@@ -59,6 +60,15 @@ export function pruneSessions(cwd, opts) {
             result.kept++;
             continue;
         }
+        // A session ANOTHER live cruxy has open is spared for the same reason our
+        // own is (P1): its writer would recreate the file on its next append with
+        // no `meta` line, and that session would be unloadable from then on. The
+        // stamp is pid + start-time, so a crashed owner's file is prunable again
+        // the moment it is looked at — nothing outlives the crash.
+        if (sessionHeldBy(ref.file)) {
+            result.kept++;
+            continue;
+        }
         const tooOld = ref.mtimeMs < cutoff;
         const beyondCap = index >= retention;
         if (!tooOld && !beyondCap) {
@@ -67,6 +77,7 @@ export function pruneSessions(cwd, opts) {
         }
         try {
             unlinkSync(ref.file);
+            removeOwnerFile(ref.file); // a stale stamp has nothing left to own
             result.removed.push({ ...ref, sessionId });
             result.bytesFreed += ref.size;
         }

package/dist/session/resume.js

@@ -2,6 +2,7 @@ import { selectList } from "../components/index.js";
 import { usageError } from "../errors/index.js";
 import { listSessionRefs, listSessions, matchSessionRefs, summarizeSession, } from "./list.js";
 import { replaySession } from "./replay.js";
+import { describeHolder, ownerFile, sessionHeldBy } from "./owner.js";
 /** How many sessions the bare-`--resume` picker offers. */
 export const PICKER_LIMIT = 10;
 /** Short, stable id form — enough to identify a session, short enough to type. */
@@ -75,6 +76,18 @@ export function priorDirectoriesWarning(state, cwd) {
  * worth failing loudly on, unlike an individual torn line.
  */
 export function loadResume(session, cwd) {
+    // OWNERSHIP (P1). Asked BEFORE the replay, and answered by the OS rather
+    // than by a file's presence: a stamp whose process is gone is not a holder.
+    // Two processes appending to one log produce a transcript that replays
+    // cleanly and means nothing, so this is a refusal, not a warning.
+    const holder = sessionHeldBy(session.file);
+    if (holder) {
+        throw usageError(`session ${shortId(session.sessionId)} is open in another cruxy (${describeHolder(holder)})`, [
+            "continue it there, or quit that cruxy and resume here",
+            "start a new session with `cruxy`",
+            `if that process is not a cruxy, remove ${ownerFile(session.file)}`,
+        ]);
+    }
     let state;
     try {
         state = replaySession(session.file);
@@ -189,9 +202,15 @@ export async function resumePicker(cwd, opts = {}) {
     ];
     const picked = await selectList(rows, {
         title: "resume a session",
-        toLabel: (row) => row.kind === "new"
-            ? "+ new session"
-            : describeSession(row.session, now),
+        toLabel: (row) => {
+            if (row.kind === "new")
+                return "+ new session";
+            const label = describeSession(row.session, now);
+            // A row another live cruxy holds is offered — the user may want to
+            // see it — but says so, so picking it is not a surprise refusal.
+            const holder = sessionHeldBy(row.session.file);
+            return holder ? `${label} · open in another cruxy` : label;
+        },
         // Non-interactive with no id named: starting fresh is the safe default,
         // never an arbitrary session picked on the user's behalf.
         defaultValue: { kind: "new" },

package/dist/subagent/orchestrator.js

@@ -7,7 +7,7 @@ import { UNRESOLVED_TIER, } from "../budget/index.js";
 import { resolveTaskModel } from "../routing/index.js";
 import { Workspace } from "../workspace/index.js";
 import { Budget, resolveBudget } from "../agent/budget.js";
-import { scopeRegistry, SUBAGENT_WRITE_TOOLS } from "./registry-scope.js";
+import { isWriteTool, scopeRegistry } from "./registry-scope.js";
 import { Semaphore } from "./semaphore.js";
 import { makeSpawnSubagentTool } from "./spawn-tool.js";
 /** Longest task excerpt shown in render chrome — display, not record. */
@@ -556,7 +556,7 @@ function taskLabel(task) {
 /** A child that holds any mutating tool — the disjoint-scope check's unit. A
  * spec with no `tools` gets the default READ-ONLY set, so it is never a writer. */
 function isWriter(spec) {
-    return (spec.tools ?? []).some((t) => SUBAGENT_WRITE_TOOLS.has(t));
+    return (spec.tools ?? []).some(isWriteTool);
 }
 /**
  * The tokens a child is KNOWN to have spent, or `undefined` when no request

package/dist/subagent/registry-scope.js

@@ -17,8 +17,20 @@ export const SPAWN_SUBAGENTS_TOOL_NAME = "spawn_subagents";
 /**
  * Mutating tools (C.33): a child holding ANY of these is a "writer" for the
  * disjoint-scope check. Two writers in one parallel batch must target distinct
- * roots, or the batch is refused pre-dispatch. Kept in sync with the gated,
- * side-effecting tool set (file writes, shell/test, VCS).
+ * roots, or the batch is refused pre-dispatch.
+ *
+ * This is the set of REGISTERED tool names that gate on `ctx.requestApproval`
+ * and act on a workspace root: file writes, shell/test, the PR tool, and the
+ * background-job dispatcher (a job is a whole agent run that may be granted
+ * any of the others). `registry-scope.test.ts` pins every name here to a tool
+ * that actually exists — until P1 this set named three tools that never did
+ * (`git_commit`, `git_branch`, `open_pr`) and omitted `create_pull_request`,
+ * so a child holding the PR tool was never counted as a writer and two of them
+ * could be dispatched against one root.
+ *
+ * Deliberately NOT here: `remember` (writes the memory store, not a root —
+ * root-disjointness says nothing about it) and the spawn tools (stripped from
+ * every child scope). MCP tools are covered by prefix in {@link isWriteTool}.
  */
 export const SUBAGENT_WRITE_TOOLS = new Set([
     "write_file",
@@ -26,10 +38,21 @@ export const SUBAGENT_WRITE_TOOLS = new Set([
     "apply_patch",
     "run_command",
     "run_tests",
-    "git_commit",
-    "git_branch",
-    "open_pr",
+    "create_pull_request",
+    "run_in_background",
 ]);
+/** The wire-name prefix every MCP-proxied tool carries (see `mcp/adapter.ts`). */
+const MCP_TOOL_PREFIX = "mcp__";
+/**
+ * Whether granting `name` to a child makes it a writer. The named set above,
+ * plus every MCP tool: the adapter gates each call on approval precisely
+ * because a server's tool can mutate anything, and the classifier never lets
+ * the server declare itself read-only — so the disjointness check must not
+ * either.
+ */
+export function isWriteTool(name) {
+    return SUBAGENT_WRITE_TOOLS.has(name) || name.startsWith(MCP_TOOL_PREFIX);
+}
 /**
  * The default child toolset: read-only investigation plus skills. Mirrors the
  * C.31 propose-phase set — no writes, no shell, no VCS unless the parent

package/dist/tools/file/apply-patch.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { z } from "zod";
 import { resolveToolPath, toPosix } from "./paths.js";
 import { applyEol, detectEol, findMatch, tierLabel } from "./match.js";
+import { changedSince, snapshotFile, snapshotOf, } from "./snapshot.js";
 /** How many leading lines of a created file the approval preview shows. */
 const PREVIEW_LINES = 20;
 /**
@@ -162,6 +163,20 @@ export const applyPatchTool = {
         if (!decision.allow) {
             return { ok: false, error: decision.feedback ?? "patch denied" };
         }
+        // The approval covered THESE files in THE states they were read in. Any
+        // path that moved during the wait — rewritten, deleted, or created by
+        // something else — voids the whole patch: nothing is applied, so the model
+        // re-reads and resubmits rather than landing a half-stale patch (P1).
+        // Every drifted path is named, not just the first: a retry that knows one
+        // of two moved re-reads one file and trips over the other.
+        const drifted = [];
+        for (const p of planned) {
+            const moved = await changedSince(p.abs, p.approved, p.rel);
+            if (moved)
+                drifted.push(moved);
+        }
+        if (drifted.length > 0)
+            return { ok: false, error: drifted.join("\n") };
         // Validation passed and the user approved; apply everything. A mid-apply I/O
         // failure is rare but reported with what already landed.
         const applied = [];
@@ -195,28 +210,44 @@ async function openTrack(i, op, abs, ctx) {
     // messages), consistent with every other path tool — see {@link toPosix}.
     const rel = toPosix(path.relative(ctx.cwd, abs));
     const base = { abs, rel, firstOp: i, hunks: [] };
-    if (op.type === "create") {
-        if (await exists(abs)) {
-            return { ok: false, error: opError(i, op, "file already exists") };
+    if (op.type === "create" || op.type === "delete") {
+        let approved;
+        try {
+            approved = await snapshotFile(abs);
         }
-        const content = op.content ?? "";
-        return {
-            ok: true,
-            track: { ...base, kind: "create", content, eol: detectEol(content) },
-        };
-    }
-    if (op.type === "delete") {
-        if (!(await exists(abs))) {
+        catch (err) {
+            return { ok: false, error: opError(i, op, err.message) };
+        }
+        if (op.type === "create") {
+            if (approved.kind === "present") {
+                return { ok: false, error: opError(i, op, "file already exists") };
+            }
+            const content = op.content ?? "";
+            return {
+                ok: true,
+                track: {
+                    ...base,
+                    kind: "create",
+                    content,
+                    eol: detectEol(content),
+                    approved,
+                },
+            };
+        }
+        if (approved.kind === "absent") {
             return { ok: false, error: opError(i, op, "file not found") };
         }
         return {
             ok: true,
-            track: { ...base, kind: "delete", content: "", eol: "\n" },
+            track: { ...base, kind: "delete", content: "", eol: "\n", approved },
         };
     }
     let content;
+    let approved;
     try {
-        content = await fs.readFile(abs, "utf8");
+        const bytes = await fs.readFile(abs);
+        approved = snapshotOf(bytes);
+        content = bytes.toString("utf8");
     }
     catch (err) {
         if (err.code === "ENOENT") {
@@ -229,6 +260,7 @@ async function openTrack(i, op, abs, ctx) {
         kind: "update",
         content,
         eol: detectEol(content),
+        approved,
     };
     const failure = applyHunk(i, op, track);
     return failure ? { ok: false, error: failure } : { ok: true, track };
@@ -261,12 +293,12 @@ function applyHunk(i, op, track) {
 }
 /** Collapse a finished track into the single write it represents. */
 function toPlanned(track) {
-    const { kind, abs, rel, content, hunks } = track;
+    const { kind, abs, rel, content, hunks, approved } = track;
     if (kind === "delete")
-        return { op: "delete", abs, rel };
+        return { op: "delete", abs, rel, approved };
     if (kind === "create")
-        return { op: "create", abs, rel, content };
-    return { op: "update", abs, rel, content, hunks };
+        return { op: "create", abs, rel, content, approved };
+    return { op: "update", abs, rel, content, hunks, approved };
 }
 /** Shape a planned op into its approval-preview form. */
 function toPreview(p) {
@@ -287,9 +319,3 @@ function toPreview(p) {
 function opError(i, op, reason) {
     return `operation ${i + 1} (${op.type} ${op.path}): ${reason}`;
 }
-async function exists(abs) {
-    return fs
-        .access(abs)
-        .then(() => true)
-        .catch(() => false);
-}

package/dist/tools/file/edit-file.js

@@ -2,10 +2,15 @@ import { promises as fs } from "node:fs";
 import { z } from "zod";
 import { resolveToolPath } from "./paths.js";
 import { applyEol, detectEol, findMatch, tierLabel } from "./match.js";
+import { changedSince, snapshotOf } from "./snapshot.js";
 /**
  * Replace one exact, unique occurrence of `old_str` with `new_str` in a file.
  * The uniqueness requirement is checked before approval so the model can fix an
  * ambiguous match without burning a prompt; gated on `ctx.approve` before writing.
+ *
+ * The bytes read before approval are the state the approval is granted
+ * against; the write is refused if the file is no longer in that state when
+ * the write is about to happen (P1 — see `snapshot.ts`).
  */
 export const editFileTool = {
     name: "edit_file",
@@ -29,8 +34,11 @@ export const editFileTool = {
             return { ok: false, error: err.message };
         }
         let content;
+        let approvedState;
         try {
-            content = await fs.readFile(abs, "utf8");
+            const bytes = await fs.readFile(abs);
+            approvedState = snapshotOf(bytes);
+            content = bytes.toString("utf8");
         }
         catch (err) {
             if (err.code === "ENOENT") {
@@ -64,6 +72,12 @@ export const editFileTool = {
         const updated = content.slice(0, match.start) +
             applyEol(input.new_str, detectEol(content)) +
             content.slice(match.end);
+        // The approval covered a diff against the bytes read above. Anything that
+        // changed the file during the wait makes `updated` a splice of stale
+        // content — refuse rather than overwrite what is there now (P1).
+        const moved = await changedSince(abs, approvedState, input.path);
+        if (moved)
+            return { ok: false, error: moved };
         try {
             await fs.writeFile(abs, updated, "utf8");
             return { ok: true, output: `edited ${input.path}` };

package/dist/tools/file/snapshot.js

@@ -0,0 +1,63 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { ErrorCode } from "../../errors/index.js";
+/** Snapshot the bytes a tool has ALREADY read (no second read). */
+export function snapshotOf(bytes) {
+    return {
+        kind: "present",
+        digest: createHash("sha256").update(bytes).digest("hex"),
+    };
+}
+/**
+ * Read `abs` and snapshot it. A missing path is a legitimate state (`absent`)
+ * — it is what `write_file` and a patch `create` are approved against. Every
+ * other failure (a directory at the path, EACCES) propagates: the caller
+ * cannot build a truthful preview of a file it cannot read.
+ */
+export async function snapshotFile(abs) {
+    try {
+        return snapshotOf(await fs.readFile(abs));
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { kind: "absent" };
+        }
+        throw err;
+    }
+}
+/**
+ * Re-read `abs` and compare it with the state the approval was granted
+ * against. Returns `null` when the file is exactly as it was, otherwise the
+ * refusal to hand back as the tool's error — one sentence on what moved, and
+ * the same next step every time: read it again and retry.
+ *
+ * Call this AFTER approval and IMMEDIATELY before the write, with nothing
+ * awaited in between — the point is to make the gap as small as the platform
+ * allows, not to check early and then wait.
+ */
+export async function changedSince(abs, approved, rel) {
+    let now;
+    try {
+        now = await snapshotFile(abs);
+    }
+    catch (err) {
+        return refusal(rel, `could not be re-read before the approved write (${err.message})`);
+    }
+    if (approved.kind === "absent") {
+        return now.kind === "absent"
+            ? null
+            : refusal(rel, "was created by something else after it was approved as a new file");
+    }
+    if (now.kind === "absent") {
+        return refusal(rel, "was deleted after it was read");
+    }
+    if (now.digest !== approved.digest) {
+        return refusal(rel, "changed on disk after it was read");
+    }
+    return null;
+}
+/** The one refusal shape: what moved, that nothing was written, what to do. */
+function refusal(rel, what) {
+    return (`${ErrorCode.FileChangedSinceRead}: ${rel} ${what}, so the approval no longer ` +
+        `covers this write; nothing was written — read the file again and retry`);
+}

package/dist/tools/file/write-file.js

@@ -2,11 +2,18 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { z } from "zod";
 import { resolveToolPath } from "./paths.js";
+import { changedSince, snapshotFile } from "./snapshot.js";
 /** How many leading lines of new content the approval preview shows. */
 const PREVIEW_LINES = 20;
 /**
  * Create or overwrite a file within the project root. Gated on `ctx.approve`
  * before anything is written.
+ *
+ * The target is snapshotted before approval — its current bytes, or its
+ * absence — and the write is refused if that state has moved by the time the
+ * write is about to happen (P1 — see `snapshot.ts`). This tool used to have
+ * no read at all: an "overwrite" approved against one version of a file would
+ * land on whatever version was there by the time the user pressed `y`.
  */
 export const writeFileTool = {
     name: "write_file",
@@ -25,11 +32,19 @@ export const writeFileTool = {
         catch (err) {
             return { ok: false, error: err.message };
         }
-        // Does the target already exist? Drives create-vs-overwrite in the preview.
-        const exists = await fs
-            .access(abs)
-            .then(() => true)
-            .catch(() => false);
+        // Does the target already exist? Drives create-vs-overwrite in the preview,
+        // and its bytes (or absence) are the state the approval is granted against.
+        let approvedState;
+        try {
+            approvedState = await snapshotFile(abs);
+        }
+        catch (err) {
+            return {
+                ok: false,
+                error: `cannot read ${input.path}: ${err.message}`,
+            };
+        }
+        const exists = approvedState.kind === "present";
         // First N lines of the new content, with a count of what's omitted.
         const allLines = input.content.split("\n");
         const lines = allLines.slice(0, PREVIEW_LINES);
@@ -46,6 +61,12 @@ export const writeFileTool = {
                 error: decision.feedback ?? `write to ${input.path} denied`,
             };
         }
+        // A create approved against "no file here" must not overwrite a file that
+        // appeared during the wait; an overwrite approved against one version must
+        // not land on another (P1).
+        const moved = await changedSince(abs, approvedState, input.path);
+        if (moved)
+            return { ok: false, error: moved };
         try {
             await fs.mkdir(path.dirname(abs), { recursive: true });
             await fs.writeFile(abs, input.content, "utf8");

package/dist/tui/app.js

@@ -3,13 +3,14 @@ import { completeLine } from "../components/autocomplete.js";
 import { SHARED_COMMANDS, SHARED_HELP, announceMode, dispatchCommand, } from "../cli/session-commands.js";
 import { TUI_ONLY_COMMANDS } from "../cli/command-catalog.js";
 import { selectList } from "../components/select.js";
-import { viewLabel, viewOrder } from "./views.js";
+import { CONVERSATION_VIEW, viewLabel, viewOrder } from "./views.js";
 import { canOverlay, createKeyLease, createOverlayIO, } from "./overlay.js";
 import { ModeRing } from "./mode-ring.js";
 import { openPalette } from "./palette.js";
 import { formatError, fromUnknown, isVerbose, shouldUseColor, } from "../errors/index.js";
 import { CLOSABLE_PANELS, columnOf, RAIL_PANELS, } from "./layout.js";
 import { COLUMN_LABELS, PANEL_LABELS } from "./panels.js";
+import { WHEEL_LINES } from "./renderer.js";
 /**
  * The TUI's input loop (P1) — the piece that replaces `repl.ts`'s readline
  * loop. It owns exactly two things: the edit buffer and command dispatch.
@@ -59,7 +60,10 @@ const HELP = [
     "  Ctrl+K           open the command palette",
     "  Ctrl+B           focus the sidebar nav (arrows switch view, Esc leaves)",
     "  Shift+Tab        cycle mode (manual · auto-approve · plan · full-auto)",
-    "  PgUp / PgDn      scroll the pane; Esc returns to the live view",
+    "  PgUp / PgDn      scroll the pane (the mouse wheel does too; to select",
+    "                   text hold Shift — Option in Terminal.app — or set",
+    "                   CRUXY_NO_MOUSE=1 to give the wheel back to the terminal)",
+    "  Esc              back to the live view, then back to the conversation",
     "  Ctrl+D           leave cruxy",
 ];
 /**
@@ -177,6 +181,10 @@ async function readLine(keys, renderer, hooks) {
                     // answering into a pane they cannot see is the one case where holding
                     // still is wrong.
                     renderer.scrollToLive();
+                    // And clears the last command's output from under a view (cli#7b):
+                    // what this line produces must not stack beneath what the last one
+                    // did. It is all still in the conversation.
+                    renderer.dismissNotices();
                     paint();
                     return text;
                 }
@@ -282,12 +290,23 @@ async function readLine(keys, renderer, hooks) {
                     // schedules its own repaint for the rows that did.
                     renderer.scrollPage(key.kind === "page-up" ? 1 : -1);
                     break;
+                case "wheel-up":
+                case "wheel-down":
+                    // The mouse wheel (cli#1) is the same scroll at a finer grain. It
+                    // only arrives because the renderer turned mouse reporting on; the
+                    // terminal would otherwise have scrolled its own window (Terminal.app)
+                    // or sent arrows this loop ignores (iTerm2).
+                    renderer.scrollBy(key.kind === "wheel-up" ? WHEEL_LINES : -WHEEL_LINES);
+                    break;
                 case "escape":
-                    // Esc leaves the scrolled view — a mode needs a visible exit, and the
-                    // notice names this key. It stays inert at the live tail rather than
-                    // being claimed unconditionally, so the binding remains free for
-                    // whatever a later track wants Esc to mean when nothing is scrolled.
-                    renderer.scrollToLive();
+                    // Esc peels one layer (cli#7b): out of scrollback first — a mode
+                    // needs a visible exit, and the notice names this key — and, at the
+                    // live tail, out of a view and back to the conversation. Two presses
+                    // from anywhere reach the home position; each one is a step the
+                    // screen can show. Inert at the conversation's live tail, so the
+                    // binding stays free for whatever a later track wants it to mean.
+                    if (!renderer.scrollToLive())
+                        renderer.setView(CONVERSATION_VIEW);
                     break;
                 case "ctrl-b":
                     // Take the keyboard to the sidebar nav (P7 track 2). Refused when the
@@ -485,6 +504,10 @@ export async function runTui(session, renderer, opts = {}) {
         print: (line = "") => renderer.println(line),
         theme: renderer.theme,
         fit: (line) => line,
+        // `/clear` (cli#2): the TUI owns its scrollback, so a cleared history is
+        // also a cleared screen. The REPL has no equivalent — its transcript is the
+        // terminal's own scrollback, which is not the CLI's to erase.
+        clear: () => renderer.clearScrollback(),
     };
     // The mode ring (Q5). The chip follows every press; the session is told once,
     // when the presses stop — see `mode-ring.ts` for why passing through a mode is

package/dist/tui/approval-overlay.js

@@ -1,3 +1,4 @@
+import { readAnswerKey } from "../components/input.js";
 import { themeForColor } from "../theme/index.js";
 /**
  * The approval prompt as an in-viewport modal (P5 track 2).
@@ -88,7 +89,9 @@ export function createOverlayPromptIO(surface, lease, color) {
             paint();
         },
         async readKey() {
-            const key = await read(keys);
+            // A wheel notch scrolls the conversation behind the drawer; it is not an
+            // answer, and mapping it to "" would deny the action being asked about.
+            const key = keys === null ? await read(keys) : await readAnswerKey(keys);
             return keyToChar(key);
         },
         /**

package/dist/tui/layout.js

@@ -124,6 +124,28 @@ export function fitBlock(lines, rows, width) {
         out.push(" ".repeat(Math.max(0, width)));
     return out;
 }
+/**
+ * Take the FIRST `rows` lines of a block and pad it to exactly that many rows —
+ * the mirror of {@link fitBlock}, for a column whose top is the part that must
+ * survive.
+ *
+ * The sidebar is that column (cli#7a). It opens with the view nav: a heading
+ * and one row per view, fixed-height, and NAVIGABLE — Ctrl+B puts the keyboard
+ * on it, and the arrows move a pointer down its rows. `fitBlock`'s tail rule
+ * applied to that column ate the heading and the first four view rows at 30
+ * rows, which left Ctrl+B moving a pointer the screen never showed. Nothing
+ * at the bottom of the sidebar is worth that: the session list below the nav
+ * is composed to its own budget by the renderer (see `sidebarLines`), so what
+ * reaches here already fits, and when it does not — a terminal too short for
+ * the nav itself — the rows to lose are the last ones, not the first.
+ */
+export function fitHead(lines, rows, width) {
+    const head = lines.length > rows ? lines.slice(0, Math.max(0, rows)) : lines;
+    const out = head.map((l) => padTo(l, width));
+    while (out.length < rows)
+        out.push(" ".repeat(Math.max(0, width)));
+    return out;
+}
 /**
  * Window `rows` lines out of a block, `offset` display lines up from the end
  * (P7 track 1). `offset === 0` is the tail view {@link fitBlock} gives, and the
@@ -293,8 +315,10 @@ export function composeScreen(vm, width, height, open, theme) {
     const drawer = fitOverlay(vm.overlay ?? [], overlayRows(height));
     const columnRows = Math.max(1, rows - drawer.length);
     const columns = [];
+    // HEAD-fitted, not tail: the sidebar is a nav over a list, and the nav is the
+    // part that has to be on screen — see `fitHead`. `main` stays a tail view.
     if (budget.sidebar > 0)
-        columns.push(fitBlock(vm.sidebar, columnRows, budget.sidebar));
+        columns.push(fitHead(vm.sidebar, columnRows, budget.sidebar));
     columns.push(fitBlock(vm.main, columnRows, budget.main));
     if (budget.rail > 0)
         columns.push(fitBlock(vm.rail, columnRows, budget.rail));

package/dist/tui/panels.js

@@ -50,22 +50,44 @@ function title(text, theme) {
  * The column is narrow (18 columns), so each session takes two lines: its short
  * id and age, then its title. The layout truncates per line, which keeps the id
  * — the part you would type into `--resume` — always fully visible.
+ *
+ * `rows` is the HEIGHT budget (cli#7a), and the list is fitted to it here the
+ * way `stackPanels` fits the rail: whole sessions, newest first, and a count of
+ * what did not fit rather than a session cut in half or silently absent. The
+ * list sits under the view nav, which is fixed-height and keyboard-driven, so
+ * it is the list that yields — and because it is newest-first, the rows to
+ * yield are at the END. The old tail-fit lost the nav heading and the newest
+ * sessions at once, which is the wrong end of both blocks.
  */
-export function sidebarLines(theme, sessions = [], activeSessionId, now = Date.now()) {
+export function sidebarLines(theme, sessions = [], activeSessionId, now = Date.now(), rows = Infinity) {
+    if (rows <= 0)
+        return [];
     const lines = title("sessions", theme);
     if (sessions.length === 0) {
         lines.push(theme.muted("no saved sessions"));
         lines.push(theme.muted("for this project yet."));
-        return lines;
+        return lines.slice(0, rows);
     }
-    for (const s of sessions) {
+    // Rows left for sessions after the title. Each session costs two, and when
+    // not all fit, one row is charged for the notice BEFORE deciding how many do
+    // — reserving it afterwards could evict a session just counted as shown.
+    const room = Math.max(0, rows - lines.length);
+    const fitsWhole = sessions.length * 2 <= room;
+    const shown = fitsWhole
+        ? sessions.length
+        : Math.max(0, Math.floor((room - 1) / 2));
+    for (const s of sessions.slice(0, shown)) {
         const active = s.sessionId === activeSessionId;
         const mark = active ? theme.accent(theme.glyph.pointer) : " ";
         const head = `${mark} ${shortId(s.sessionId)} ${relativeAge(s.updatedAt, now)}`;
         lines.push(active ? theme.strong(head) : head);
         lines.push(theme.muted(`  ${s.title}`));
     }
-    return lines;
+    if (!fitsWhole && room > 0) {
+        const hidden = sessions.length - shown;
+        lines.push(theme.muted(`${theme.glyph.ellipsis}${hidden} more session${hidden === 1 ? "" : "s"}`));
+    }
+    return lines.slice(0, rows);
 }
 /** A panel with no state yet: says so, rather than inventing a plausible value. */
 function pending(theme) {
@@ -236,19 +258,35 @@ function shortTokens(n) {
  *
  * The compaction threshold is shown because it is the only actionable thing
  * here: it says when the CLI will start folding history away.
+ *
+ * THE ALLOWANCE IS NAMED (cli#4). `used` includes `context.reserveTokens` — a
+ * fixed 4,500 by default — because the compaction seam adds it, and the panel
+ * must measure what the seam measures. But shown as a bare figure it read as
+ * consumption: an empty session opened at "~5k / 100k", as if something had
+ * already been spent. Nothing had. The constant is a fair size for what it
+ * stands in for (the system prompt plus the default tool catalogue measure
+ * about 3.7k), and it is an ALLOWANCE, not a reading: it does not move when
+ * CRUXY.md, memory recall, LSP, web or MCP schemas make the real request
+ * larger. The second row says so, in the room a 24-column strip has.
  */
 export function contextPanelLines(theme, reading) {
     if (reading === undefined) {
         return [theme.muted(`measuring${theme.glyph.ellipsis}`)];
     }
-    const { used, total, compactAt } = reading;
+    const { used, total, compactAt, reserve } = reading;
     const figure = `~${shortTokens(used)} / ${shortTokens(total)} budget`;
     // Past the threshold the next turn compacts, which is worth flagging — but as
     // a statement of what happens next, not as an alarm about a guessed number.
     // Compared on `used`, not the clamped fraction: the clamp is for display, and
     // a history that has overrun the budget must not compare as merely "at" it.
     const style = used >= compactAt ? theme.warning : theme.strong;
-    return [style(figure), theme.muted(`compacts at ${shortTokens(compactAt)}`)];
+    return [
+        style(figure),
+        ...(reserve === undefined || reserve <= 0
+            ? []
+            : [theme.muted(`incl. ~${shortTokens(reserve)} allowance`)]),
+        theme.muted(`compacts at ${shortTokens(compactAt)}`),
+    ];
 }
 /** The opening lines of the main column, before any turn has run. */
 export function mainWelcome(theme, hint) {