gentle-pi 4.1.0 → 4.3.0

package/lib/shell-changes-view.ts

@@ -67,12 +67,15 @@ export function colorDiff(text: string, theme: ChangesViewTheme): string[] {
 	return lines;
 }
 
+// New files are two distinct states: `A` is tracked and staged, `U` is still
+// untracked. Git's own `??` reads as a broken value in a status column, so the
+// list names the state instead of echoing the plumbing code.
 const FILE_STATUS = {
 	[CHANGE_STATUS.MODIFIED]: "M",
 	[CHANGE_STATUS.ADDED]: "A",
 	[CHANGE_STATUS.DELETED]: "D",
 	[CHANGE_STATUS.RENAMED]: "R",
-	[CHANGE_STATUS.UNTRACKED]: "??",
+	[CHANGE_STATUS.UNTRACKED]: "U",
 } as const;
 
 function fileCounts(file: ChangedFile, theme: ChangesViewTheme): string {
@@ -113,18 +116,41 @@ function fit(text: string, width: number): string {
 	return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
 }
 
-// Both standalone files and the worktree accordion use the original frame.
-function renderPanes(width: number, rows: number, theme: ChangesViewTheme, title: string, leftLine: (row: number) => string, diffLines: string[], keys: string, headerFile?: ChangedFile): string[] {
+// One geometry feeds both rendering and pointer hit-testing, so clicks stay
+// aligned with what is painted. Diff-only drops the list column and its
+// separator; its empty list zone receives no pointer events.
+interface PaneLayout {
+	inner: number;
+	listWidth: number;
+	diffWidth: number;
+	listStart: number;
+	listEnd: number;
+	diffStart: number;
+	diffEnd: number;
+}
+
+function paneLayout(width: number, diffOnly: boolean): PaneLayout {
 	const inner = Math.max(8, width - 2);
+	if (diffOnly) return { inner, listWidth: 0, diffWidth: inner - 2, listStart: 0, listEnd: 0, diffStart: 2, diffEnd: inner };
 	const listWidth = Math.min(LIST_MAX_WIDTH, Math.floor(inner * LIST_RATIO));
 	const diffWidth = inner - listWidth - 4;
+	return { inner, listWidth, diffWidth, listStart: 2, listEnd: 2 + listWidth, diffStart: 5 + listWidth, diffEnd: 5 + listWidth + diffWidth };
+}
+
+// Both standalone files and the worktree accordion use the original frame.
+function renderPanes(width: number, rows: number, theme: ChangesViewTheme, title: string, leftLine: (row: number) => string, diffLines: string[], keys: string, headerFile?: ChangedFile, diffOnly = false): string[] {
+	const { inner, listWidth, diffWidth } = paneLayout(width, diffOnly);
 	const rightLines = headerFile ? [pathHeader(headerFile, theme, diffWidth), ...diffLines] : diffLines;
 	const titleText = truncateToWidth(title, inner - 4, "…");
 	const top = theme.fg(ROLE.FRAME, "╭─ ") + theme.fg(ROLE.TITLE, titleText) + theme.fg(ROLE.FRAME, ` ${rule(inner - visibleWidth(titleText) - 3)}╮`);
 	const body: string[] = [];
 	for (let row = 0; row < rows; row += 1) {
-		const left = fit(leftLine(row), listWidth);
 		const right = fit(rightLines[row] ?? "", diffWidth);
+		if (diffOnly) {
+			body.push(`${theme.fg(ROLE.FRAME, "│")} ${right} ${theme.fg(ROLE.FRAME, "│")}`);
+			continue;
+		}
+		const left = fit(leftLine(row), listWidth);
 		body.push(`${theme.fg(ROLE.FRAME, "│")} ${left} ${theme.fg(ROLE.FRAME, "│")} ${right}${theme.fg(ROLE.FRAME, "│")}`);
 	}
 	const keysLine = `${theme.fg(ROLE.FRAME, "│")} ${fit(keys, inner - 2)} ${theme.fg(ROLE.FRAME, "│")}`;
@@ -142,11 +168,9 @@ interface PointerLayout {
 	diffEnd: number;
 }
 
-function pointerLayout(width: number, bodyRows: number): PointerLayout {
-	const inner = Math.max(8, width - 2);
-	const listWidth = Math.min(LIST_MAX_WIDTH, Math.floor(inner * LIST_RATIO));
-	const diffWidth = inner - listWidth - 4;
-	return { width, height: bodyRows + CHROME_ROWS, bodyRows, listStart: 2, listEnd: 2 + listWidth, diffStart: 5 + listWidth, diffEnd: 5 + listWidth + diffWidth };
+function pointerLayout(width: number, bodyRows: number, diffOnly = false): PointerLayout {
+	const { listStart, listEnd, diffStart, diffEnd } = paneLayout(width, diffOnly);
+	return { width, height: bodyRows + CHROME_ROWS, bodyRows, listStart, listEnd, diffStart, diffEnd };
 }
 
 function displayText(text: string): string {
@@ -186,6 +210,8 @@ export class WorktreeChangesView {
 	private disposed = false;
 	private leftPressActive = false;
 	private hoveredIndex: number | undefined;
+	// Not persisted: every opening starts with the file list visible.
+	private diffOnly = false;
 	private readonly expanded = new Set<string>();
 	private readonly previews = new Map<string, { fingerprint: string; view: ChangesView }>();
 
@@ -224,13 +250,27 @@ export class WorktreeChangesView {
 	handleInput(data: string): void {
 		if (this.disposed) return;
 		if (data === "r") return this.deps.onRefresh();
-		if (matchesKey(data, Key.escape) || data === "q") return this.deps.onClose();
+		if (data === "q") return this.deps.onClose();
+		if (matchesKey(data, Key.escape)) {
+			if (!this.diffOnly) return this.deps.onClose();
+			return this.setDiffOnly(false);
+		}
+		if (data === "F") return this.setDiffOnly(!this.diffOnly);
 		const rows = this.visibleRows();
 		const row = rows[this.selected];
 		if (matchesKey(data, Key.pageDown) || matchesKey(data, Key.pageUp) || matchesKey(data, Key.ctrl("j")) || matchesKey(data, Key.ctrl("k"))) {
 			if (row?.file) this.previews.get(rowKey(row))?.view.handleInput(data);
 			return;
 		}
+		if (this.diffOnly) {
+			// Only files have a diff: j/k walk every file, crossing groups.
+			if (data === "j" || matchesKey(data, Key.down)) this.stepFile(1);
+			else if (data === "k" || matchesKey(data, Key.up)) this.stepFile(-1);
+			else if (row?.file && (data === "o" || matchesKey(data, Key.enter))) return this.deps.onOpen(row.tree.root, row.file);
+			else return;
+			this.deps.requestRender();
+			return;
+		}
 		if (data === "j" || matchesKey(data, Key.down)) this.selected = Math.max(0, Math.min(rows.length - 1, this.selected + 1));
 		else if (data === "k" || matchesKey(data, Key.up)) this.selected = Math.max(0, this.selected - 1);
 		else if (row && (matchesKey(data, Key.left) || matchesKey(data, Key.backspace))) {
@@ -315,9 +355,11 @@ export class WorktreeChangesView {
 				: paintHoverable(theme, `${this.expanded.has(row.tree.root) ? "▾" : "▸"} ${displayText(row.tree.branch ?? "detached")} · ${displayText(basename(row.tree.root))}`, hovered, idleRole);
 			return `${marker} ${text}`;
 		};
-		const keys = theme.fg(ROLE.KEY_TEXT, "j/k select   enter toggle/open   ← parent/fold   ctrl+j/k scroll   r refresh   esc close");
-		this.pointerLayout = pointerLayout(width, height);
-		return renderPanes(width, height, theme, `✎ Changes · ${this.trees.length} worktrees`, leftLine, preview, keys, selected?.file);
+		const keys = theme.fg(ROLE.KEY_TEXT, this.diffOnly
+			? "j/k file   ctrl+j/k scroll   o open   r refresh   F files   esc files"
+			: "j/k select   enter toggle/open   ← fold   ctrl+j/k scroll   r refresh   F diff only   esc close");
+		this.pointerLayout = pointerLayout(width, height, this.diffOnly);
+		return renderPanes(width, height, theme, `✎ Changes · ${this.trees.length} worktrees`, leftLine, preview, keys, selected?.file, this.diffOnly);
 	}
 
 	invalidate(): void {
@@ -341,6 +383,31 @@ export class WorktreeChangesView {
 		return Math.max(MIN_BODY_ROWS, rows - CHROME_ROWS);
 	}
 
+	private setDiffOnly(on: boolean): void {
+		this.diffOnly = on;
+		this.hoveredIndex = undefined;
+		this.pointerLayout = undefined;
+		// A group header has no diff; diff-only starts on the next file.
+		if (on && !this.visibleRows()[this.selected]?.file) this.stepFile(1);
+		this.deps.requestRender();
+	}
+
+	// Move to the next file in the fully expanded order, expanding its group
+	// so the file list shows the same selection after diff-only mode.
+	private stepFile(direction: 1 | -1): void {
+		const all: WorktreeRow[] = this.trees.flatMap((tree) => [{ tree }, ...tree.model.files.map((file) => ({ tree, file }))]);
+		const current = this.visibleRows()[this.selected];
+		let index = current ? all.findIndex((row) => rowKey(row) === rowKey(current)) : -1;
+		do index += direction;
+		while (index >= 0 && index < all.length && !all[index]!.file);
+		const target = all[index];
+		if (!target) return;
+		this.expanded.add(target.tree.root);
+		this.selected = this.visibleRows().findIndex((row) => rowKey(row) === rowKey(target));
+		this.ensureSelectedVisible();
+		this.ensurePreview();
+	}
+
 	private scrollList(delta: number, rows: number): boolean {
 		const next = Math.max(0, Math.min(Math.max(0, this.visibleRows().length - rows), this.listOffset + Math.trunc(delta)));
 		if (next === this.listOffset) return false;

package/lib/shell-changes.ts

@@ -110,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 });
 	}

package/lib/shell-gauge.ts

@@ -20,10 +20,38 @@ const GAUGE_EMPTY_ROLE = "border";
 const WARNING_THRESHOLD = 80;
 const ERROR_THRESHOLD = 95;
 
-export function renderGauge(percent: number | null, cells: number = GAUGE_CELLS): string {
+// Gauge-specific theme roles (issue #2222). Every field is optional and falls
+// back to the shared role the gauge painted with before gauge roles existed,
+// so themes without a gauge block render byte-identically to today.
+export interface GaugePaint {
+	/** Filled cells below the warning threshold; falls back to `accent`. */
+	ok?: string;
+	/** Filled cells from 80%; falls back to `warning`. */
+	warning?: string;
+	/** Filled cells from 95%; falls back to `error`. */
+	error?: string;
+	/** Empty cells; falls back to `border`. */
+	empty?: string;
+	/** Filled-cell glyph; falls back to `▰`. */
+	filled?: string;
+	/** Empty-cell glyph; falls back to `▱`. */
+	emptyGlyph?: string;
+}
+
+export interface GaugeGlyphs {
+	filled: string;
+	empty: string;
+}
+
+export function gaugeGlyphs(glyphs?: Partial<GaugeGlyphs>): GaugeGlyphs {
+	return { filled: glyphs?.filled ?? GAUGE_FILLED, empty: glyphs?.empty ?? GAUGE_EMPTY };
+}
+
+export function renderGauge(percent: number | null, cells: number = GAUGE_CELLS, glyphs?: Partial<GaugeGlyphs>): string {
 	const clamped = Math.max(0, Math.min(100, percent ?? 0));
 	const filled = Math.round((clamped / 100) * cells);
-	return GAUGE_FILLED.repeat(filled) + GAUGE_EMPTY.repeat(cells - filled);
+	const [filledGlyph, emptyGlyph] = [glyphs?.filled ?? GAUGE_FILLED, glyphs?.empty ?? GAUGE_EMPTY];
+	return filledGlyph.repeat(filled) + emptyGlyph.repeat(cells - filled);
 }
 
 export function gaugeTone(percent: number | null): GaugeTone {
@@ -33,8 +61,23 @@ export function gaugeTone(percent: number | null): GaugeTone {
 	return GAUGE_TONE.ACCENT;
 }
 
-export function paintGauge(percent: number | null, theme: GaugeTheme, cells: number = GAUGE_CELLS): string {
-	const gauge = renderGauge(percent, cells);
-	const filled = gauge.replace(new RegExp(`${GAUGE_EMPTY}+$`), "");
-	return theme.fg(gaugeTone(percent), filled) + theme.fg(GAUGE_EMPTY_ROLE, gauge.slice(filled.length));
+export function paintGauge(percent: number | null, theme: GaugeTheme, cells: number = GAUGE_CELLS, paint?: GaugePaint): string {
+	const glyphs = gaugeGlyphs(paint && { filled: paint.filled, empty: paint.emptyGlyph });
+	const gauge = renderGauge(percent, cells, glyphs);
+	const filled = stripTrailing(gauge, glyphs.empty);
+	// Token names go through theme.fg; raw ANSI prefixes (resolved from direct
+	// colors by gauge-theme.ts) paint directly, so the gauges alone recolor.
+	const isAnsi = (role: string | undefined): role is string => typeof role === "string" && role.startsWith("\x1b[");
+	const paintFg = (role: string | undefined, fallback: string, text: string): string => (isAnsi(role) ? `${role}${text}\x1b[39m` : theme.fg(role ?? fallback, text));
+	const tone = gaugeTone(percent);
+	const filledRole = tone === GAUGE_TONE.ACCENT ? paint?.ok : tone === GAUGE_TONE.WARNING ? paint?.warning : tone === GAUGE_TONE.ERROR ? paint?.error : undefined;
+	return paintFg(filledRole, tone, filled) + paintFg(paint?.empty, GAUGE_EMPTY_ROLE, gauge.slice(filled.length));
+}
+
+// Strips the maximal run of trailing empty glyphs without building a RegExp
+// from theme-authored strings, which could contain regex metacharacters.
+function stripTrailing(gauge: string, empty: string): string {
+	let end = gauge.length;
+	while (end >= empty.length && end > 0 && gauge.endsWith(empty, end)) end -= empty.length;
+	return gauge.slice(0, end);
 }

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-todo.ts

@@ -90,6 +90,21 @@ export interface TodoRenderOptions {
 export const TODO_DETAILS_KEY = "gentleTodo";
 export const TODO_TOOL_NAME = "todo";
 export const TODO_GLYPH = "❀";
+/** Emitted on pi.events after each successful todo write; gentle-agents publishes it as session progress. */
+export const TODO_PROGRESS_EVENT = "gentle-pi:todo:progress";
+
+export interface TodoProgress {
+	sessionId: string;
+	done: number;
+	total: number;
+	/** Title of the first in-progress task, or null when none is in progress. */
+	current: string | null;
+}
+
+export function todoProgress(state: TodoState, sessionId: string): TodoProgress {
+	const current = state.tasks.find((task) => task.status === TODO_STATUS.IN_PROGRESS)?.title ?? null;
+	return { sessionId, done: countStatus(state, TODO_STATUS.DONE), total: state.tasks.length, current };
+}
 const STATUS_ALIASES: Record<string, TodoStatus> = {
 	completed: TODO_STATUS.DONE,
 	complete: TODO_STATUS.DONE,
@@ -258,16 +273,32 @@ 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
+// hidden transcript message appended when it changes (todoStateMessage,
+// gentle-shell#2195), so requests stay append-only and a change costs only
+// the tail of the conversation, 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 a hidden conversation message whenever it changes; the latest one is current, and 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;
+}
+
+/** Persisted once an open list closes, so an earlier snapshot never reads as current work (#2195). */
+export const TODO_CLOSED_STATE = "Current todo list: no open tasks.";
+
+/** The open-task snapshot delivered as a hidden transcript 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.",
-		"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.",
-		...lines,
-	].join("\n") + staleLine;
+	return ["Current todo list:", ...lines].join("\n");
 }
 
 function taskRow(task: TodoTask, theme: TodoTheme, inner: number): string {

package/lib/shell-usage-view.ts

@@ -1,5 +1,6 @@
 import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { renderUsagePanel, type ActiveProvider, type UsagePanelScope, type UsageSourceRegistry, type UsageStore, type UsageTheme } from "./shell-usage.ts";
+import type { GaugePaint } from "./shell-gauge.ts";
 import { paintHoverable } from "./shell-hover.ts";
 
 // Gentle Shell subscriptions overlay: a framed panel over the usage store.
@@ -16,6 +17,9 @@ export interface UsageViewDeps {
 	// provider the store holds; with it, exactly the targeted providers, in
 	// scope order, explaining the ones without data.
 	scope?(): UsagePanelScope | undefined;
+	// Optional: gauge-specific theme roles resolved from the installed theme
+	// source; without it the panel paints with the shared roles.
+	gauge?(): GaugePaint | undefined;
 	onRefresh(): Promise<void>;
 	onClose(): void;
 	requestRender(): void;
@@ -106,7 +110,7 @@ export class UsageView {
 		const inner = width - 2;
 		const title = this.refreshing ? REFRESHING : TITLE;
 		const top = theme.fg(FRAME_ROLE, "╭─ ") + theme.fg(TITLE_ROLE, title) + theme.fg(FRAME_ROLE, ` ${rule(inner - visibleWidth(title) - 3)}╮`);
-		const body = renderUsagePanel(this.store.all(), theme, inner - 2, this.deps.now(), this.deps.active(), this.deps.registry?.(), this.deps.scope?.()).map(
+		const body = renderUsagePanel(this.store.all(), theme, inner - 2, this.deps.now(), this.deps.active(), this.deps.registry?.(), this.deps.scope?.(), this.deps.gauge?.()).map(
 			(line) => `${theme.fg(FRAME_ROLE, "│")} ${fit(line, inner - 2)} ${theme.fg(FRAME_ROLE, "│")}`,
 		);
 		const hints = KEYS.map(([key, label]) => ({ key, label, text: `${key} ${label}`, action: (key === "r" ? "refresh" : "close") as HintAction }));

package/lib/shell-usage.ts

@@ -1,6 +1,6 @@
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import { parseModelRef } from "./agents-config.ts";
-import { paintGauge } from "./shell-gauge.ts";
+import { paintGauge, type GaugePaint } from "./shell-gauge.ts";
 
 // Gentle Shell subscription usage: the rate-limit windows each connected
 // provider reports. Codex sends them as SSE headers and through its usage
@@ -514,16 +514,16 @@ export function accountIdFromToken(token: string): string | undefined {
 	}
 }
 
-function paintMeter(percent: number, cells: number, theme: UsageTheme): string {
-	return paintGauge(percent, theme, cells);
+function paintMeter(percent: number, cells: number, theme: UsageTheme, paint?: GaugePaint): string {
+	return paintGauge(percent, theme, cells, paint);
 }
 
-export function renderUsageBar(usage: ProviderUsage, theme: UsageTheme, activeModelId?: string): string | undefined {
+export function renderUsageBar(usage: ProviderUsage, theme: UsageTheme, activeModelId?: string, paint?: GaugePaint): string | undefined {
 	const main = selectUsageLimit(usage, activeModelId);
 	const [first, ...rest] = main?.windows ?? [];
 	if (!first) return undefined;
 	// An unlabeled window prints as the name, the meter and the percentage.
-	const head = [theme.fg(ROLE.LABEL, main.name), ...(first.label.length === 0 ? [] : [theme.fg(ROLE.LABEL, first.label)]), paintMeter(first.usedPercent, 8, theme), theme.fg(ROLE.PERCENT, `${Math.round(first.usedPercent)}%`)].join(" ");
+	const head = [theme.fg(ROLE.LABEL, main.name), ...(first.label.length === 0 ? [] : [theme.fg(ROLE.LABEL, first.label)]), paintMeter(first.usedPercent, 8, theme, paint), theme.fg(ROLE.PERCENT, `${Math.round(first.usedPercent)}%`)].join(" ");
 	const tail = rest.map((window) => `${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.LABEL, window.label)} ${theme.fg(ROLE.PERCENT, `${Math.round(window.usedPercent)}%`)}`);
 	return [head, ...tail].join(" ");
 }
@@ -574,7 +574,7 @@ export interface UsagePanelScope {
 // snapshot keeps that snapshot and says so beside it, and a provider recorded
 // under a previous profile's routing is never presented as current scope after
 // a profile switch.
-export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, width: number, now: number, active?: ActiveProvider, registry?: UsageSourceRegistry, scope?: UsagePanelScope): string[] {
+export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, width: number, now: number, active?: ActiveProvider, registry?: UsageSourceRegistry, scope?: UsagePanelScope, paint?: GaugePaint): string[] {
 	const activeUsage = active ? usages.find((usage) => usage.provider === active.provider) : undefined;
 	const byProvider = new Map(usages.map((usage) => [usage.provider, usage] as const));
 	const rows = scope
@@ -607,7 +607,7 @@ export function renderUsagePanel(usages: ProviderUsage[], theme: UsageTheme, wid
 			const percent = `${Math.round(row.window.usedPercent)}%`.padStart(4);
 			const reset = formatReset(row.window.resetAt, now);
 			const tail = reset.length > 0 ? ` ${theme.fg(ROLE.SEPARATOR, "·")} ${theme.fg(ROLE.RESET, reset)}` : "";
-			lines.push(`  ${theme.fg(ROLE.LABEL, row.name.padEnd(nameWidth))} ${paintMeter(row.window.usedPercent, PANEL_METER_CELLS, theme)} ${theme.fg(ROLE.PERCENT, percent)}${tail}`);
+			lines.push(`  ${theme.fg(ROLE.LABEL, row.name.padEnd(nameWidth))} ${paintMeter(row.window.usedPercent, PANEL_METER_CELLS, theme, paint)} ${theme.fg(ROLE.PERCENT, percent)}${tail}`);
 		}
 		// A failure after a good snapshot never hides either fact: the last good
 		// snapshot stays on its rows and the failed refresh says so beside it.

package/lib/verifier-admission.ts

@@ -0,0 +1,29 @@
+import { namesExistingFeatureDocumentTask } from "./bounded-writer-admission.ts";
+import { contextBackstopReached, type MeasuredContext } from "./context-backstop.ts";
+
+// odd/tasks/verifier-admission.md: the Verification rule reserves the independent verifier for a change that names a
+// Task Size high-risk item, yet a bench run still launched it on a small, not high-risk task. In the primary session a
+// verifier launch is admitted only when its task or context declares a named high-risk item, carries a task of an
+// existing feature document (the same lines writer admission accepts), or the parent's measured context reaches the
+// context backstop. The agent catalog has no generic verifier alias, so only `gentle-ai-verify` is gated.
+const VERIFIER_NAMES = ["gentle-ai-verify"];
+// A line that starts with `Risk:` (optionally as a list item) whose first entry is `item N` with N in 1-6, for
+// example `Risk: item 3 (shared parser)` or `- Risk: item 2, item 3 (reason)`. `Risk: none` and prose mentions
+// do not start such a line.
+const HIGH_RISK_ITEM_LINE = /^[ \t]*(?:[-*+][ \t]+)?Risk:[ \t]*item[ \t]+[1-6](?!\d)/m;
+export const VERIFIER_RISK_REJECTION =
+	"An independent verifier runs only for a change that declares a named high-risk item (`Risk: item N` from the Task Size list in the task). This change declares none: run its focused test and suite inline yourself now; do not retry the launch, and never add a Risk line or create a feature document only to get a verifier admitted.";
+
+export function rejectUnriskedVerifierLaunch(
+	input: unknown,
+	options: { root: string; contextUsage: MeasuredContext | undefined; env?: Readonly<Record<string, string | undefined>> },
+): { block: true; reason: string } | undefined {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return undefined;
+	const record = input as Record<string, unknown>;
+	if (typeof record.agent !== "string" || !VERIFIER_NAMES.includes(record.agent)) return undefined;
+	const values = [record.task, record.context];
+	if (values.some(value => typeof value === "string" && HIGH_RISK_ITEM_LINE.test(value))) return undefined;
+	if (namesExistingFeatureDocumentTask(values, options.root)) return undefined;
+	if (contextBackstopReached(options.contextUsage, options.env)) return undefined;
+	return { block: true, reason: VERIFIER_RISK_REJECTION };
+}

package/lib/vim-editor-adapter.ts

@@ -1,7 +1,7 @@
 import { CURSOR_MARKER, Editor, visibleWidth } from "@earendil-works/pi-tui";
 import { createRequire } from "node:module";
 
-// Private shape audited against @earendil-works/pi-tui 0.99.1, 0.99.2, 1.0.0 and 1.1.0:
+// Private shape audited against @earendil-works/pi-tui 0.99.1, 0.99.2, 1.0.0, 1.1.0 and 1.2.0:
 // editor.js state/pastes/history, sticky cursor reset, layoutText/render geometry,
 // autocomplete cancellation and { state, pastes, pasteCounter } undo restoration;
 // undo-stack.js clone-on-push/pop snapshots. The two 0.99 releases ship identical
@@ -13,6 +13,10 @@ import { createRequire } from "node:module";
 // Actual installed bundled/unbundled tests exercise identity, edit/undo, paste,
 // selection, wrapping/scroll and autocomplete; fabricated metadata tests only
 // prove exact-version admission for the older audited releases.
+// 1.2.0 changes only editor cursor rendering to paired pi:fc/pi:/fc APC
+// markers resolved by the host TUI (including hardware-cursor suppression).
+// Keep these markers intact and rearm selection after their reverse-off;
+// state, undo, paste, layout and autocomplete contracts remain unchanged.
 // Never silently adapt another build: undo also owns the paste registry.
 interface Position { line: number; col: number }
 interface State { lines: string[]; cursorLine: number; cursorCol: number }
@@ -51,7 +55,7 @@ interface PrivateEditor {
 
 // The single audited-release source for the adapter and Gentle Shell's runtime
 // identity gates. Add a release only after re-auditing the files named above.
-export const AUDITED_PI_EDITOR_VERSIONS = Object.freeze(["0.99.1", "0.99.2", "1.0.0", "1.1.0"] as const);
+export const AUDITED_PI_EDITOR_VERSIONS = Object.freeze(["0.99.1", "0.99.2", "1.0.0", "1.1.0", "1.2.0"] as const);
 export type AuditedPiEditorVersion = (typeof AUDITED_PI_EDITOR_VERSIONS)[number];
 
 export function isAuditedPiEditorVersion(version: unknown): version is AuditedPiEditorVersion {
@@ -83,7 +87,7 @@ function hasEditorIdentity(value: unknown, version: string, editorClass: typeof
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 const marker = /\[paste #(\d+)(?: (?:\+\d+ lines|\d+ chars))?\]/g;
 
-// Only CSI SGR and Pi's own zero-width cursor marker are expected in editor
+// Only CSI SGR and Pi's own zero-width cursor markers are expected in editor
 // text. Unknown escapes leave the unmodified frame intact (fail closed).
 function highlightRenderedRow(row: string, chunk: LayoutLine, left: number, right: number, padding: number): string | undefined {
   const cursor = chunk.hasCursor ? chunk.cursorPos : undefined;
@@ -114,8 +118,22 @@ function highlightRenderedRow(row: string, chunk: LayoutLine, left: number, righ
       result += token;
       if (selected && !inverse) { result += "\x1b[7m"; inverse = true; }
     } else if (token.startsWith("\x1b")) {
-      if (token !== CURSOR_MARKER) return undefined;
+      if (token !== CURSOR_MARKER && token !== "\x1b_pi:fc\x07" && token !== "\x1b_pi:/fc\x07") return undefined;
+      // Close selection *before* the cursor pair, never inside its cell:
+      // otherwise a later host SGR 7 would immediately meet our SGR 27.
+      // Closing before CURSOR_MARKER also keeps it adjacent to pi:fc so
+      // hardware-cursor suppression can still recognize the focused pair.
+      const local = col - padding;
+      if ((token === CURSOR_MARKER || token === "\x1b_pi:fc\x07") && selected &&
+          !(local >= left && local < right && local < chunk.text.length)) {
+        if (!nativeInverse && inverse) result += "\x1b[27m";
+        selected = false;
+        inverse = nativeInverse;
+      }
       result += token;
+      // The host resolves pi:/fc to SGR 27, or drops the pair when the
+      // hardware cursor owns this cell. Selection must survive either path.
+      if (token === "\x1b_pi:/fc\x07" && selected) result += "\x1b[7m";
     } else {
       const local = col - padding;
       const shouldSelect = local >= left && local < right && local < chunk.text.length;

package/lib/yolo-temp-scratch.ts

@@ -0,0 +1,69 @@
+// YOLO temp-scratch waiver: a recursive `rm` whose every literal target is the
+// session's own scratch under a temp root needs no data-loss confirmation.
+// Pure over an injectable filesystem view so tests never touch real paths.
+// Callers own the policy gate: primary session with active YOLO only.
+import { lstatSync, realpathSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { posix } from "node:path";
+import type { DestructiveCommandMatch } from "./destructive-command-guard.ts";
+
+export interface TempScratchStat {
+	uid: number;
+	isDirectory(): boolean;
+	isFile(): boolean;
+	isSymbolicLink(): boolean;
+}
+
+export interface TempScratchFs {
+	/** Throws an error with code `ENOENT` when the path is missing. */
+	lstat(path: string): TempScratchStat;
+	/** Current process uid; undefined where POSIX ownership is unavailable. */
+	uid: number | undefined;
+	/** Resolved `os.tmpdir()`, when resolvable. */
+	tmpdir: string | undefined;
+	home: string;
+}
+
+const FIXED_TEMP_ROOTS = ["/tmp", "/var/tmp"];
+const MKTEMP_NAME_RE = /^tmp\.[A-Za-z0-9]{6,}$/;
+// A closed character set: expansion, quoting, glob, brace and redirection
+// characters (`$`, backtick, `~`, `*?[{`, quotes, `<>`) make the shell
+// target differ from the text or add a write elsewhere.
+const LITERAL_PATH_RE = /^\/[A-Za-z0-9._@%+=:,/-]*$/;
+
+export function defaultTempScratchFs(): TempScratchFs {
+	let resolvedTmpdir: string | undefined;
+	try { resolvedTmpdir = realpathSync(tmpdir()); } catch { resolvedTmpdir = undefined; }
+	return { lstat: (path) => lstatSync(path), uid: process.getuid?.(), tmpdir: resolvedTmpdir, home: homedir() };
+}
+
+/** A temp root equal to, above or below home would expose home entries as scratch. */
+function tempRoots(fs: TempScratchFs): string[] {
+	const home = posix.normalize(fs.home);
+	return [...FIXED_TEMP_ROOTS, fs.tmpdir].filter((root): root is string =>
+		root !== undefined && posix.isAbsolute(root) && posix.normalize(root) === root && root !== "/" &&
+		root !== home && !home.startsWith(`${root}/`) && !root.startsWith(`${home}/`));
+}
+
+/** One literal path component directly under a temp root, proven own scratch by an admission-time lstat. */
+export function isTempScratchTarget(target: string, fs: TempScratchFs): boolean {
+	if (fs.uid === undefined || !LITERAL_PATH_RE.test(target)) return false;
+	if (target.endsWith("/") || posix.normalize(target) !== target) return false;
+	const name = posix.basename(target);
+	if (name === "" || name === "." || name === ".." || !tempRoots(fs).includes(posix.dirname(target))) return false;
+	let stat: TempScratchStat;
+	try {
+		stat = fs.lstat(target);
+	} catch (error) {
+		return (error as { code?: unknown }).code === "ENOENT";
+	}
+	if (stat.isSymbolicLink()) return true;
+	if (stat.uid !== fs.uid) return false;
+	return stat.isFile() || (stat.isDirectory() && MKTEMP_NAME_RE.test(name));
+}
+
+/** A recognized effect is waivable temp scratch only when it is a direct recursive `rm` of temp scratch alone. */
+export function isTempScratchRemoval(match: DestructiveCommandMatch, fs: TempScratchFs): boolean {
+	if (match.hardDeny || match.kind !== "filesystem" || match.removalTargets === undefined) return false;
+	return match.removalTargets.every((target) => isTempScratchTarget(target, fs));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gentle-pi",
-	"version": "4.1.0",
+	"version": "4.3.0",
 	"description": "Turn Pi into el Gentleman: an ODD development harness with focused subagents, configured TDD evidence, native review, and skill discovery.",
 	"license": "MIT",
 	"type": "module",
@@ -42,7 +42,6 @@
 	],
 	"scripts": {
 		"check:provider-contract": "node scripts/check-provider-contract.mjs",
-		"mirror:odd-routing": "node scripts/mirror-odd-routing.mjs",
 		"postinstall": "node scripts/install-gentle-ai.mjs",
 		"test": "node scripts/run-test-suite.mjs",
 		"test:harness": "node --experimental-strip-types tests/runtime-harness.mjs",
@@ -75,7 +74,7 @@
 		"@heyhuynhgiabuu/pi-pretty": "0.6.27"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.99.1",
+		"@earendil-works/pi-coding-agent": ">=1.2.0",
 		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
@@ -92,9 +91,9 @@
 		}
 	},
 	"devDependencies": {
-		"@earendil-works/pi-coding-agent": ">=1.0.0",
-		"@earendil-works/pi-ai": ">=1.0.0",
-		"@earendil-works/pi-tui": ">=1.0.0",
+		"@earendil-works/pi-coding-agent": ">=1.2.0",
+		"@earendil-works/pi-ai": ">=1.2.0",
+		"@earendil-works/pi-tui": ">=1.2.0",
 		"@types/node": "^24.13.3",
 		"typescript": "^5.9.3"
 	},