gentle-pi 4.0.0 → 4.1.0

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 } : {}) };
 }
 
@@ -240,6 +265,7 @@ export function todoPromptBlock(state: TodoState, stale: number): string | undef
 	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;
 }
@@ -253,18 +279,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 +306,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 +320,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 +334,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 };
 }
 

package/lib/status-timing-diagnostics.ts

@@ -0,0 +1,201 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { ExtensionContext, ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { TSchema } from "typebox";
+
+const MAX_STATUSES = 8;
+const MAX_ACTIVE_OBSERVATIONS = 8;
+type Outcome = { kind: "success" | "cli_error" | "native_failure" | "unknown"; code?: string; phase?: string; mutation_outcome?: string; retry_safe?: boolean; next_action?: string };
+interface StatusSample {
+	timeout_ms: number;
+	total_ms: number;
+	resolution_ms: number;
+	adapter_ms: number;
+	decode_ms: number;
+	outcome: Outcome;
+}
+interface Summary {
+	schema: "gentle-pi.status-timing/v1";
+	host_total_ms: number;
+	dispatch_ms: number;
+	sidebar_ms: number;
+	completion_ms: number;
+	truncated: boolean;
+	clock_unavailable?: true;
+	statuses: StatusSample[];
+}
+interface HostObservation {
+	clock: () => number;
+	current: () => boolean;
+	claim: () => boolean;
+	claimed: boolean;
+	started: number;
+	lastNativeEnd: number;
+	summary: Summary;
+}
+interface NativeObservation { host: HostObservation; sample: StatusSample; }
+const hostScope = new AsyncLocalStorage<HostObservation>();
+const nativeScope = new AsyncLocalStorage<NativeObservation>();
+
+// Observer failures must never replace the operation's result or exception.
+function safely<T>(run: () => T): T | undefined {
+	try { return run(); } catch { return undefined; }
+}
+function now(host: HostObservation): number {
+	const value = safely(host.clock);
+	if (value !== undefined && Number.isFinite(value) && value >= 0) return value;
+	host.summary.clock_unavailable = true;
+	return 0;
+}
+function elapsed(start: number, end: number): number { return Math.max(0, end - start); }
+
+// Failure/v2 codes and next_action are extensible strings, not safe diagnostic
+// text. Only recognized values enter this summary; no messages or raw envelopes.
+const CLI_CODES = new Set(["unavailable", "timeout", "non-zero", "signal", "unexpected-stderr", "output-limit", "empty-output", "malformed-json", "schema-incompatible", "identity-mismatch", "version-incompatible", "cancelled", "package-local-binary-missing", "unsupported-transition-operation"]);
+const NATIVE_CODES = new Set(["operation_timeout", "invalid_request", "binding_revision_conflict", "internal_error", "cancelled"]);
+function outcome(error: unknown): Outcome {
+	return safely((): Outcome => {
+		if (typeof error !== "object" || error === null) return { kind: "unknown" };
+		const value = error as { name?: unknown; code?: unknown; failureEnvelope?: Record<string, unknown> };
+		if (value.name === "NativeReviewCliError") return { kind: "cli_error", code: typeof value.code === "string" && CLI_CODES.has(value.code) ? value.code : "other" };
+		if (value.name !== "NativeReviewIntegrationError" || !value.failureEnvelope) return { kind: "unknown" };
+		const failure = value.failureEnvelope;
+		const result: Outcome = { kind: "native_failure", code: typeof failure.code === "string" && NATIVE_CODES.has(failure.code) ? failure.code : "other" };
+		if (["preflight", "pre_native", "native_running", "native_committed", "reconciliation"].includes(String(failure.phase))) result.phase = String(failure.phase);
+		if (["not_started", "committed", "unknown"].includes(String(failure.mutationOutcome))) result.mutation_outcome = String(failure.mutationOutcome);
+		if (typeof failure.retrySafe === "boolean") result.retry_safe = failure.retrySafe;
+		if (["stop", "review.status"].includes(String(failure.nextAction))) result.next_action = String(failure.nextAction);
+		return result;
+	}) ?? { kind: "unknown" };
+}
+
+/** The next already-authorized STATUS-bearing tool call consumes the arm. */
+export class StatusTimingDiagnostics {
+	private armed = false;
+	private epoch = 0;
+	private manager: ExtensionContext["sessionManager"] | undefined;
+	private session: string | undefined;
+	private last: Summary | undefined;
+	private readonly active = new Set<HostObservation>();
+	private readonly clock: () => number;
+	constructor(clock = () => performance.now()) { this.clock = clock; }
+
+	reset(ctx?: ExtensionContext): void {
+		this.epoch++;
+		this.armed = false;
+		this.last = undefined;
+		for (const host of this.active) host.summary.statuses.length = 0;
+		this.active.clear();
+		this.manager = ctx?.sessionManager;
+		this.session = safely(() => ctx?.sessionManager.getSessionId());
+	}
+	private matches(ctx: ExtensionContext): boolean {
+		return safely(() => this.manager === ctx.sessionManager && !!this.session && this.session === ctx.sessionManager.getSessionId()) === true;
+	}
+	command(args: string, ctx: ExtensionContext): void {
+		if (!this.matches(ctx)) this.reset(ctx);
+		const action = args.trim() || "show";
+		if (action === "enable") {
+			this.reset(ctx);
+			this.armed = !!this.session;
+			ctx.ui.notify(this.armed
+				? "STATUS timing armed for the next separately authorized STATUS-bearing tool call. No STATUS is invoked or retried. Use /gentle:status-timing show to consult the completed summary."
+				: "STATUS timing requires a live session.", "info");
+		} else if (action === "disable") {
+			this.reset(ctx);
+			ctx.ui.notify("STATUS timing disabled; in-memory observations cleared.", "info");
+		} else if (action === "show") {
+			ctx.ui.notify(this.last ? JSON.stringify(this.last, null, 2) : `No completed STATUS timing summary. Diagnostic is ${this.armed ? "armed" : "off"}.`, "info");
+		} else {
+			ctx.ui.notify("Unknown /gentle:status-timing sub-action. Use enable, disable, or show.", "warning");
+		}
+	}
+	tool<TParams extends TSchema, TDetails>(definition: ToolDefinition<TParams, TDetails>): ToolDefinition<TParams, TDetails> {
+		return {
+			...definition,
+			execute: async (toolCallId, params, signal, onUpdate, ctx) => {
+				const run = () => definition.execute(toolCallId, params, signal, onUpdate, ctx);
+				if (!this.matches(ctx)) this.reset(ctx);
+				if (!this.armed || this.active.size >= MAX_ACTIVE_OBSERVATIONS) return run();
+				const epoch = this.epoch;
+				const host: HostObservation = {
+					clock: this.clock,
+					current: () => this.epoch === epoch && this.matches(ctx),
+					claim: () => {
+						if (!host.current() || !this.armed) return false;
+						this.armed = false;
+						return true;
+					},
+					claimed: false, started: 0, lastNativeEnd: 0,
+					summary: { schema: "gentle-pi.status-timing/v1", host_total_ms: 0, dispatch_ms: 0, sidebar_ms: 0, completion_ms: 0, truncated: false, statuses: [] },
+				};
+				this.active.add(host);
+				host.started = now(host);
+				return hostScope.run(host, async () => {
+					try { return await run(); }
+					finally {
+						this.active.delete(host);
+						safely(() => {
+							if (!host.claimed || !host.current()) return;
+							const ended = now(host);
+							host.summary.host_total_ms = elapsed(host.started, ended);
+							host.summary.completion_ms = elapsed(host.lastNativeEnd, ended);
+							this.last = host.summary;
+						});
+					}
+				});
+			},
+		};
+	}
+}
+
+/** Only called by the existing STATUS entry points; never invokes one itself. */
+export async function observeNativeStatus<T>(timeoutMs: number, run: () => Promise<T>): Promise<T> {
+	const host = hostScope.getStore();
+	if (!host || !safely(host.current)) return run();
+	if (!host.claimed) {
+		if (!safely(host.claim)) return run();
+		host.claimed = true;
+		host.summary.dispatch_ms = elapsed(host.started, now(host));
+	}
+	const sample: StatusSample = { timeout_ms: timeoutMs, total_ms: 0, resolution_ms: 0, adapter_ms: 0, decode_ms: 0, outcome: { kind: "success" } };
+	if (host.summary.statuses.length < MAX_STATUSES) host.summary.statuses.push(sample);
+	else host.summary.truncated = true;
+	const started = now(host);
+	return nativeScope.run({ host, sample }, async () => {
+		try { return await run(); }
+		catch (error) { safely(() => { sample.outcome = outcome(error); }); throw error; }
+		finally {
+			safely(() => {
+				const ended = now(host);
+				sample.total_ms = elapsed(started, ended);
+				host.lastNativeEnd = ended;
+			});
+		}
+	});
+}
+
+function activeNative(): NativeObservation | undefined {
+	const observation = nativeScope.getStore();
+	return observation && safely(observation.host.current) ? observation : undefined;
+}
+export function measureStatusSync<T>(stage: "resolution" | "decode", run: () => T): T {
+	const observation = activeNative();
+	if (!observation) return run();
+	const started = now(observation.host);
+	try { return run(); }
+	finally { safely(() => { observation.sample[`${stage}_ms`] += elapsed(started, now(observation.host)); }); }
+}
+export async function measureStatusAsync<T>(stage: "adapter", run: () => Promise<T>): Promise<T> {
+	const observation = activeNative();
+	if (!observation) return run();
+	const started = now(observation.host);
+	try { return await run(); }
+	finally { safely(() => { observation.sample[`${stage}_ms`] += elapsed(started, now(observation.host)); }); }
+}
+export function measureStatusSidebar<T>(run: () => T): T {
+	const host = hostScope.getStore();
+	if (!host || !safely(host.current)) return run();
+	const started = now(host);
+	try { return run(); }
+	finally { safely(() => { host.summary.sidebar_ms += elapsed(started, now(host)); }); }
+}

package/lib/telemetry-trigger.ts

@@ -1,4 +1,5 @@
 import { spawn as nodeSpawn } from "node:child_process";
+import { gentleAiIsolationEnv } from "./gentle-ai-binary.ts";
 
 // gentle-ai#4309 owns anonymous usage telemetry end to end: install and
 // heartbeat events, the notice, every kill switch, and the wire contract.
@@ -128,7 +129,8 @@ export function spawnTelemetryTrigger(options: SpawnTelemetryTriggerOptions): Te
 	try {
 		const child = spawnImpl(options.executable, ["telemetry", "trigger", "--json"], {
 			cwd: options.cwd,
-			env: options.env,
+			// S9: a bundled install keeps Gentle AI's telemetry state inside its prefix.
+			env: gentleAiIsolationEnv(options.env),
 			detached: true,
 			windowsHide: true,
 			stdio: "ignore",

package/lib/vim-editor-adapter.ts

@@ -1,12 +1,16 @@
 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 and 1.0.0:
+// Private shape audited against @earendil-works/pi-tui 0.99.1, 0.99.2, 1.0.0 and 1.1.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
 // editor/undo-stack sources; 1.0.0 is a touched-contract audit, not byte identity.
-// Actual 1.0.0 bundled and unbundled tests exercise identity, edit/undo, paste,
+// The 1.1.0 touched-contract audit retains clone-on-push snapshots with the
+// paste registry, cursor resets, layoutText/render geometry and history exit.
+// cancelAutocomplete aborts/debounces requests before clearing its UI;
+// the adapter still calls that host-owned method, never mutating its request state.
+// 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.
 // Never silently adapt another build: undo also owns the paste registry.
@@ -47,7 +51,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"] as const);
+export const AUDITED_PI_EDITOR_VERSIONS = Object.freeze(["0.99.1", "0.99.2", "1.0.0", "1.1.0"] as const);
 export type AuditedPiEditorVersion = (typeof AUDITED_PI_EDITOR_VERSIONS)[number];
 
 export function isAuditedPiEditorVersion(version: unknown): version is AuditedPiEditorVersion {

package/lib/visual-customization-policy.ts

@@ -18,6 +18,8 @@ export interface VisualVisibility {
 	todo: boolean;
 	usageCost: boolean;
 	modelDetails: boolean;
+	/** High-context warning notice; independent from audio notifications. */
+	contextWarning: boolean;
 }
 export interface VisualSettings {
 	statusPlacement: StatusPlacement;
@@ -29,13 +31,13 @@ export const DEFAULT_VISUAL_SETTINGS: VisualSettings = {
 	statusPlacement: STATUS_PLACEMENT.AUTO,
 	headerPlacement: HEADER_PLACEMENT.TOP,
 	density: DENSITY.COMFORTABLE,
-	visibility: { changes: true, rdd: true, agents: true, todo: true, usageCost: true, modelDetails: true },
+	visibility: { changes: true, rdd: true, agents: true, todo: true, usageCost: true, modelDetails: true, contextWarning: true },
 };
 /** Sections row order; `rdd` follows `changes` as the RDD group follows Changes in the Status card. */
-export const VISUAL_SECTION_KEYS = ["changes", "rdd", "agents", "todo", "usageCost", "modelDetails"] as const satisfies readonly (keyof VisualVisibility)[];
-/** Keys added after v1 shipped: stored settings may omit them together, and they default to shown. */
-const ADDED_SECTION_KEYS: readonly (keyof VisualVisibility)[] = ["rdd"];
-const LEGACY_SECTION_KEYS = VISUAL_SECTION_KEYS.filter((key) => !ADDED_SECTION_KEYS.includes(key));
+export const VISUAL_SECTION_KEYS = ["changes", "rdd", "agents", "todo", "usageCost", "modelDetails", "contextWarning"] as const satisfies readonly (keyof VisualVisibility)[];
+/** Keys added after v1 shipped: stored settings may omit them together or one at a time, and they default to shown. */
+const ADDED_SECTION_KEYS: readonly (keyof VisualVisibility)[] = ["rdd", "contextWarning"];
+const BASE_SECTION_KEYS = VISUAL_SECTION_KEYS.filter((key) => !ADDED_SECTION_KEYS.includes(key));
 interface VisualOptions { gentlePiConfigHome?: string }
 export interface VisualResolution {
 	settings: VisualSettings;
@@ -64,13 +66,22 @@ export function isVisualSettings(value: unknown): value is VisualSettings {
 		&& keysMatch(visibility, VISUAL_SECTION_KEYS)
 		&& Object.values(visibility).every((item) => typeof item === "boolean");
 }
-/** Reader-side validation: accepts the current shape and legacy visibility that predates added sections. Writers stay strict. */
+/**
+ * Reader-side validation: accepts the current shape plus every historical one.
+ * Every key must be known, every base key present, and every present value a
+ * boolean; missing added keys (`rdd`, `contextWarning`) then default to shown,
+ * while present values (including `rdd: false`) are preserved. Writers stay strict.
+ */
 export function normalizeVisualSettings(value: unknown): VisualSettings | undefined {
 	if (!record(value) || !record(value.visibility)) return undefined;
 	const visibility = value.visibility;
-	const candidate = keysMatch(visibility, LEGACY_SECTION_KEYS)
-		? { ...value, visibility: Object.fromEntries(VISUAL_SECTION_KEYS.map((key) => [key, visibility[key] ?? true])) }
-		: value;
+	if (!Object.keys(visibility).every((key) => (VISUAL_SECTION_KEYS as readonly string[]).includes(key))) return undefined;
+	if (!BASE_SECTION_KEYS.every((key) => Object.hasOwn(visibility, key))) return undefined;
+	// A key that is present is authoritative: only a missing added key may default to shown.
+	if (!Object.keys(visibility).every((key) => typeof visibility[key] === "boolean")) return undefined;
+	const candidate = keysMatch(visibility, VISUAL_SECTION_KEYS)
+		? value
+		: { ...value, visibility: Object.fromEntries(VISUAL_SECTION_KEYS.map((key) => [key, visibility[key] ?? true])) };
 	return isVisualSettings(candidate) ? candidate : undefined;
 }
 export function parseVisualSettingsFile(raw: string): VisualSettings | undefined {