gentle-pi 4.2.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-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-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,
@@ -261,13 +276,14 @@ export function replayTodo(entries: readonly unknown[]): TodoState {
 // 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.
+// 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 the last message of each request; it is not repeated here.",
+	"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. */
@@ -275,7 +291,10 @@ export function todoPromptBlock(): string {
 	return TODO_PROMPT_BLOCK;
 }
 
-/** The open-task snapshot delivered as a request-local message; undefined when nothing is open. */
+/** 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}` : ""}`);

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/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.2.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",

package/runtime/gentle-ai-binary.mjs

@@ -15,7 +15,7 @@ import {
 	resolveGentleAiReleaseAsset,
 } from "../scripts/gentle-ai-installer.mjs";
 import { engramPinVersion } from "../scripts/installer-downloads.mjs";
-import { bundledGentlePiConfigHome, bundledPiConfigDir, bundledPiConfigParent, runningBundledPrefix } from "./gentle-shell-bundled.mjs";
+import { bundledPiConfigDir, bundledPiConfigParent, GENTLE_SHELL_CONFIG_HOME_ENV, resolveGentlePiConfigHome, runningBundledPrefix } from "./gentle-shell-bundled.mjs";
 import { fileURLToPath } from "node:url";
 
 export const GENTLE_AI_BINARY_MISSING_CODE = "package-local-binary-missing";
@@ -87,9 +87,11 @@ export function bundledGentleAiPaths(prefix        , platform         = process.
  * (only when the pinned Engram is published), GENTLE_AI_NO_SELF_UPDATE=1 and
  * GENTLE_PI_CONFIG_HOME (the parent of GENTLE_AI_PI_CONFIG_DIR)
  * when this gentle-pi runs from the valid bundled install GENTLE_SHELL_PREFIX
- * names (runningBundledPrefix). Otherwise `env` itself, unchanged: a gentle-pi
- * installed elsewhere (the user's own, started from the agent's shell, which
- * inherits the variable) keeps its own Gentle AI.
+ * names (runningBundledPrefix). In the standalone launcher's isolated home
+ * (#2201) only the config pair, for the folder its marker names. Otherwise
+ * `env` itself, unchanged: a gentle-pi installed elsewhere (the user's own,
+ * started from the agent's shell, which inherits the variable) keeps its own
+ * Gentle AI.
  */
 export function gentleAiIsolationEnv(
 	env                   ,
@@ -97,7 +99,7 @@ export function gentleAiIsolationEnv(
 )                    {
 	const platform = options.platform ?? process.platform;
 	const prefix = runningBundledPrefix(env, { packageRoot: options.packageRoot, platform });
-	if (prefix === undefined) return env;
+	if (prefix === undefined) return standaloneGentleAiEnv(env, platform);
 	const paths = bundledGentleAiPaths(prefix, platform);
 	let engram = false;
 	try {
@@ -126,6 +128,23 @@ export function gentleAiIsolationEnv(
 	};
 }
 
+// #2201: the same config pair as a bundled install, for the folder the
+// standalone launcher's marker names, when it decides the config home
+// (resolveGentlePiConfigHome; an explicit GENTLE_PI_CONFIG_HOME keeps its
+// existing meaning for Gentle AI). Gentle AI's own state stays where it was.
+// The parent is given only for a folder named gentle-ai, the one Gentle AI
+// 4.0.0 appends to it.
+function standaloneGentleAiEnv(env                   , platform        )                    {
+	const marker = env[GENTLE_SHELL_CONFIG_HOME_ENV];
+	if (marker === undefined || resolveGentlePiConfigHome(env, homedir(), { platform }) !== marker) return env;
+	const path = platform === "win32" ? win32 : posix;
+	return {
+		...env,
+		GENTLE_AI_PI_CONFIG_DIR: marker,
+		...(path.basename(marker) === "gentle-ai" ? { GENTLE_PI_CONFIG_HOME: path.dirname(marker) } : {}),
+	};
+}
+
 function sha256(value        )         {
 	return createHash("sha256").update(value).digest("hex");
 }
@@ -137,7 +156,9 @@ function sha256(value        )         {
 //   1. GENTLE_PI_GENTLE_AI_DEV_BINARY (session override, absolute path), then
 //   2. the persistent registration file at
 //      <config home>/dev-binary.json (a bundled prefix's gentle-pi, else
-//      GENTLE_PI_CONFIG_HOME, else ~/.pi/gentle-ai) with the strict
+//      GENTLE_PI_CONFIG_HOME, else ~/.pi/gentle-ai, never the standalone
+//      launcher's marker: the main channel writes it outside any session,
+//      #2201) with the strict
 //      shape {"schema":"gentle-pi.dev-binary/v1","path":"<absolute path>"}.
 //
 // The registration deliberately pins no digest: it is the unpinned field-test
@@ -195,7 +216,7 @@ function ambientDevBinaryEnvironment()                               {
 }
 
 export function gentleAiDevBinaryRegistrationPath(environment                               = ambientDevBinaryEnvironment())         {
-	const configHome = bundledGentlePiConfigHome(environment.env) ?? environment.env.GENTLE_PI_CONFIG_HOME ?? join(environment.home, ".pi", "gentle-ai");
+	const configHome = resolveGentlePiConfigHome(environment.env, environment.home, { launcherMarker: false });
 	return join(configHome, "dev-binary.json");
 }
 

package/runtime/gentle-shell-bundled.mjs

@@ -176,6 +176,29 @@ export function bundledGentlePiConfigHome(env     )                     {
 	return prefix === undefined ? undefined : bundledPiConfigDir(prefix);
 }
 
+// #2201: the standalone launcher gives Pi this variable in its isolated home
+// only, naming the config folder next to the agent dir (standaloneConfigHome:
+// ~/.gentle-shell/gentle-ai by default). It is launcher-owned, never
+// GENTLE_PI_CONFIG_HOME: Gentle AI 4.0.0 reads that one as the parent of its
+// own gentle-ai folder, and the agent's shell would pass it to any gentle-ai.
+export const GENTLE_SHELL_CONFIG_HOME_ENV = "GENTLE_SHELL_CONFIG_HOME";
+
+// gentle-pi's config home, the one rule every reader shares: a bundled
+// prefix's folder, then an explicit GENTLE_PI_CONFIG_HOME, then the launcher's
+// marker (absolute only), then ~/.pi/gentle-ai. Empty values count as unset.
+// `launcherMarker: false` is for install-level state written outside a session
+// (the main channel's channel.json, builds and dev-binary.json): the installer
+// and `gentle-shell upgrade` never see the marker, so their readers ignore it.
+export function resolveGentlePiConfigHome(env     , home        , options                                                  = {})         {
+	const path = pathFor(options.platform ?? process.platform);
+	const bundled = bundledGentlePiConfigHome(env);
+	if (bundled !== undefined) return bundled;
+	if (env.GENTLE_PI_CONFIG_HOME) return env.GENTLE_PI_CONFIG_HOME;
+	const marker = env[GENTLE_SHELL_CONFIG_HOME_ENV];
+	if (options.launcherMarker !== false && marker && path.isAbsolute(marker)) return marker;
+	return path.join(home, ".pi", "gentle-ai");
+}
+
 // The exact Pi of the version (S8): the Pi the version's package.json pins,
 // installed inside the version folder with Pi's own bin entry. Never another Pi.
 export function bundledPi(install                , input                                     )            {
@@ -214,6 +237,8 @@ export function bundledPi(install                , input
 // memory is allowed locally; otherwise the Shell-owned guard, so no provider,
 // whatever loaded it, runs an Engram binary against an unverified store.
 export const ENGRAM_COMPANION_SOURCE = "npm:gentle-engram@0.4.2";
+export const ENGRAM_PRIVATE_REQUIRED_NOTICE = "Engram memory disabled: session-owned servers require a supporting published bundled core and companion. This bundle does not establish both capabilities; it will not fall back to a detached shared server. Install a supporting published bundle and restart Shell. Existing shared services are not stopped or adopted as session-owned.";
+export const ENGRAM_CORE_CHANGED_NOTICE = "Engram memory disabled: the bundled core changed since Shell recorded this store. Install a published bundle supporting migrate-copy, stop every Engram client, retain a complete backup, then run gentle-shell memory migrate --confirm-quiescent. The command verifies and migrates a copy before updating provenance; older bundles refuse safely. Do not edit coreSha256 or delete the original store. Shell remains usable without memory.";
 export const ENGRAM_RECOVERY_NOTICE = "Engram memory disabled: Shell could not verify safe store or server reuse. Matching versions or updating alone do not prove compatibility. Reuse requires a server with verified /compatibility evidence or matching Shell-provisioned store identity. Back up existing Engram data before manual changes; do not delete it or bypass the safety check. Shell rechecks on every launch and remains usable without memory.";
 // `gentle-shell setup` publishes the verified core (ensureEngram) on every run.
 export const ENGRAM_PROVISION_FAILED_NOTICE = "Engram memory disabled for this launch: Shell could not provision a new Engram store identity, so it cannot vouch for that store. Restart Shell to retry. If Shell keeps reporting unknown compatibility and ~/.engram holds only .instance-id files, back it up and remove it, then restart Shell. Shell remains usable without memory.";
@@ -237,7 +262,7 @@ function outdatedServerVersion(version                    )
 // The default endpoint gentle-engram uses without ENGRAM_URL or ENGRAM_PORT.
 export const ENGRAM_DEFAULT_PORT = 7437;
 export const ENGRAM_DEFAULT_URL = `http://127.0.0.1:${ENGRAM_DEFAULT_PORT}`;
-const ENGRAM_SELECTIONS = ["ENGRAM_BIN", "ENGRAM_URL", "ENGRAM_DATA_DIR", "ENGRAM_PORT", "ENGRAM_DATABASE_URL"];
+const ENGRAM_SELECTIONS = ["ENGRAM_BIN", "ENGRAM_URL", "ENGRAM_DATA_DIR", "ENGRAM_PORT", "ENGRAM_SOCKET", "ENGRAM_DATABASE_URL"];
 const HEX32 = /^[a-f0-9]{32}$/;
 
 
@@ -271,7 +296,7 @@ export function classifyEngramStartup(input
 	// Shell's own store, created by this exact core: offline, the provider starts
 	// that core; a running server must be that store and that exact core.
 	if (endpoint.kind === "refused") return { policy: "allow" };
-	if (endpoint.kind === "listening" && endpoint.healthInstanceId === own.instanceId && endpoint.healthVersion === input.coreVersion) return { policy: "allow" };
+	if (endpoint.kind === "listening" && endpoint.healthInstanceId === own.instanceId && endpoint.healthVersion === input.coreVersion) return { policy: "allow", url: ENGRAM_DEFAULT_URL };
 	return unknown;
 }
 
@@ -402,6 +427,11 @@ export function supportsEngramStartupPolicy(metadata                    )
 	return pkg?.name === "gentle-engram" && pkg.engram?.startupPolicy === 1;
 }
 
+export function supportsEngramSessionOwned(metadata                    )          {
+	const pkg = parseJson(metadata);
+	return supportsEngramStartupPolicy(metadata) && pkg?.engram?.sessionOwned === 1;
+}
+
 export function bundledChildEnv(base     , input                                                                                                        )      {
 	const env      = { ...base, PI_SKIP_VERSION_CHECK: "1", [GENTLE_SHELL_PREFIX_ENV]: input.prefix };
 	delete env.GENTLE_SHELL_PI;
@@ -426,6 +456,12 @@ export function bundledChildEnv(base     , input
 	if (memory.url !== undefined) env.ENGRAM_URL = memory.url;
 	const local = memory.policy === "allow" && memory.url === undefined ? input.engram : undefined;
 	env.ENGRAM_BIN = local ?? input.guard;
+	if (local && memory.owned) {
+		env.ENGRAM_SERVER_MODE = "session-owned";
+		delete env.ENGRAM_URL;
+		delete env.ENGRAM_PORT;
+		delete env.ENGRAM_SOCKET;
+	}
 	return env;
 }