gentle-pi 2.6.4 → 3.0.0

package/extensions/gentle-shell.ts

@@ -1,20 +1,26 @@
 import { CustomEditor, keyHint, type ExtensionAPI, type ExtensionContext, type KeybindingsManager } from "@earendil-works/pi-coding-agent";
 import type { EditorTheme, TUI } from "@earendil-works/pi-tui";
 import { execFile, spawnSync } from "node:child_process";
-import { readFile } from "node:fs/promises";
+import { statSync } from "node:fs";
+import { profilesFilePath, readProfilesFileResult } from "../lib/agent-profiles.ts";
 import * as os from "node:os";
 import { join } from "node:path";
 import { renderShellBar, renderShellSidebarBar, shellEnabled, type ShellBarModel, type ShellBarTheme } from "../lib/shell-bar.ts";
-import { CHANGE_STATUS, WorktreeChangesTracker, renderChangesWidget, type ChangedFile, type ChangesModel, type GitRunner, type LineCounter, type WorktreeChanges } from "../lib/shell-changes.ts";
+import { CHANGE_STATUS, renderChangesWidget, type ChangedFile, type ChangesModel, type GitRunner, type WorktreeChanges } from "../lib/shell-changes.ts";
 import { WorktreeChangesView } from "../lib/shell-changes-view.ts";
-import { SessionWorktreeRegistry, SESSION_WORKTREE_CHANGED, resolveSessionWorktree, toolWorktreePath, worktreeGitEnvironment, type WorktreeResolver } from "../lib/session-worktree-registry.ts";
+import { SessionWorktreeRegistry, resolveSessionWorktree, worktreeGitEnvironment, type WorktreeResolver } from "../lib/session-worktree-registry.ts";
 import { CARD_TONE, renderCard, type Card, type CardTheme } from "../lib/shell-card.ts";
+import { CommandPalette, commandsKey, type CommandPaletteResult } from "../lib/command-palette.ts";
+import { buildCommandPaletteGroups } from "../lib/command-palette-catalog.ts";
+import { agentsViewKey } from "../lib/agents-keys.ts";
 import { GentleAiDevBinaryOverrideError, resolveGentleAiDevBinaryOverride } from "../lib/gentle-ai-binary.ts";
-import { framePromptLines, PROMPT_HINT, PROMPT_STATE, withPromptHint, type PromptState } from "../lib/shell-prompt.ts";
+import { framePromptLines, PROMPT_HINT, PROMPT_STATE, SHELL_PULSE_MS, withPromptHint, type PromptState } from "../lib/shell-prompt.ts";
 import { accountIdFromToken, CODEX_PROVIDER, CODEX_USAGE_URL, parseCodexUsage, parseUsageHeaders, UsageStore, type ProviderUsage } from "../lib/shell-usage.ts";
 import { UsageView } from "../lib/shell-usage-view.ts";
 import { sidebarPart } from "../lib/shell-sidebar.ts";
 import { installSidebar, invalidateSidebar } from "../lib/shell-sidebar-layout.ts";
