gentle-pi 4.0.0 → 4.2.0

package/lib/shell-changes.ts

@@ -27,7 +27,6 @@ export interface ChangesModel {
 	files: ChangedFile[];
 	added: number;
 	deleted: number;
-	notice?: string;
 }
 
 export interface ChangesSnapshot {
@@ -46,6 +45,11 @@ interface NumstatEntry {
 }
 
 export const CHANGES_COMMAND = "/gentle:changes";
+// One selected file's diff is the only bounded thing in Changes: past either
+// limit the panel shows DIFF_TOO_LARGE instead of buffering and coloring it.
+export const DIFF_MAX_BYTES = 1024 * 1024;
+export const DIFF_MAX_LINES = 20_000;
+export const DIFF_TOO_LARGE = "Diff too large — press o to open in editor.";
 const WIDGET_GLYPH = "✎";
 const STATUS_BY_CODE: Record<string, ChangeStatus> = {
 	A: CHANGE_STATUS.ADDED,
@@ -106,6 +110,8 @@ export function snapshotChanges(snapshot: ChangesSnapshot): ChangedFile[] {
 	const counts = new Map(parseNumstat(snapshot.numstat).map((entry) => [entry.path, entry]));
 	const files: ChangedFile[] = [];
 	for (const [path, status] of parsePorcelain(snapshot.porcelain)) {
+		// Dependency backups are local artifacts; tracked files remain visible.
+		if (status === CHANGE_STATUS.UNTRACKED && /(?:^|\/)node_modules\.backup-[^/]+\//.test(path)) continue;
 		const entry = counts.get(path);
 		files.push({ path, added: entry?.added ?? 0, deleted: entry?.deleted ?? 0, status });
 	}
@@ -123,7 +129,7 @@ export function changesModel(changed: ChangedFile[]): ChangesModel {
 
 export function changesSummary(model: ChangesModel): string {
 	const noun = model.files.length === 1 ? "file" : "files";
-	return `${model.files.length} ${noun} · +${model.added} −${model.deleted}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}${model.notice ? " · capture limit reached" : ""}`;
+	return `${model.files.length} ${noun} · +${model.added} −${model.deleted}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}`;
 }
 
 // One line: summary, the files joined by dots, and the command pushed to
@@ -132,7 +138,7 @@ export function renderChangesWidget(model: ChangesModel, theme: ChangesTheme, wi
 	if (model.files.length === 0) return [];
 	const noun = model.files.length === 1 ? "file" : "files";
 	const dot = theme.fg("muted", "·");
-	const head = `${theme.fg("accent", WIDGET_GLYPH)} ${theme.fg("text", `${model.files.length} ${noun}`)} ${dot} ${theme.fg("success", `+${model.added}`)} ${theme.fg("error", `−${model.deleted}`)}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}${model.notice ? ` ${dot} ${theme.fg("warning", "capture limit reached")}` : ""}`;
+	const head = `${theme.fg("accent", WIDGET_GLYPH)} ${theme.fg("text", `${model.files.length} ${noun}`)} ${dot} ${theme.fg("success", `+${model.added}`)} ${theme.fg("error", `−${model.deleted}`)}${model.files.some(file => file.countsUnavailable) ? " · partial counts" : ""}`;
 	const hint = theme.fg("dim", CHANGES_COMMAND);
 	const list = model.files.map((file) => theme.fg("muted", file.path)).join(` ${dot} `);
 	const left = `${head} ${dot} ${list}`;
@@ -146,10 +152,14 @@ export function renderChangesWidget(model: ChangesModel, theme: ChangesTheme, wi
 export interface GitResult {
 	stdout: string;
 	code: number;
+	/** The runner stopped reading at its output bound; stdout is partial. */
+	truncated?: boolean;
 }
 
 export type GitRunner = (args: string[]) => Promise<GitResult>;
 export type LineCounter = (path: string) => Promise<number>;
+/** A cheap content identity (e.g. size and mtime) so same-count edits refresh their diff. */
+export type FileRevision = (path: string) => Promise<string | undefined>;
 
 export interface WorktreeChanges {
 	root: string;
@@ -189,76 +199,41 @@ export async function foreignRootBranch(git: GitRunner): Promise<string | undefi
 	return verified.code === 0 ? branch : "no commits yet";
 }
 
-// The session-evidence tracker behind /gentle:changes records roots, never
-// branches, so the overlay would label every tree "detached". This resolves
-// each root's own HEAD state once (branch, "no commits yet", undefined for a
-// real detached HEAD, or UNKNOWN_BRANCH when the root could not even be
-// asked), decorates the trees from the cache, and tells the caller when a
-// fresh answer arrived so the view can repaint. Git is touched only while the
-// overlay is open, never at startup or on evidence refresh.
-export class RootBranchLabels {
-	private readonly labels = new Map<string, string | undefined>();
-	private readonly pending = new Map<string, Promise<void>>();
-	private readonly gitForRoot: (root: string) => GitRunner;
-	private readonly onChange: () => void;
-	constructor(gitForRoot: (root: string) => GitRunner, onChange: () => void = () => {}) {
-		this.gitForRoot = gitForRoot;
-		this.onChange = onChange;
-	}
-
-	decorate(trees: readonly WorktreeChanges[]): WorktreeChanges[] {
-		return trees.map((tree) => {
-			if (tree.branch !== undefined) return tree;
-			if (!this.labels.has(tree.root)) this.resolve(tree.root);
-			const branch = this.labels.get(tree.root);
-			return branch === undefined ? tree : { ...tree, branch };
-		});
-	}
-
-	/** Every in-flight resolution has finished. */
-	async settled(): Promise<void> {
-		while (this.pending.size) await Promise.all(this.pending.values());
-	}
-
-	private resolve(root: string): void {
-		if (this.pending.has(root)) return;
-		// A rejection here means the root could not even be asked -- distinct
-		// from foreignRootBranch resolving to undefined, which means git
-		// answered and there really is no branch (a real detached HEAD).
-		const task = foreignRootBranch(this.gitForRoot(root))
-			.then(
-				(branch) => branch,
-				() => UNKNOWN_BRANCH,
-			)
-			.then((branch) => {
-				this.labels.set(root, branch);
-				this.pending.delete(root);
-				this.onChange();
-			});
-		this.pending.set(root, task);
-	}
-}
-
+// /gentle:changes: one group per registered root holding its working tree
+// against HEAD. A root whose Git fails (timed out, rejected) has no group but
+// is listed in failedRoots: a failed scan is never reported as a clean root.
 export class WorktreeChangesTracker {
 	worktrees: WorktreeChanges[] = [];
+	failedRoots: string[] = [];
+	scannedRootCount = 0;
 	private inFlight: Promise<ChangesModel> | undefined;
 	private readonly discover: GitRunner;
 	private readonly gitForRoot: (root: string) => GitRunner;
 	private readonly linesForRoot: (root: string) => LineCounter;
 	private readonly registeredRoots: () => readonly string[];
+	private readonly revisionForRoot: (root: string) => FileRevision | undefined;
 
-	constructor(discover: GitRunner, gitForRoot: (root: string) => GitRunner, linesForRoot: (root: string) => LineCounter = () => noLines, registeredRoots: () => readonly string[] = () => []) {
+	constructor(discover: GitRunner, gitForRoot: (root: string) => GitRunner, linesForRoot: (root: string) => LineCounter = () => noLines, registeredRoots: () => readonly string[] = () => [], revisionForRoot: (root: string) => FileRevision | undefined = () => undefined) {
 		this.discover = discover;
 		this.gitForRoot = gitForRoot;
 		this.linesForRoot = linesForRoot;
 		this.registeredRoots = registeredRoots;
+		this.revisionForRoot = revisionForRoot;
 	}
 
+	private modelOf: WorktreeChanges[] | undefined;
+	private combined: ChangesModel = emptyChanges();
+
+	// Footers read this every frame; rebuild only when a scan replaced the trees.
 	get model(): ChangesModel {
-		return changesModel(this.worktrees.flatMap((tree) => tree.model.files.map((file) => ({
-			...file,
-			path: this.worktrees.length === 1 ? file.path : `${tree.root}/${file.path}`,
-		}))));
+		if (this.modelOf !== this.worktrees) {
+			this.modelOf = this.worktrees;
+			this.combined = changesModel(this.worktrees.flatMap((tree) => tree.model.files.map((file) => ({
+				...file,
+				path: this.worktrees.length === 1 ? file.path : `${tree.root}/${file.path}`,
+			}))));
+		}
+		return this.combined;
 	}
 
 	async start(): Promise<void> {
@@ -278,17 +253,29 @@ export class WorktreeChangesTracker {
 	}
 
 	private async capture(): Promise<ChangesModel> {
-		const result = await this.discover(["worktree", "list", "--porcelain", "-z"]).catch(() => ({ code: 128, stdout: "" }));
-		const trees: WorktreeChanges[] = [];
-		const metadata = new Map((result.code === 0 ? parseWorktrees(result.stdout) : []).map((tree) => [tree.root, tree]));
 		// Discovery labels registered roots; it never grants visibility to siblings.
 		const roots = new Set(this.registeredRoots());
-		for (const root of roots) {
+		// No root to scan means no Git at all, not even branch discovery.
+		if (roots.size === 0) {
+			this.worktrees = [];
+			this.failedRoots = [];
+			this.scannedRootCount = 0;
+			return this.model;
+		}
+		const result = await this.discover(["worktree", "list", "--porcelain", "-z"]).catch(() => ({ code: 128, stdout: "" }));
+		const metadata = new Map((result.code === 0 ? parseWorktrees(result.stdout) : []).map((tree) => [tree.root, tree]));
+		// Roots scan in parallel so one slow root does not delay the others.
+		const failed: string[] = [];
+		const scanned = await Promise.all([...roots].map(async (root): Promise<WorktreeChanges | undefined> => {
 			const known = metadata.get(root);
 			try {
-				const tracker = new ChangesTracker(this.gitForRoot(root), this.linesForRoot(root));
+				const tracker = new ChangesTracker(this.gitForRoot(root), this.linesForRoot(root), this.revisionForRoot(root));
 				await tracker.start();
-				if (!tracker.model.files.length) continue;
+				if (!tracker.statusRead) {
+					failed.push(root);
+					return undefined;
+				}
+				if (!tracker.model.files.length) return undefined;
 				// A root missing from this discovery scan belongs to a different Git
 				// clone entirely (e.g. an inner repository nested inside an outer
 				// one) -- worktree list can never describe a foreign clone, so ask
@@ -299,22 +286,40 @@ export class WorktreeChangesTracker {
 				// change scan above failing -- that must label the root
 				// UNKNOWN_BRANCH, not drop real, already-captured changes.
 				const branch = known ? known.branch : await foreignRootBranch(this.gitForRoot(root)).catch(() => UNKNOWN_BRANCH);
-				trees.push({ root, ...(branch ? { branch } : {}), model: tracker.model });
+				return { root, ...(branch ? { branch } : {}), model: tracker.model };
 			} catch {
-				// Linked roots can disappear between discovery and status.
+				// A root the caller stops registering mid-scan (e.g. a removed
+				// worktree) triggers the rescan below without it, not a failure.
+				failed.push(root);
+				return undefined;
 			}
-		}
+		}));
+		const trees = scanned.filter((tree): tree is WorktreeChanges => tree !== undefined);
 		const latest = new Set(this.registeredRoots());
 		// A root admitted during status must not wait for a later poll (which may
 		// be disabled). Ordinary overlapping polls still share exactly one scan.
 		if (latest.size !== roots.size || [...latest].some((root) => !roots.has(root))) return this.capture();
 		this.worktrees = trees;
+		this.failedRoots = failed;
+		this.scannedRootCount = roots.size;
 		return this.model;
 	}
 }
 
 const noLines: LineCounter = async () => 0;
 
+// Per-file line counts and revision lookups are file IO: a large change set
+// runs this many files at a time instead of one by one or all at once.
+export const FILE_WORK_CONCURRENCY = 8;
+
+async function eachLimited<T>(items: readonly T[], limit: number, work: (item: T) => Promise<void>): Promise<void> {
+	let next = 0;
+	const worker = async () => {
+		while (next < items.length) await work(items[next++]);
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
+
 const NUMSTAT_ARGS = ["diff", "--numstat", "HEAD"];
 const PORCELAIN_ARGS = ["status", "--porcelain=v1", "--untracked-files=all", "-z"];
 
@@ -324,20 +329,27 @@ const PORCELAIN_ARGS = ["status", "--porcelain=v1", "--untracked-files=all", "-z
 export class ChangesTracker {
 	private readonly git: GitRunner;
 	private readonly countLines: LineCounter;
+	private readonly revision: FileRevision | undefined;
 	private current: ChangesModel = emptyChanges();
 	private available = false;
 	private inFlight: Promise<ChangesModel> | undefined;
 	private queued = false;
 
-	constructor(git: GitRunner, countLines: LineCounter = noLines) {
+	constructor(git: GitRunner, countLines: LineCounter = noLines, revision?: FileRevision) {
 		this.git = git;
 		this.countLines = countLines;
+		this.revision = revision;
 	}
 
 	get model(): ChangesModel {
 		return this.current;
 	}
 
+	/** False when the last start could not read `git status`. */
+	get statusRead(): boolean {
+		return this.available;
+	}
+
 	async start(): Promise<void> {
 		const files = await this.capture();
 		this.available = files !== undefined;
@@ -372,9 +384,14 @@ export class ChangesTracker {
 		if (porcelain.code !== 0) return undefined;
 		const files = snapshotChanges({ numstat: numstat.stdout, porcelain: porcelain.stdout });
 		// Untracked files never appear in numstat; count their lines directly.
-		for (const file of files) {
-			if (file.status === CHANGE_STATUS.UNTRACKED) file.added = await this.countLines(file.path).catch(() => 0);
-		}
+		await eachLimited(files, FILE_WORK_CONCURRENCY, async (file) => {
+			const [added, revision] = await Promise.all([
+				file.status === CHANGE_STATUS.UNTRACKED ? this.countLines(file.path).catch(() => 0) : undefined,
+				this.revision?.(file.path).catch(() => undefined),
+			]);
+			if (added !== undefined) file.added = added;
+			if (revision) file.diffRevision = revision;
+		});
 		return files;
 	}
 }

package/lib/shell-prompt.ts

@@ -74,7 +74,9 @@ export const DOUBLE_ESC_CANCEL_HINT = "esc again to cancel";
 export const IDLE_ESC_CLEAR_HINT = "esc again to clear";
 const LABEL_ROLE = "muted";
 const HINT_ROLE = "dim";
-const FAKE_CURSOR = "\x1b[7m \x1b[0m";
+// Audited legacy SGR and Pi 1.2 APC cursors. Do not resolve the latter
+// here: the host TUI owns hardware-cursor suppression after composition.
+const EMPTY_FAKE_CURSORS = ["\x1b[7m \x1b[0m", "\x1b_pi:fc\x07 \x1b_pi:/fc\x07"];
 const SCROLL_INDICATOR = /[↑↓] \d+ more/;
 const STATE_LABEL: Record<PromptState, string | undefined> = {
 	[PROMPT_STATE.IDLE]: undefined,
@@ -228,9 +230,9 @@ export function framePromptLines(lines: string[], width: number, options: Prompt
 }
 
 export function withPromptHint(line: string, hint: string, fg: PromptFrameOptions["fg"]): string {
-	const cursorAt = line.indexOf(FAKE_CURSOR);
-	if (cursorAt === -1) return line;
-	const afterCursor = cursorAt + FAKE_CURSOR.length;
+	const cursor = EMPTY_FAKE_CURSORS.find((marker) => line.includes(marker));
+	if (!cursor) return line;
+	const afterCursor = line.indexOf(cursor) + cursor.length;
 	const trailing = line.slice(afterCursor);
 	if (trailing.trim() !== "" || trailing.length < hint.length + 1) return line;
 	return `${line.slice(0, afterCursor)} ${fg(HINT_ROLE, hint)}${" ".repeat(trailing.length - hint.length - 1)}`;

package/lib/shell-sidebar-layout.ts

@@ -179,6 +179,10 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme, placement: () =>
 	};
 	scroll.handleMouse = (event) => {
 		if (event.type === "wheel") {
+			// A bounded section (Todo) owns its inner viewport. Only wheel
+			// events it declines should move the surrounding rail.
+			const sectionResult = dispatchPartMouse(event);
+			if (sectionResult?.handled) return sectionResult;
 			// Consume even at the boundary or over blank rail space: Pi 0.85.1
 			// can send unconsumed delta to the primary transcript despite containment.
 			scroll.scrollBy(event.wheelDelta ?? 0);
@@ -375,7 +379,7 @@ export function installSidebar(tui: TUI, theme: ShellBarTheme, placement: () =>
 		stopped = true;
 		state.active = false;
 		clearInterval(timer);
-		scroll.hideTransientScrollbar();
+		scroll.setScrollbar("hidden");
 		for (const cleanup of cleanups.reverse()) cleanup();
 		tui.requestRender();
 	};

package/lib/shell-todo.ts

@@ -1,4 +1,4 @@
-import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { truncateToWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { CARD_TONE, panelHeaderRow, panelInnerWidth, renderCard, type CardTheme, type CardTone } from "./shell-card.ts";
 import { sanitizeTerminalText } from "./terminal-theme.ts";
 import { paintHoverable } from "./shell-hover.ts";
@@ -11,7 +11,11 @@ import { paintHoverable } from "./shell-hover.ts";
 export const TODO_STATUS = {
 	PENDING: "pending",
 	IN_PROGRESS: "in_progress",
+	/** Open, but waiting on something outside the list; always carries a note naming it. */
+	BLOCKED: "blocked",
 	DONE: "done",
+	/** Will not be done, on purpose: terminal, and never counts as open. */
+	DROPPED: "dropped",
 } as const;
 
 export type TodoStatus = (typeof TODO_STATUS)[keyof typeof TODO_STATUS];
@@ -86,10 +90,20 @@ export interface TodoRenderOptions {
 export const TODO_DETAILS_KEY = "gentleTodo";
 export const TODO_TOOL_NAME = "todo";
 export const TODO_GLYPH = "❀";
-const STATUS_ALIASES: Record<string, TodoStatus> = { completed: TODO_STATUS.DONE, complete: TODO_STATUS.DONE, doing: TODO_STATUS.IN_PROGRESS, todo: TODO_STATUS.PENDING };
-const STATUS_GLYPH: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "○", [TODO_STATUS.IN_PROGRESS]: "◐", [TODO_STATUS.DONE]: "✓" };
-const STATUS_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "text", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.DONE]: "dim" };
-const GLYPH_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "muted", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.DONE]: "success" };
+const STATUS_ALIASES: Record<string, TodoStatus> = {
+	completed: TODO_STATUS.DONE,
+	complete: TODO_STATUS.DONE,
+	doing: TODO_STATUS.IN_PROGRESS,
+	todo: TODO_STATUS.PENDING,
+	cancelled: TODO_STATUS.DROPPED,
+	canceled: TODO_STATUS.DROPPED,
+	abandoned: TODO_STATUS.DROPPED,
+};
+const STATUS_LIST = "pending, in_progress, blocked, done, or dropped";
+const BLOCKED_NEEDS_NOTE = "blocked needs a note naming what it waits for";
+const STATUS_GLYPH: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "○", [TODO_STATUS.IN_PROGRESS]: "◐", [TODO_STATUS.BLOCKED]: "⊘", [TODO_STATUS.DONE]: "✓", [TODO_STATUS.DROPPED]: "✕" };
+const STATUS_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "text", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.BLOCKED]: "text", [TODO_STATUS.DONE]: "dim", [TODO_STATUS.DROPPED]: "dim" };
+const GLYPH_ROLE: Record<TodoStatus, string> = { [TODO_STATUS.PENDING]: "muted", [TODO_STATUS.IN_PROGRESS]: "accent", [TODO_STATUS.BLOCKED]: "warning", [TODO_STATUS.DONE]: "success", [TODO_STATUS.DROPPED]: "muted" };
 const NOTE_ROLE = "muted";
 const STALE_AFTER_TURNS = 2;
 /** Above this many rows the finished tasks fold into one line and the rest is capped. */
@@ -111,20 +125,30 @@ function parseStatus(value: unknown): TodoStatus | undefined {
 	return STATUS_ALIASES[normalized];
 }
 
+function countStatus(state: TodoState, status: TodoStatus): number {
+	return state.tasks.filter((task) => task.status === status).length;
+}
+
+/** Dropped tasks are neither done nor open. */
 export function todoSummary(state: TodoState): TodoSummary {
-	const done = state.tasks.filter((task) => task.status === TODO_STATUS.DONE).length;
-	return { done, total: state.tasks.length, open: state.tasks.length - done };
+	const done = countStatus(state, TODO_STATUS.DONE);
+	return { done, total: state.tasks.length, open: state.tasks.length - done - countStatus(state, TODO_STATUS.DROPPED) };
 }
 
+// Only work the model can pick up goes stale: a list whose open tasks all
+// wait on something outside it has nothing to bring up to date.
 export function staleTurns(state: TodoState, currentTurn: number): number {
-	if (state.updatedTurn === null || todoSummary(state).open === 0) return 0;
+	const actionable = state.tasks.some((task) => task.status === TODO_STATUS.PENDING || task.status === TODO_STATUS.IN_PROGRESS);
+	if (state.updatedTurn === null || !actionable) return 0;
 	return Math.max(0, currentTurn - state.updatedTurn);
 }
 
 function summaryText(state: TodoState): string {
 	const { done, total } = todoSummary(state);
-	const inProgress = state.tasks.filter((task) => task.status === TODO_STATUS.IN_PROGRESS).length;
-	return `${total} ${total === 1 ? "task" : "tasks"} · ${done} done · ${inProgress} in progress`;
+	const inProgress = countStatus(state, TODO_STATUS.IN_PROGRESS);
+	const blocked = countStatus(state, TODO_STATUS.BLOCKED);
+	const dropped = countStatus(state, TODO_STATUS.DROPPED);
+	return `${total} ${total === 1 ? "task" : "tasks"} · ${done} done · ${inProgress} in progress${blocked ? ` · ${blocked} blocked` : ""}${dropped ? ` · ${dropped} dropped` : ""}`;
 }
 
 function taskLine(task: TodoTask): string {
@@ -135,8 +159,9 @@ function buildTask(input: TodoTaskInput, id: number): TodoTask | string {
 	const title = cleanText(input.title);
 	if (title.length === 0) return "title is required";
 	const status = parseStatus(input.status);
-	if (status === undefined) return `unknown status "${input.status}" (use pending, in_progress, or done)`;
+	if (status === undefined) return `unknown status "${input.status}" (use ${STATUS_LIST})`;
 	const note = cleanText(input.note);
+	if (status === TODO_STATUS.BLOCKED && note.length === 0) return BLOCKED_NEEDS_NOTE;
 	return { id, title, status, ...(note ? { note } : {}) };
 }
 
@@ -233,15 +258,28 @@ export function replayTodo(entries: readonly unknown[]): TodoState {
 	return state;
 }
 
-export function todoPromptBlock(state: TodoState, stale: number): string | undefined {
+// gentle-shell#1367, #1662: the system prompt is a cached prefix for every
+// provider, so the block it carries is byte-stable for the whole session:
+// rules only, no task content and no counters. The current list travels as a
+// request-local message at the end of the conversation (todoStateMessage),
+// where a change costs only the tail of the request, never the prefix.
+const TODO_PROMPT_BLOCK = [
+	"## Todo list",
+	"Keep it current with the `todo` tool: mark a task in_progress before starting it, done right after finishing it, and rewrite the whole list with `write` whenever the plan changes. Update it before you end the turn.",
+	"A blocked task waits on something outside the list: do not work on it until its condition holds. When the plan changes, mark the tasks it made obsolete dropped instead of leaving them pending or marking them done.",
+	"While tasks stay open, the current list arrives as the last message of each request; it is not repeated here.",
+].join("\n");
+
+/** The byte-stable rules block appended to every system prompt. */
+export function todoPromptBlock(): string {
+	return TODO_PROMPT_BLOCK;
+}
+
+/** The open-task snapshot delivered as a request-local message; undefined when nothing is open. */
+export function todoStateMessage(state: TodoState): string | undefined {
 	if (todoSummary(state).open === 0) return undefined;
 	const lines = state.tasks.map((task, index) => `${index + 1}. [${task.status}] ${task.title}${task.note ? ` — ${task.note}` : ""}`);
-	const staleLine = stale >= STALE_AFTER_TURNS ? `\n(stale: ${stale} turns without an update — bring the list up to date now)` : "";
-	return [
-		"## Todo list",
-		"Keep it current with the `todo` tool: mark a task in_progress before starting it, done right after finishing it, and rewrite the whole list with `write` whenever the plan changes. Update it before you end the turn.",
-		...lines,
-	].join("\n") + staleLine;
+	return ["Current todo list:", ...lines].join("\n");
 }
 
 function taskRow(task: TodoTask, theme: TodoTheme, inner: number): string {
@@ -253,18 +291,22 @@ function taskRow(task: TodoTask, theme: TodoTheme, inner: number): string {
 			.join("\n");
 	}
 	const title = task.title;
-	const note = task.status === TODO_STATUS.IN_PROGRESS && task.note ? ` ${theme.fg(NOTE_ROLE, "·")} ${theme.fg(NOTE_ROLE, task.note)}` : "";
+	const showsNote = task.status === TODO_STATUS.IN_PROGRESS || task.status === TODO_STATUS.BLOCKED;
+	const note = showsNote && task.note ? ` ${theme.fg(NOTE_ROLE, "·")} ${theme.fg(NOTE_ROLE, task.note)}` : "";
 	return `${theme.fg(GLYPH_ROLE[task.status], STATUS_GLYPH[task.status])} ${theme.fg(STATUS_ROLE[task.status], title)}${note}`;
 }
 
-// Long lists keep the card short: done tasks fold into "✓ N done" and the
-// open ones fill the remaining rows, with a trailing count for the rest.
+// Long lists keep the card short: done and dropped tasks fold into "✓ N done"
+// and "✕ N dropped", and the open ones fill the remaining rows, with a
+// trailing count for the rest.
 function bodyRows(state: TodoState, theme: TodoTheme, inner: number): string[] {
 	if (state.tasks.length <= ROW_CAP) return state.tasks.map((task) => taskRow(task, theme, inner));
-	const { done } = todoSummary(state);
-	const open = state.tasks.filter((task) => task.status !== TODO_STATUS.DONE);
+	const open = state.tasks.filter((task) => task.status !== TODO_STATUS.DONE && task.status !== TODO_STATUS.DROPPED);
 	const rows: string[] = [];
-	if (done > 0) rows.push(`${theme.fg(GLYPH_ROLE[TODO_STATUS.DONE], STATUS_GLYPH[TODO_STATUS.DONE])} ${theme.fg(NOTE_ROLE, `${done} done`)}`);
+	for (const [status, label] of [[TODO_STATUS.DONE, "done"], [TODO_STATUS.DROPPED, "dropped"]] as const) {
+		const count = countStatus(state, status);
+		if (count > 0) rows.push(`${theme.fg(GLYPH_ROLE[status], STATUS_GLYPH[status])} ${theme.fg(NOTE_ROLE, `${count} ${label}`)}`);
+	}
 	const room = ROW_CAP - rows.length - (open.length > ROW_CAP - rows.length ? 1 : 0);
 	for (const task of open.slice(0, room)) rows.push(taskRow(task, theme, inner));
 	if (open.length > room) rows.push(theme.fg(NOTE_ROLE, `… ${open.length - room} more`));
@@ -276,6 +318,8 @@ function collapsedRow(state: TodoState, theme: TodoTheme, inner: number): string
 	if (active) return taskRow(active, theme, inner);
 	const pending = state.tasks.find((task) => task.status === TODO_STATUS.PENDING);
 	if (pending) return taskRow(pending, theme, inner);
+	const blocked = state.tasks.find((task) => task.status === TODO_STATUS.BLOCKED);
+	if (blocked) return taskRow(blocked, theme, inner);
 	const { open } = todoSummary(state);
 	return `${theme.fg(GLYPH_ROLE[TODO_STATUS.PENDING], STATUS_GLYPH[TODO_STATUS.PENDING])} ${theme.fg(NOTE_ROLE, `${open} open`)}`;
 }
@@ -288,6 +332,8 @@ export function todoCardTone(staleTurns: number): CardTone {
 export function renderTodoCard(state: TodoState, theme: TodoTheme, width: number, options: TodoRenderOptions): string[] {
 	if (state.tasks.length === 0) return [];
 	const { done, total } = todoSummary(state);
+	// Dropped work is not part of the plan anymore, so it leaves the denominator.
+	const planned = total - countStatus(state, TODO_STATUS.DROPPED);
 	const stale = options.staleTurns >= STALE_AFTER_TURNS;
 	const action = options.collapsed ? "expand" : "collapse";
 	const actionLabel = action[0]!.toUpperCase() + action.slice(1);
@@ -300,12 +346,21 @@ export function renderTodoCard(state: TodoState, theme: TodoTheme, width: number
 	// Content columns of the card body in the active style (float is narrower).
 	const inner = panelInnerWidth(theme, width, tone);
 	const rows = options.collapsed ? [collapsedRow(state, theme, inner)] : options.scrollable ? state.tasks.map((task) => taskRow(task, theme, inner)) : bodyRows(state, theme, inner);
-	const body = stale ? [theme.fg(NOTE_ROLE, `stale · ${options.staleTurns} turns`), ...rows] : rows;
+	const staleLabel = theme.fg(NOTE_ROLE, `stale · ${options.staleTurns} turns`);
+	let body = options.collapsed
+		? [truncateToWidth(`${stale ? `${staleLabel} · ` : ""}${rows[0]}`, inner, "…")]
+		: stale ? [staleLabel, ...rows] : rows;
+	if (!options.collapsed && !options.scrollable) {
+		// Budget physical lines after wrapping: one long task can exceed the
+		// old task-count cap by itself. Scrollable hosts retain every line.
+		body = body.flatMap((row) => wrapTextWithAnsi(row, Math.max(1, inner)));
+		if (body.length > ROW_CAP) body = [...body.slice(0, ROW_CAP - 1), theme.fg(NOTE_ROLE, "… more")];
+	}
 	// The clickable control paints the shared hover role while hovered --
 	// same treatment every other clickable surface uses -- instead of its
 	// ordinary accent role.
 	return renderCard(
-		{ title: `Todos ${paintHoverable(theme, control, options.hovered, "accent")}`, subtitle: `${done} of ${total}`, body, tone, glyph: TODO_GLYPH },
+		{ title: `Todos ${paintHoverable(theme, control, options.hovered, "accent")}`, subtitle: `${done} of ${planned}`, body, tone, glyph: TODO_GLYPH },
 		theme,
 		width,
 		{ expanded: true, hint, panel: true },

package/lib/shell-usage.ts

@@ -269,7 +269,7 @@ export function formatReset(resetAt: number | null, now: number): string {
 }
 
 function parseWindow(raw: RawWindow | null | undefined, now: number): UsageWindow | undefined {
-	if (!raw || typeof raw.used_percent !== "number" || typeof raw.limit_window_seconds !== "number") return undefined;
+	if (!raw || !isFiniteNumber(raw.used_percent) || !isFiniteNumber(raw.limit_window_seconds) || raw.limit_window_seconds <= 0) return undefined;
 	const resetAt =
 		typeof raw.reset_at === "number" ? raw.reset_at * 1000 : typeof raw.reset_after_seconds === "number" ? now + raw.reset_after_seconds * 1000 : null;
 	return { label: windowLabel(raw.limit_window_seconds), usedPercent: raw.used_percent, windowSeconds: raw.limit_window_seconds, resetAt };
@@ -297,9 +297,10 @@ export function parseCodexUsage(payload: unknown, now: number): ProviderUsage {
 function headerWindow(headers: Record<string, string>, kind: "primary" | "secondary"): UsageWindow | undefined {
 	const used = Number.parseFloat(headers[`${HEADER_PREFIX}${kind}-used-percent`] ?? "");
 	if (!Number.isFinite(used)) return undefined;
-	const minutes = Number.parseInt(headers[`${HEADER_PREFIX}${kind}-window-minutes`] ?? "", 10);
+	// Missing or invalid duration is not a zero-minute quota or an assumed 5h window.
+	const seconds = Number(headers[`${HEADER_PREFIX}${kind}-window-minutes`]) * MINUTE;
+	if (!Number.isFinite(seconds) || seconds <= 0) return undefined;
 	const resetAt = Number.parseInt(headers[`${HEADER_PREFIX}${kind}-reset-at`] ?? "", 10);
-	const seconds = Number.isFinite(minutes) ? minutes * MINUTE : 0;
 	return { label: windowLabel(seconds), usedPercent: used, windowSeconds: seconds, resetAt: Number.isFinite(resetAt) ? resetAt * 1000 : null };
 }