+import { SessionChanges, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+import { installSessionChangeCapture } from "../lib/session-change-capture.ts";
 
 // Gentle Shell: the visual layer gentle-pi puts on top of pi. It installs the
 // status bar, the petal prompt, the working-tree changes widget and overlay,
@@ -39,6 +45,7 @@ interface ShellBarComponent {
 }
 
 interface BuildOptions {
+	profile?: string;
 	home?: string;
 	dirty?: number;
 	usage?: ProviderUsage;
@@ -47,6 +54,7 @@ interface BuildOptions {
 export type DevBinaryNotice = { state: "active"; path: string; sha256: string } | { state: "invalid"; reason: string };
 
 export interface ShellDeps {
+	activeProfile(): string | undefined;
 	fetch: typeof fetch;
 	now(): number;
 	devBinary(): DevBinaryNotice | undefined;
@@ -54,6 +62,31 @@ export interface ShellDeps {
 	gitRunner(cwd: string): GitRunner;
 }
 
+// The rail digest runs every frame. Cache parsing by file identity and metadata,
+// not just mtime: profile writes replace the store atomically. Keep the cache
+// local to this shell instance and recheck on the next frame after panel edits.
+export function createActiveProfileReader(env: NodeJS.ProcessEnv = process.env): () => string | undefined {
+	const path = profilesFilePath(env.GENTLE_PI_CONFIG_HOME ?? join(os.homedir(), ".pi", "gentle-ai"));
+	let fingerprint: string | undefined;
+	let name: string | undefined;
+	return () => {
+		try {
+			const stat = statSync(path, { bigint: true });
+			const next = `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
+			if (next !== fingerprint) {
+				const result = readProfilesFileResult(path);
+				name = result.status === "valid" ? result.file.active : undefined;
+				fingerprint = next;
+			}
+			return name;
+		} catch {
+			fingerprint = undefined;
+			name = undefined;
+			return undefined;
+		}
+	};
+}
+
 function ambientDevBinary(): DevBinaryNotice | undefined {
 	try {
 		const override = resolveGentleAiDevBinaryOverride();
@@ -64,7 +97,7 @@ function ambientDevBinary(): DevBinaryNotice | undefined {
 	}
 }
 
-const defaultShellDeps: ShellDeps = { fetch: (...args) => globalThis.fetch(...args), now: () => Date.now(), devBinary: ambientDevBinary, resolveWorktree: resolveSessionWorktree, gitRunner: shellGitRunner };
+const defaultShellDeps: Omit<ShellDeps, "activeProfile"> = { fetch: (...args) => globalThis.fetch(...args), now: () => Date.now(), devBinary: ambientDevBinary, resolveWorktree: resolveSessionWorktree, gitRunner: shellGitRunner };
 
 interface AssistantUsageEntry {
 	type: string;
@@ -104,6 +137,7 @@ export function buildShellBarModel(
 		.map(([, text]) => text);
 	return {
 		cwd: shortenHome(ctx.sessionManager.getCwd(), home),
+		profile: options.profile,
 		branch: footerData.getGitBranch(),
 		dirty: options.dirty,
 		sessionName: ctx.sessionManager.getSessionName(),
@@ -151,8 +185,6 @@ interface PromptEditorDeps {
 
 const PROMPT_FRAME_ROLE = "border";
 
-const PETAL_PULSE_MS = 160;
-
 export class GentlePromptEditor extends CustomEditor {
 	private promptState: PromptState = PROMPT_STATE.IDLE;
 	private tick = 0;
@@ -171,7 +203,7 @@ export class GentlePromptEditor extends CustomEditor {
 			this.pulse = setInterval(() => {
 				this.tick += 1;
 				this.deps.requestRender();
-			}, PETAL_PULSE_MS);
+			}, SHELL_PULSE_MS);
 			this.pulse.unref();
 		}
 		this.deps.requestRender();
@@ -203,9 +235,14 @@ export class GentlePromptEditor extends CustomEditor {
 	}
 }
 
-function installPrompt(ctx: ExtensionContext, onCreated: (prompt: GentlePromptEditor) => void): void {
-	if (ctx.ui.getEditorComponent()) return;
-	ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+// Stable across extension module reloads; never infer ownership from a name.
+const PROMPT_OWNER = Symbol.for("gentle-pi.prompt-owner");
+type PromptFactory = NonNullable<ReturnType<ExtensionContext["ui"]["getEditorComponent"]>> & { [PROMPT_OWNER]?: boolean };
+
+function installPrompt(ctx: ExtensionContext, onCreated: (prompt: GentlePromptEditor) => void): boolean {
+	const previous = ctx.ui.getEditorComponent() as PromptFactory | undefined;
+	if (previous && !previous[PROMPT_OWNER]) return false;
+	const factory: PromptFactory = (tui, theme, keybindings) => {
 		const prompt = new GentlePromptEditor(tui, theme, keybindings, {
 			fg: (color, text) => ctx.ui.theme.fg(color as Parameters<typeof ctx.ui.theme.fg>[0], text),
 			bold: (text) => ctx.ui.theme.bold(text),
@@ -214,15 +251,18 @@ function installPrompt(ctx: ExtensionContext, onCreated: (prompt: GentlePromptEd
 		});
 		onCreated(prompt);
 		return prompt;
-	});
+	};
+	factory[PROMPT_OWNER] = true;
+	ctx.ui.setEditorComponent(factory);
+	return true;
 }
 
 const CHANGES_WIDGET_KEY = "gentle-shell-changes";
 const CHANGES_COMMAND_NAME = "gentle:changes";
 const CHANGES_SHORTCUT_DEFAULT = "alt+g";
 const CHANGES_POLL_DEFAULT_MS = 2000;
-const CHANGES_WATCH_DEFAULT_MS = 5000;
 const GIT_TIMEOUT_MS = 5000;
+const COMMANDS_COMMAND_NAME = "gentle:commands";
 const OVERLAY_HEIGHT_RATIO = 0.8;
 const OVERLAY_MIN_ROWS = 8;
 
@@ -246,14 +286,6 @@ export function shellGitRunner(cwd: string, env: NodeJS.ProcessEnv = process.env
 	});
 }
 
-function lineCounter(cwd: string): LineCounter {
-	return async (path: string) => {
-		const text = await readFile(join(cwd, path), "utf8");
-		if (text.length === 0) return 0;
-		return text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
-	};
-}
-
 export async function loadFileDiff(git: GitRunner, file: ChangedFile): Promise<string> {
 	const args = file.status === CHANGE_STATUS.UNTRACKED ? ["diff", "--no-index", "--", "/dev/null", file.path] : ["diff", "HEAD", "--", file.path];
 	const result = await git(args);
@@ -295,28 +327,19 @@ function changesPollMs(env: NodeJS.ProcessEnv): number {
 	return positiveMs(env.GENTLE_PI_SHELL_CHANGES_POLL_MS, CHANGES_POLL_DEFAULT_MS);
 }
 
-// Background watch: the widget and the bar follow edits made outside pi.
-// 0 or "off" disables it; tool events still refresh.
-function changesWatchMs(env: NodeJS.ProcessEnv): number | undefined {
-	const value = env.GENTLE_PI_SHELL_CHANGES_WATCH_MS?.trim().toLowerCase();
-	if (value === "0" || value === "off") return undefined;
-	return positiveMs(value, CHANGES_WATCH_DEFAULT_MS);
-}
-
 function changesFingerprint(model: ChangesModel): string {
-	return model.files.map((file) => `${file.path}:${file.status}:${file.added}:${file.deleted}`).join("|");
+	return [model.notice ?? "", ...model.files.map((file) => `${file.path}:${file.status}:${file.added}:${file.deleted}:${file.diffRevision ?? ""}:${file.countsUnavailable ?? ""}`)].join("|");
 }
 
 interface OverlayDeps {
-	git(root: string): GitRunner;
+	loadDiff(root: string, file: ChangedFile): string;
 	worktrees(): WorktreeChanges[];
 	refresh(): Promise<ChangesModel>;
 	apply(ctx: ExtensionContext, model: ChangesModel): void;
 	pollMs: number;
 }
 
-// While the overlay is open, git is polled so edits made outside pi (nvim,
-// another agent, a git checkout) show up without reopening it.
+// Refresh only the captured session model. Never read live files or Git here.
 async function showChangesOverlay(ctx: ExtensionContext, deps: OverlayDeps): Promise<void> {
 	let host: ExternalEditorHost | undefined;
 	let view: WorktreeChangesView | undefined;
@@ -334,7 +357,7 @@ async function showChangesOverlay(ctx: ExtensionContext, deps: OverlayDeps): Pro
 				view = new WorktreeChangesView(deps.worktrees(), {
 					theme,
 					rows: () => Math.max(OVERLAY_MIN_ROWS, Math.floor(tui.terminal.rows * OVERLAY_HEIGHT_RATIO)),
-					loadDiff: (root, file) => loadFileDiff(deps.git(root), file),
+					loadDiff: (root, file) => Promise.resolve(deps.loadDiff(root, file)),
 					onOpen: (root, file) => done({ root, file }),
 					onRefresh: () => void refresh(),
 					onClose: () => done(null),
@@ -353,6 +376,29 @@ async function showChangesOverlay(ctx: ExtensionContext, deps: OverlayDeps): Pro
 	}
 }
 
+// The command palette is a curated, grouped menu (Configuration, Session,
+// Diagnostics, SDD, Skills), not a raw listing of every registered
+// extension command: buildCommandPaletteGroups keeps only the catalog
+// entries that are actually registered, so a missing extension never shows
+// a dead row. Selecting an entry runs it exactly as if the user had typed
+// the underlying slash command.
+async function showCommandPalette(pi: ExtensionAPI, ctx: ExtensionContext, env: NodeJS.ProcessEnv): Promise<void> {
+	if (!ctx.hasUI) return;
+	const groups = buildCommandPaletteGroups(pi.getCommands(), {
+		"gentle:changes": changesShortcut(env),
+		"gentle:agents": agentsViewKey(env),
+	});
+	if (groups.length === 0) {
+		ctx.ui.notify("No Gentle commands are registered.", "info");
+		return;
+	}
+	const result = await ctx.ui.custom<CommandPaletteResult>(
+		(tui, theme, _keybindings, done) => new CommandPalette(groups, done, theme, () => Math.max(0, tui.terminal.rows)),
+		{ overlay: true, overlayOptions: { anchor: "center", width: "70%", minWidth: 60, maxHeight: "85%" } },
+	);
+	if (result?.type === "run") pi.sendUserMessage(`/${result.name}`, { expandPromptTemplates: true });
+}
+
 function showChanges(ctx: ExtensionContext, model: ChangesModel): void {
 	if (model.files.length === 0) {
 		ctx.ui.setWidget(CHANGES_WIDGET_KEY, undefined);
@@ -365,20 +411,6 @@ function showChanges(ctx: ExtensionContext, model: ChangesModel): void {
 				return renderChangesWidget(model, theme, width);
 			},
 			invalidate() {},
-		}, {
-			render(width: number) {
-				const noun = model.files.length === 1 ? "file" : "files";
-				return renderCard({
-					title: "Changes",
-					tone: CARD_TONE.INFO,
-					body: [
-						`${model.files.length} ${noun} · ${theme.fg("success", `+${model.added}`)} ${theme.fg("error", `−${model.deleted}`)}`,
-						"",
-						theme.fg("muted", `/${CHANGES_COMMAND_NAME}`),
-					],
-				}, theme, width, { expanded: true });
-			},
-			invalidate() {},
 		}),
 		{ placement: "belowEditor" },
 	);
@@ -451,8 +483,9 @@ export async function fetchCodexUsage(token: string | undefined, fetchFn: typeof
 }
 
 export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = process.env, overrides: Partial<ShellDeps> = {}): void {
+	installSessionChangeCapture(pi, env, overrides.resolveWorktree ?? resolveSessionWorktree);
 	if (!shellEnabled(env)) return;
-	const deps: ShellDeps = { ...defaultShellDeps, ...overrides };
+	const deps: ShellDeps = { ...defaultShellDeps, activeProfile: createActiveProfileReader(env), ...overrides };
 	const usage = new UsageStore();
 	let renderHost: ShellRenderHost | undefined;
 	let usageFetchedAt = 0;
@@ -500,11 +533,9 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		},
 	});
 	let prompt: GentlePromptEditor | undefined;
-	let changes: WorktreeChangesTracker | undefined;
+	let changes: SessionChanges | undefined;
 	let registry: SessionWorktreeRegistry | undefined;
 	let currentContext: ExtensionContext | undefined;
-	const pendingTools = new Map<string, { sessionId: string; path?: string }>();
-	let watch: NodeJS.Timeout | undefined;
 	let shown = "";
 	const applyChanges = (ctx: ExtensionContext, model: ChangesModel) => {
 		const fingerprint = changesFingerprint(model);
@@ -515,22 +546,21 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 	const refreshChanges = async (ctx: ExtensionContext) => {
 		const tracker = changes;
 		if (!tracker || !ctx.hasUI || registry?.sessionId !== ctx.sessionManager.getSessionId()) return;
+		tracker.restore(ctx.sessionManager.getEntries());
 		const model = await tracker.refresh();
 		if (changes === tracker) applyChanges(ctx, model);
 	};
-	const stopWatch = () => {
-		if (watch) clearInterval(watch);
-		watch = undefined;
-	};
-	const unsubscribeWorktrees = pi.events.on(SESSION_WORKTREE_CHANGED, (data) => {
+	const unsubscribeWorktrees = pi.events.on(SESSION_CHANGE_EVENT, (data) => {
 		if (!currentContext || !registry || (data as { sessionId?: string } | undefined)?.sessionId !== registry.sessionId) return;
+		const notice = (data as { notice?: string } | undefined)?.notice;
+		if (notice) { if (changes) changes.notice = notice; currentContext.ui.notify(notice, "warning"); }
 		void refreshChanges(currentContext);
 	});
 	pi.registerTool({
 		name: "session_worktree_register",
 		renderShell: "self",
 		label: "Register session worktree",
-		description: "Register a worktree used by this session, including earlier work or opaque shell use. Only the same Git clone is accepted. Shows ALL dirty files in that root, including preexisting and untracked files; never infers roots from shell commands or prose.",
+		description: "Register a worktree in the same Git clone for session coordination. Registration does not attribute file changes; Changes shows captured write/edit operations only.",
 		parameters: { type: "object", required: ["path"], additionalProperties: false, properties: { path: { type: "string", description: "Worktree path to include in this session." } } } as never,
 		async execute(_id, params, _signal, _onUpdate, ctx) {
 			if (!registry || registry.sessionId !== ctx.sessionManager.getSessionId()) throw new Error("No active session worktree registry.");
@@ -540,16 +570,13 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		},
 	});
 	pi.on("session_start", async (_event, ctx) => {
-		stopWatch();
 		registry?.close();
-		pendingTools.clear();
 		currentContext = ctx;
 		changes = undefined;
 		registry = new SessionWorktreeRegistry(pi, ctx.sessionManager, ctx.cwd, deps.resolveWorktree);
 		registry.start();
-		const sessionRegistry = registry;
 		if (!ctx.hasUI) return;
-		changes = new WorktreeChangesTracker(deps.gitRunner(ctx.cwd), deps.gitRunner, lineCounter, () => sessionRegistry.roots());
+		changes = new SessionChanges(ctx.sessionManager.getSessionId(), ctx.sessionManager.getEntries());
 		const tracker = changes;
 		ctx.ui.setFooter((tui, theme, footerData) => {
 			renderHost = { requestRender: () => tui.requestRender(), invalidateSidebar: () => invalidateSidebar(tui) };
@@ -558,7 +585,10 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 			// part for: model, effort, context, cost, session name and extension
 			// statuses. The digest is what keeps the fullscreen memo honest, and it
 			// rebuilds the model exactly as the narrow bottom bar does every frame.
-			const footerModel = () => buildShellBarModel(pi, ctx, footerData, { dirty: tracker.model.files.length, usage: usage.get(ctx.model?.provider ?? "") });
+			const footerModel = (): ShellBarModel => ({
+				...buildShellBarModel(pi, ctx, footerData, { dirty: tracker.model.files.length, usage: usage.get(ctx.model?.provider ?? ""), profile: deps.activeProfile() }),
+				changes: { files: tracker.model.files.length, added: tracker.model.added, deleted: tracker.model.deleted, notice: tracker.model.notice },
+			});
 			const part = sidebarPart(tui, "footer", bottom, {
 				digest: () => JSON.stringify(footerModel()),
 				render: (width) => renderShellSidebarBar(footerModel(), theme, width),
@@ -568,11 +598,13 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 			return { ...part, dispose() { uninstall(); part.dispose(); } };
 		});
 		void refreshUsage(ctx, true);
-		installPrompt(ctx, (created) => {
+		const ownsPrompt = installPrompt(ctx, (created) => {
+			prompt?.dispose();
 			prompt = created;
 		});
-		// The petal already says the agent is working; pi's own "Working" row would say it twice.
-		ctx.ui.setWorkingVisible(false);
+		// Hide native feedback only when our petal replaces it. Native transcript
+		// thinking blocks remain Pi-owned; this changes only the supported loader UI.
+		if (ownsPrompt) ctx.ui.setWorkingVisible(false);
 		const notice = deps.devBinary();
 		ctx.ui.setWidget(
 			DEV_BINARY_WIDGET_KEY,
@@ -580,24 +612,21 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 				? (_tui, theme) => spaced(cardComponent(devBinaryCard(notice), theme, { expanded: true }))
 				: undefined,
 		);
-		await tracker.start();
 		if (changes !== tracker) return;
 		shown = "";
 		applyChanges(ctx, tracker.model);
-		stopWatch();
-		const watchMs = changesWatchMs(env);
-		if (watchMs) {
-			watch = setInterval(() => void refreshChanges(ctx), watchMs);
-			watch.unref();
-		}
 	});
-	pi.on("session_shutdown", () => {
-		stopWatch();
+	pi.on("session_shutdown", (_event, ctx) => {
+		prompt?.dispose();
+		prompt = undefined;
+		if ((ctx.ui.getEditorComponent() as PromptFactory | undefined)?.[PROMPT_OWNER]) {
+			ctx.ui.setEditorComponent(undefined);
+			ctx.ui.setWorkingVisible(true);
+		}
 		registry?.close();
 		registry = undefined;
 		changes = undefined;
 		currentContext = undefined;
-		pendingTools.clear();
 		unsubscribeWorktrees();
 	});
 	const openChanges = async (ctx: ExtensionContext) => {
@@ -605,46 +634,43 @@ export default function gentleShell(pi: ExtensionAPI, env: NodeJS.ProcessEnv = p
 		const tracker = changes;
 		const model = await tracker.refresh();
 		if (model.files.length === 0) {
-			ctx.ui.notify("No changes in the working tree.", "info");
+			ctx.ui.notify("No captured agent changes. Only successful write/edit operations from this session and its subagents are shown; shell changes are not attributed.", "info");
 			return;
 		}
-		await showChangesOverlay(ctx, { git: deps.gitRunner, worktrees: () => tracker.worktrees, refresh: () => tracker.refresh(), apply: applyChanges, pollMs: changesPollMs(env) });
+		await showChangesOverlay(ctx, { loadDiff: (root, file) => tracker.loadDiff(root, file), worktrees: () => tracker.worktrees, refresh: () => tracker.refresh(), apply: applyChanges, pollMs: changesPollMs(env) });
 	};
 	pi.registerCommand(CHANGES_COMMAND_NAME, {
-		description: "Browse this session's registered dirty worktrees and their changes against HEAD. Press o on a file to open $EDITOR.",
+		description: "Browse captured write/edit changes from this agent session and its subagents, excluding preexisting and external edits. Shell changes are not attributed. Press o to open $EDITOR.",
 		handler: async (_args, ctx) => openChanges(ctx),
 	});
 	const shortcut = changesShortcut(env);
 	if (shortcut) {
 		pi.registerShortcut(shortcut as Parameters<ExtensionAPI["registerShortcut"]>[0], {
-			description: "Open the working tree changes",
+			description: "Open captured agent session changes",
 			handler: async (ctx) => openChanges(ctx),
 		});
 	}
+	pi.registerCommand(COMMANDS_COMMAND_NAME, {
+		description: "Open the command palette: a curated, grouped menu of Gentle commands.",
+		handler: async (_args, ctx) => showCommandPalette(pi, ctx, env),
+	});
+	const commandsShortcut = commandsKey(env);
+	if (commandsShortcut) {
+		pi.registerShortcut(commandsShortcut as Parameters<ExtensionAPI["registerShortcut"]>[0], {
+			description: "Open the command palette",
+			handler: async (ctx) => showCommandPalette(pi, ctx, env),
+		});
+	}
 	pi.on("agent_start", (_event, ctx) => {
 		prompt?.setWorking(true);
 		// The dev-binary card is a startup notice: it leaves with the first prompt.
 		if (ctx.hasUI) ctx.ui.setWidget(DEV_BINARY_WIDGET_KEY, undefined);
 	});
-	pi.on("agent_end", async (_event, ctx) => {
+	pi.on("agent_settled", () => {
 		prompt?.setWorking(false);
-		await refreshChanges(ctx);
-		void refreshUsage(ctx, false);
-	});
-	pi.on("tool_execution_start", (event, ctx) => {
-		pendingTools.set(event.toolCallId, { sessionId: ctx.sessionManager.getSessionId() });
 	});
-	pi.on("tool_result", (event, ctx) => {
-		const pending = pendingTools.get(event.toolCallId);
-		if (pending?.sessionId === ctx.sessionManager.getSessionId()) pending.path = toolWorktreePath(event.toolName, event.input);
-	});
-	pi.on("tool_execution_end", async (event, ctx) => {
-		const pending = pendingTools.get(event.toolCallId);
-		pendingTools.delete(event.toolCallId);
-		if (!event.isError && pending?.path !== undefined && pending.sessionId === registry?.sessionId && pending.sessionId === ctx.sessionManager.getSessionId()) {
-			try { registry.register(pending.path, `tool:${event.toolName}`); }
-			catch { /* Non-project paths and missing roots do not expand the registry. */ }
-		}
+	pi.on("agent_end", async (_event, ctx) => {
 		await refreshChanges(ctx);
+		void refreshUsage(ctx, false);
 	});
 }

package/extensions/pi-pretty.ts

@@ -1,29 +1,78 @@
-import { realpathSync } from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { shellEnabled } from "../lib/shell-bar.ts";
 import {
 	mergeDisabledTools,
 	PI_PRETTY_SUPPRESSED_TOOL_NAMES,
 	quietToolsEnabled,
 } from "../lib/quiet-tools-config.ts";
 
-const packageJsonPath = realpathSync(
-	fileURLToPath(new URL("../package.json", import.meta.url)),
-);
-const requireFromRealPackage = createRequire(packageJsonPath);
-const piPrettyModule = requireFromRealPackage("@heyhuynhgiabuu/pi-pretty");
+type PiPrettyExtension = (pi: unknown, deps?: unknown) => unknown;
 
-const piPrettyExtension =
-	typeof piPrettyModule === "function"
-		? piPrettyModule
-		: piPrettyModule.default;
+let piPrettyExtensionPromise: Promise<PiPrettyExtension> | undefined;
 
-export default async function gentlePiPrettyExtension(pi: unknown, deps?: unknown): Promise<unknown> {
+async function loadPiPrettyExtension(): Promise<PiPrettyExtension> {
+	return piPrettyExtensionPromise ??= import("@heyhuynhgiabuu/pi-pretty").then(
+		(piPrettyModule) => {
+			const moduleCandidate: unknown = piPrettyModule;
+			const extension =
+				typeof moduleCandidate === "function"
+					? moduleCandidate
+					: piPrettyModule.default;
+			if (typeof extension !== "function") {
+				throw new TypeError("pi-pretty must export an extension function");
+			}
+			return extension as PiPrettyExtension;
+		},
+	);
+}
+
+export default async function gentlePiPrettyExtension(
+	pi: unknown,
+	deps?: unknown,
+	bundled?: PiPrettyExtension,
+	env: NodeJS.ProcessEnv = process.env,
+): Promise<unknown> {
 	if (quietToolsEnabled()) {
 		process.env.PRETTY_DISABLE_TOOLS = mergeDisabledTools(
 			process.env.PRETTY_DISABLE_TOOLS,
 			PI_PRETTY_SUPPRESSED_TOOL_NAMES,
 		);
 	}
-	return piPrettyExtension(pi, deps);
+	const extension = bundled ?? await loadPiPrettyExtension();
+	if (!shellEnabled(env)) return extension(pi, deps);
+	const api = pi as ExtensionAPI;
+	// Scope interception to this bundled dependency, never to the shared host UI.
+	// Its tools/autocomplete/status APIs pass through; prompt ownership stays with
+	// Gentle Shell (or a genuine third-party editor). This also blocks stale restores.
+	const owned = new Set(["setEditorComponent", "setWorkingIndicator", "setWorkingMessage", "setWorkingVisible"]);
+	const delegated = new Proxy(api, {
+		get(target, key) {
+			if (key !== "on") return Reflect.get(target, key);
+			return (event: Parameters<ExtensionAPI["on"]>[0], handler: (event: unknown, ctx: ExtensionContext) => unknown) => {
+				api.on(event, ((event: unknown, ctx: ExtensionContext) => {
+					if (ctx.mode !== "tui") return handler(event, ctx);
+					const ui = new Proxy(ctx.ui, {
+						get(target, key) {
+							return owned.has(String(key)) ? () => {} : Reflect.get(target, key);
+						},
+					});
+					return handler(event, new Proxy(ctx, { get: (target, key) => key === "ui" ? ui : Reflect.get(target, key) }));
+				}) as never);
+			};
+		},
+	});
+	const result = await extension(delegated, deps);
+	// GentlePromptEditor already carries the live working state in its frame.
+	// Hide Pi's separate loader row to avoid repeating Thinking above the input;
+	// transcript thinking blocks remain untouched as historical reasoning markers.
+	api.on("session_start", (_event, ctx) => {
+		if (ctx.mode === "tui") ctx.ui.setWorkingVisible(false);
+	});
+	api.on("session_shutdown", (_event, ctx) => {
+		if (ctx.mode !== "tui") return;
+		ctx.ui.setWorkingVisible(true);
+		ctx.ui.setWorkingIndicator();
+		ctx.ui.setWorkingMessage();
+	});
+	return result;
 }

package/extensions/quiet-tools.ts

@@ -238,7 +238,7 @@ function shellTokens(command: string): ShellTokenization {
 function isAssignment(token: string): boolean {
 	return /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
 }
-const SDD_ATTEMPT_VERBS = new Set(["acquire", "settle", "grant"]);
+const SDD_ATTEMPT_VERBS = new Set(["grant"]);
 
 const REVIEW_DIRECT_OPERATIONS = new Set([
 	"capabilities",
@@ -354,7 +354,6 @@ function gentleAiOperationPathFrom(tokens: string[]): string {
 	if (tokens[0] === "sdd-attempt") {
 		const verb = tokens[1] ?? "";
 		if (!SDD_ATTEMPT_VERBS.has(verb)) return "sdd attempt";
-		if (verb !== "grant") return `sdd attempt ${verb}`;
 		const rootCount = authorizationRootCount(tokens);
 		return rootCount > 0
 			? `sdd attempt grant · ${rootCount} root${rootCount === 1 ? "" : "s"}`

package/extensions/startup-banner.ts

@@ -29,14 +29,14 @@ const BANNER_PALETTES: Record<BannerColor, { rose: [number, number, number]; lab
 };
 
 const TEXT_LOGO = [
-  "                  ▄▄▄▀▀▀▀▀██                                ▄▄▀▄▄           ▄▄█▀▀▀██   ▀▀█▄    ▄▄▄",
-  "              ▄▄█▀▀▒▒▒▒▒▄▄█▀▒                   ▄██     ▄▄█▀█▄█▀▒▒      ▄█▀▀ ▒▒▒▄█▀▀▒   ▄██▒ ▄█▀▒▒▒",
-  "          ▄▄██▀▒▒▒▒▒▄▄▄▀▀▒▒▒▒        ▄▄▄  ▀▀▀▀██▀▀▀▀▀███▀█▄▀▀▒▒▒▒      ██▒▒▒▒▄▄█▀▒▒▒▒▄▄█▀▀▄██▀▒▒▒",
-  "        ▄██▀▒▒▒▒     ▒▒▄▄█ ▄▄▄▀██ ▄▄▄▀▀▀▄  ▄██▀▒▒▒▒▄██▀▀▀▒▄▄███         ▒▒ ▄███▄▄▄█▀▀▀▒▒▄██▀▒▒▒",
-  "       ██▀▒▒▒     ▄▄▄███▀▄██▀▀▀▄▄██▀▀▄█▀▄▄██▀▒▒▒▄▄██▀▒▒▄██▀▀▀▄▄▀▀▀▀▀▀▀▀▀ ▄█▀▀▒▒▒▒▒▒▒▒▒▄██▒▒▒▒",
-  "       ▀█▄▄▄▄▄▀▀▀█▄▄███▄▒▀▀▀▀▀▀▒▀▀▒▒▀▀▀▀▒██▄▄▀▀▀ ▀█▄▀▀▀ ▀▀▀▀▀▒▒▒▒▒▒▒▒▒▒▄██▀▒▒▒       ███▒▒",
-  "        ▒▄▄▄█▀▀▀█▄█▀▀▒▒▒▒ ▒▒▒▒▒▒ ▒▒  ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒        ▀▀▀▒▒▒          ▒▒▒",
-  "     ▄▄▀▀ ▒▒▒▒▄██▀▒▒▒▒                                                 ▒▒▒",
+  "                  ▄▄▄▀▀▀▀▀██                                ▄▄▀▄▄          ▄▄█▀▀▀██   ▄▄▀██               ▄▄▀▄▄   ▄▄▀▄▄",
+  "              ▄▄█▀▀▒▒▒▒▒▄▄█▀▒                   ▄██     ▄▄█▀█▄█▀▒▒       ▄█▀▀▒▒▒▄█▀▒ ▄██▄█▀▒           ▄▄█▀█▄█▀▄▄█▀█▄█▀▒",
+  "          ▄▄██▀▒▒▒▒▒▄▄▄▀▀▒▒▒▒        ▄▄▄  ▀▀▀▀██▀▀▀▀▀███▀█▄▀▀▒▒▒▒      ██▄▄▒▒▒▒▒▒▒ ▄██▀▀▒▒▒          ▄██▀█▄▀▀▄██▀█▄▀▀▒▒▒",
+  "        ▄██▀▒▒▒▒     ▒▒▄▄█ ▄▄▄▀██ ▄▄▄▀▀▀▄  ▄██▀▒▒▒▒▄██▀▀▀▒▄▄███         ▀▀▀██▄▄  ▄██▀▒▄▄▀██   ▄▄▀▀██ ██▀▀▀▒▒▒██▀▀▀▒▒▒",
+  "       ██▀▒▒▒     ▄▄▄███▀▄██▀▀▀▄▄██▀▀▄█▀▄▄██▀▒▒▒▄▄██▀▒▒▄██▀▀▀▄▄      ▄▄     ▀██▄▄██▀▄██▀██▒  ▄██▄▄▀▒ █▀▒▒▒   █▀▒▒▒",
+  "       ▀█▄▄▄▄▄▀▀▀█▄▄███▄▒▀▀▀▀▀▀▒▀▀▒▒▀▀▀▀▒██▄▄▀▀▀ ▀█▄▀▀▀ ▀▀▀▀▀▒▒      ▀█▄▄▄▄█▀▀▒▒▀▀▒▒▀▀▒ ██▄▄▀▀█▄▄▄▄▀▀█▄▄▀▀▀▄▄▀█▄▄▀▀▀",
+  "        ▒▄▄▄█▀▀▀█▄█▀▀▒▒▒▒ ▒▒▒▒▒▒ ▒▒  ▒▒▒▒ ▒▒▒▒▒▒▒ ▒▒▒▒▒▒ ▒▒▒▒▒        ▒▀▀▀▀▒▒▒▒  ▒▒▒▒▒▒ ▒▒▒▒▒ ▒▒▒▒▒▒  ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒",
+  "     ▄▄▀▀ ▒▒▒▒▄██▀▒▒▒▒",
   "   ▄█ ▒▒▒▄▄██▀▀▒▒▒▒",
   "    ▀▀▀▀▀▀▒▒▒▒▒▒",
   "     ▒▒▒▒▒▒",
@@ -183,7 +183,8 @@ function buildLetterSpans(bounds: Span, weights: number[]): Span[] {
 }
 
 const LOGO_BOUNDS = computeLogoBounds(TEXT_LOGO);
-const LETTER_WEIGHTS = [14, 10, 11, 10, 9, 11, 6, 13, 12]; // G E N T L E - P I
+// Variable-width script regions, including the gap before Shell and shadows.
+const LETTER_WEIGHTS = [22, 9, 8, 9, 8, 9, 10, 13, 8, 8, 13]; // G E N T L E S H E L L
 const LETTER_SPANS = buildLetterSpans(LOGO_BOUNDS, LETTER_WEIGHTS);
 
 function letterIndexAtX(x: number): number {

package/lib/agent-home.ts

@@ -6,3 +6,11 @@ import { join } from "node:path";
 export function resolveGentlePiAgentHome(env: NodeJS.ProcessEnv = process.env): string {
 	return env.GENTLE_PI_AGENT_HOME || env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
 }
+
+// The Gentle AI config directory outside `~/.pi/agent`: everything the extension
+// commands own lives here. It is defined once because the launch-time profile pin
+// resolver reads the same profiles store the `/gentle:profiles` panel writes, and
+// two spellings of the override would silently read two different stores.
+export function gentlePiConfigHome(env: NodeJS.ProcessEnv = process.env): string {
+	return env.GENTLE_PI_CONFIG_HOME || join(homedir(), ".pi", "gentle-ai");
+}