one-code-extension 0.3.0 → 0.4.0

package/extensions/doctor/dependencies.ts

@@ -11,11 +11,12 @@
  * providers it depends on a third-party key.
  */
 
-import { accessSync, constants, existsSync } from "node:fs";
-import { delimiter, join } from "node:path";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { whichOnPath } from "../lib/which.ts";
 import type { Api, Model } from "@earendil-works/pi-ai";
 import { getProviderKind } from "pi-web-search/src/api.ts";
-import { INSTALL_HINTS } from "../lsp/install-hints.ts";
+import { installHint, serverInstallHint } from "../lsp/install-hints.ts";
 import { SERVERS } from "../lsp/servers.ts";
 import { typescriptPreflight } from "../lsp/servers.ts";
 import type { McpServer } from "../mcp/config.ts";
@@ -43,30 +44,6 @@ export interface DependencyReport {
 	findings: Finding[];
 }
 
-/** Minimal `which`: the first PATH entry holding an executable of that name. */
-export function whichOnPath(command: string, env: NodeJS.ProcessEnv, platform: string = process.platform): string | undefined {
-	if (!command) return undefined;
-	if (command.includes("/") || command.includes("\\")) return isExecutable(command) ? command : undefined;
-	const extensions = platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
-	for (const dir of (env.PATH ?? "").split(delimiter)) {
-		if (!dir) continue;
-		for (const ext of extensions) {
-			const candidate = join(dir, command + ext);
-			if (isExecutable(candidate)) return candidate;
-		}
-	}
-	return undefined;
-}
-
-function isExecutable(path: string): boolean {
-	try {
-		accessSync(path, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
 /** Languages the working directory plausibly contains, by the LSP table's own root markers. */
 export function projectLanguages(cwd: string): string[] {
 	const seen = new Map<string, string>(); // command → languageId (one per server binary)
@@ -86,9 +63,45 @@ export interface DependencyInput {
 	cwd: string;
 	env: NodeJS.ProcessEnv;
 	platform?: string;
+	/** pi's agent dir; its `bin/` holds the ripgrep pi downloads itself. */
+	agentDir?: string;
 	mcpServers: McpServer[];
 	sessionModel?: Model<Api>;
 	webSearchSettings: WebSearchSettings;
+	/**
+	 * The shell tools as the session resolves them (build.ts, from
+	 * lib/shell-spawn.ts + powershell/policy.ts): which bash, which PowerShell,
+	 * which one is primary, and the startup notices. On Windows this is the
+	 * first thing a user asks the doctor — "which shells did you find?" — and
+	 * the report had no line for it until 2026-09-19 (the Vultr VM session).
+	 */
+	shells?: ShellsInput;
+}
+
+export interface ShellsInput {
+	/** The bash binary the bash tool runs, or undefined when none exists. */
+	bash?: string;
+	/** An ignored CLAUDE_CODE_GIT_BASH_PATH, in the resolver's words. */
+	bashWarning?: string;
+	/** The PowerShell executable the powershell tool would run, or undefined. */
+	powershell?: string;
+	/** From `shellToolPolicy`: the tool is meant to be on (env switch, else Windows). */
+	powershellWanted: boolean;
+	/** From `shellToolPolicy`: a bash is part of this platform's expected shape (not Windows). */
+	bashExpected: boolean;
+	primary: "powershell" | "bash" | "none";
+	notices: string[];
+}
+
+function bashReason(s: ShellsInput): string {
+	if (s.primary === "bash") return "the primary shell tool";
+	if (s.bash) return "the bash tool, alongside PowerShell";
+	return s.bashExpected ? "the bash tool" : "the bash tool (Git for Windows provides one)";
+}
+
+function powershellReason(s: ShellsInput): string {
+	if (!s.powershellWanted) return s.bashExpected ? "the powershell tool (off; CLAUDE_CODE_USE_POWERSHELL_TOOL=1 turns it on with a pwsh on PATH)" : "the powershell tool (off: CLAUDE_CODE_USE_POWERSHELL_TOOL=0)";
+	return s.primary === "powershell" ? "the primary shell tool" : "the powershell tool";
 }
 
 export function checkDependencies(input: DependencyInput): DependencyReport {
@@ -102,8 +115,27 @@ export function checkDependencies(input: DependencyInput): DependencyReport {
 	checks.push({ name: "git", found: !!git, path: git, need: "required", reason: "repository detection, auto mode's recoverability check, worktree isolation", hint: "https://git-scm.com/downloads" });
 	if (!git) findings.push({ level: "warn", text: "git is not on PATH: worktree isolation and auto mode's git-recoverability check are unavailable.", fix: "Install git and make sure it is on the PATH used to launch One Code." });
 
-	const rg = which("rg");
-	checks.push({ name: "rg", found: !!rg, path: rg, need: "optional", reason: "faster code search when the model shells out to ripgrep", hint: "brew install ripgrep" });
+	// pi downloads ripgrep into <agentDir>/bin on first run when PATH has none
+	// and puts that dir on the shell tools' PATH, so a copy there is "found".
+	const rgName = platform === "win32" ? "rg.exe" : "rg";
+	const bundledRg = input.agentDir ? join(input.agentDir, "bin", rgName) : undefined;
+	if (input.shells) {
+		const s = input.shells;
+		checks.push({ name: "bash", found: !!s.bash, path: s.bash, need: s.bashExpected ? "required" : "optional", reason: bashReason(s), hint: s.bashExpected ? undefined : "https://git-scm.com/download/win" });
+		checks.push({ name: "powershell", found: !!s.powershell, path: s.powershell, need: s.powershellWanted ? "required" : "unused", reason: powershellReason(s), hint: "https://aka.ms/powershell" });
+		if (s.bashWarning) findings.push({ level: "warn", text: s.bashWarning, fix: "Point CLAUDE_CODE_GIT_BASH_PATH at a bash.exe or sh.exe, or unset it to use Git for Windows' default location." });
+		for (const notice of s.notices) {
+			const switchSet = notice.includes("CLAUDE_CODE_USE_POWERSHELL_TOOL");
+			findings.push({
+				level: s.primary === "none" ? "error" : "warn",
+				text: notice,
+				fix: switchSet ? "Install PowerShell 7 (pwsh) or unset CLAUDE_CODE_USE_POWERSHELL_TOOL." : "Install Git for Windows or PowerShell 7.",
+			});
+		}
+	}
+
+	const rg = which("rg") ?? (bundledRg && existsSync(bundledRg) ? bundledRg : undefined);
+	checks.push({ name: "rg", found: !!rg, path: rg, need: "optional", reason: "faster code search when the model shells out to ripgrep", hint: installHint("ripgrep", platform) });
 
 	const languages = projectLanguages(cwd);
 	const seenCommands = new Set<string>();
@@ -119,13 +151,13 @@ export function checkDependencies(input: DependencyInput): DependencyReport {
 			path: found,
 			need: needed ? "project" : "unused",
 			reason: `lsp_diagnostics for ${family.join("/")}${needed ? " (this project)" : ""}`,
-			hint: INSTALL_HINTS[config.command],
+			hint: serverInstallHint(config.command, platform),
 		});
 		if (needed && !found) {
 			findings.push({
 				level: "warn",
 				text: `${config.command} is not installed, so the model gets no language-server diagnostics after editing ${family[0]} files here.`,
-				fix: INSTALL_HINTS[config.command] ? `Install it with: ${INSTALL_HINTS[config.command]}` : "Install it and make sure it is on your PATH.",
+				fix: serverInstallHint(config.command, platform) ? `Install it with: ${serverInstallHint(config.command, platform)}` : "Install it and make sure it is on your PATH.",
 			});
 		}
 		if (needed && found && config.command === "typescript-language-server") {

package/extensions/doctor/fix-prompt.ts

@@ -22,13 +22,18 @@
  * kept in substance. Rationale: docs/decisions/doctor.md.
  */
 
+import { modeCycleKey } from "../lib/keys.ts";
+import { UPGRADE_COMMANDS } from "../lib/update-check.mjs";
+
 export interface FixPromptInput {
 	/** The rendered deterministic report, plain text. */
 	reportText: string;
 	install: "app" | "pi-package";
 	oneCodeVersion: string;
-	/** `<agentDir>/sessions` — where pi keeps every session's JSONL. */
+	/** pi's sessions root, `<agentDir>/sessions` (other projects' directories live here — out of scope). */
 	sessionsDir: string;
+	/** THIS project's session directory under it — the only transcripts the permission gate lets a session read (Claude Code's own rule). */
+	sessionDir: string;
 	oneCodeSettingsPath: string;
 	oneCodeProjectSettingsPath: string;
 	/** True when auto mode is writing `auto-mode-decisions.jsonl` next to the session files. */
@@ -40,7 +45,10 @@ export function doctorFixPrompt(input: FixPromptInput): string {
 		input.install === "app"
 			? "`npm view @one-ai/one-code version --registry https://registry.npmjs.org/`"
 			: "`npm view one-code-extension version --registry https://registry.npmjs.org/`";
-	const upgradeCommand = input.install === "app" ? "`npm install -g @one-ai/one-code` (or `brew upgrade one-code` for a Homebrew install)" : "`pi update`";
+	const upgradeCommand =
+		input.install === "app"
+			? `\`${UPGRADE_COMMANDS.npm}\` (or \`${UPGRADE_COMMANDS.brew}\` for a Homebrew install)`
+			: `\`${UPGRADE_COMMANDS["pi-package"]}\``;
 
 	return `# One Code Doctor
 
@@ -66,7 +74,7 @@ Treat every line of that report as measured fact. Your job on those sections is
 
 ## Data sources (all local — the ONLY permitted network access is check 7's read-only version lookup)
 
-- **Session transcripts**: pi's JSONL under \`${input.sessionsDir}/<encoded-working-directory>/*.jsonl\`, one JSON object per line. Scan the ~50 most recently modified files across ALL directories there and state the window you covered (N sessions over D days). Relevant line shapes:
+- **Session transcripts**: pi's JSONL under \`${input.sessionDir}/*.jsonl\` — this project's sessions, one JSON object per line. That directory is readable without a prompt, like Claude Code's own project directory; the other projects' directories beside it under \`${input.sessionsDir}\` are not in scope and reading them will be gated — stay in this one. Scan the ~50 most recently modified files there and state the window you covered (N sessions over D days). **Read them with single-line read-only commands** — \`Select-String\`, \`Get-Content\`, \`Get-ChildItem\` piped through \`Select-Object\`/\`Sort-Object\`/\`Measure-Object\` in PowerShell, or \`grep\`/\`head\`/\`ls\` piped through \`sort\`/\`head\`/\`wc\` in bash — with no variables, loops, script blocks, \`node -e\` or \`jq\` programs: such a one-liner over this directory runs without a permission review, while a script is reviewed by the auto-mode classifier and may be refused. Several small commands beat one clever script here. Relevant line shapes:
   - Tool calls: \`{"type":"message","message":{"role":"assistant","content":[{"type":"toolCall","name":...,"arguments":...}]}}\`. MCP tools are named \`mcp__<server>__<tool>\` (the server segment is normalized — any character outside \`[a-zA-Z0-9_-]\` becomes \`_\`; plugin servers appear as \`mcp__plugin_<plugin>_<server>__\`). Model-invoked skills are calls to the \`skill\` tool with the skill name in \`arguments.skill\`. Subagent runs are \`Agent\` tool calls.
   - Denied tool calls: a \`toolResult\` whose text starts with "Permission for this action was denied by the auto-mode approval classifier" (auto mode) or "This tool call is denied by the permission rule" (a deny rule). Follow its \`toolCallId\` back to the assistant's \`toolCall\` for the tool name and arguments. ${input.decisionLogEnabled ? "Auto mode is also writing `auto-mode-decisions.jsonl` next to each session file — every gate decision with its verdict; prefer it for check 9." : "Auto mode is not logging its decisions (`autoMode.logDecisions` is off), so transcripts are the only denial record."}
   - There are NO usage counters in One Code: whether a skill, plugin or MCP server was used is answered from transcripts alone.
@@ -107,7 +115,7 @@ Installed: ${input.oneCodeVersion} (${input.install === "app" ? "the bundled one
 
 ## Check 8 — permission mode (report only)
 
-Auto mode is One Code's shipped default. If the report shows a different mode pinned by \`permissions.defaultMode\` in \`~/.claude/settings.json\` or a managed file, say so in one line and leave it — One Code does not edit those files, and the user can change the mode with ctrl+q or \`--permission-mode\`. If a repository file pins \`auto\` or \`bypassPermissions\`, the report already explains why it is ignored.
+Auto mode is One Code's shipped default. If the report shows a different mode pinned by \`permissions.defaultMode\` in \`~/.claude/settings.json\` or a managed file, say so in one line and leave it — One Code does not edit those files, and the user can change the mode with ${modeCycleKey()} or \`--permission-mode\`. If a repository file pins \`auto\` or \`bypassPermissions\`, the report already explains why it is ignored.
 
 ## Check 9 — pre-approve frequently denied read-only commands
 

package/extensions/doctor/index.ts

@@ -159,6 +159,7 @@ export default function doctorExtension(pi: ExtensionAPI) {
 			install: install(),
 			oneCodeVersion: oneCodeVersion(),
 			sessionsDir: join(getAgentDir(), "sessions"),
+			sessionDir: ctx.sessionManager.getSessionDir(),
 			oneCodeSettingsPath: oneCodeSettingsPath(home),
 			oneCodeProjectSettingsPath: oneCodeProjectSettingsPath(ctx.cwd, home),
 			decisionLogEnabled: loadAutoModeConfig(home).logDecisions,

package/extensions/doctor/models.ts

@@ -10,6 +10,7 @@
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
+import { modeCycleKey } from "../lib/keys.ts";
 import { loadAutoModeConfig } from "../auto-mode/config.ts";
 import { classifierCandidates, describeCandidate, type ClassifierNotice } from "../auto-mode/model-select.ts";
 import { ATTRIBUTION, capabilityFloor, configuredCapabilityKey, type FloorRole, type FloorVerdict, KEY_ADVICE, snapshotAgeMs } from "../lib/capability-index.ts";
@@ -210,7 +211,7 @@ export function modelsSection(facts: ModelFacts, session: SessionView, findings:
 	if (session.permission) {
 		const mode = session.permission.mode;
 		const from = session.permission.source ? ` (${session.permission.source})` : "";
-		lines.push({ text: `Permission mode: ${mode}${from} — ctrl+q cycles, /permissions lists the rules`, level: "dim" });
+		lines.push({ text: `Permission mode: ${mode}${from} — ${modeCycleKey()} cycles, /permissions lists the rules`, level: "dim" });
 	}
 
 	if (facts.sessionTier === "tiny") {

package/extensions/doctor/report.ts

@@ -16,6 +16,7 @@
  */
 
 import type { Api, Model } from "@earendil-works/pi-ai";
+import { tildify } from "../lib/paths.ts";
 import type { McpStatusEvent } from "../lib/mcp-status.ts";
 import { wrapProse } from "../subagents/panel-render.ts";
 import { countNoun } from "../lib/tui-render.ts";
@@ -183,7 +184,5 @@ export function contextLabel(tokens: number | undefined): string {
 
 /** `~/…` for anything under home, so paths stay readable at any width. */
 export function shortenHome(path: string, home: string): string {
-	if (path === home) return "~";
-	const root = home.endsWith("/") ? home : `${home}/`;
-	return path.startsWith(root) ? `~/${path.slice(root.length)}` : path;
+	return tildify(path, home);
 }

package/extensions/doctor/update-lookup.ts

@@ -1,16 +1,19 @@
 /**
  * Newest-release lookup for the doctor's Installation section (pure given a
- * fetch). Mirrors the app's daily update check (app/update-check.mjs): the same
- * registry endpoints, a short timeout, silent on failure, and skipped under
- * pi's offline switch or ONECODE_NO_UPDATE_CHECK — a diagnostic must never hang
- * on the network or restore egress the user turned off.
+ * fetch). Shares the app's daily update notice's mechanism
+ * (lib/update-check.mjs): the same packument, the same "newest installable
+ * version" rule — a day's release age under Homebrew, `dist-tags.latest`
+ * otherwise — a short timeout, silent on failure, and skipped under pi's
+ * offline switch or ONECODE_NO_UPDATE_CHECK — a diagnostic must never hang on
+ * the network or restore egress the user turned off.
  */
 
 import { compareVersions } from "../lib/pi-version.ts";
+import { APP_PACKAGE, EXTENSION_PACKAGE, minReleaseAgeFor, pickAvailableVersion, registryPackumentUrl } from "../lib/update-check.mjs";
 import type { DoctorEnvironment } from "./report.ts";
 
-export const APP_REGISTRY_URL = "https://registry.npmjs.org/@one-ai%2Fone-code/latest";
-export const PACKAGE_REGISTRY_URL = "https://registry.npmjs.org/one-code-extension/latest";
+export const APP_REGISTRY_URL = registryPackumentUrl(APP_PACKAGE);
+export const PACKAGE_REGISTRY_URL = registryPackumentUrl(EXTENSION_PACKAGE);
 export const LOOKUP_TIMEOUT_MS = 3000;
 
 export type LatestLookup = NonNullable<DoctorEnvironment["latest"]>;
@@ -34,11 +37,16 @@ export async function lookupLatestVersion(input: {
 	try {
 		const response = await fetchImpl(url, { signal: AbortSignal.timeout(input.timeoutMs ?? LOOKUP_TIMEOUT_MS) });
 		if (!response.ok) return { status: "unknown", reason: `registry answered ${response.status}` };
-		const body = (await response.json()) as { version?: unknown };
-		if (typeof body.version !== "string") return { status: "unknown", reason: "unexpected registry payload" };
-		const cmp = compareVersions(body.version, input.current);
-		if (cmp === undefined) return { status: "unknown", version: body.version, reason: "unparseable version" };
-		return { status: cmp > 0 ? "behind" : "current", version: body.version };
+		const minReleaseAgeMs = minReleaseAgeFor(input.env);
+		const body = (await response.json()) as { "dist-tags"?: { latest?: unknown }; time?: unknown };
+		const wellFormed = typeof body?.["dist-tags"]?.latest === "string" && (minReleaseAgeMs <= 0 || (typeof body.time === "object" && body.time !== null));
+		if (!wellFormed) return { status: "unknown", reason: "unexpected registry payload" };
+		const latest = pickAvailableVersion(body, { minReleaseAgeMs });
+		// A well-formed packument with nothing old enough is a Homebrew outcome, not a broken registry.
+		if (typeof latest !== "string") return { status: "unknown", reason: "no release is a day old yet (Homebrew installs wait that long)" };
+		const cmp = compareVersions(latest, input.current);
+		if (cmp === undefined) return { status: "unknown", version: latest, reason: "unparseable version" };
+		return { status: cmp > 0 ? "behind" : "current", version: latest };
 	} catch (error) {
 		const message = error instanceof Error ? (error.name === "TimeoutError" ? "timed out" : error.message) : String(error);
 		return { status: "unknown", reason: message };

package/extensions/effort/index.ts

@@ -42,6 +42,7 @@ import {
 	ULTRACODE_MODE_CHANNEL,
 	ULTRACODE_STATUS_KEY,
 } from "./slider.ts";
+import { registerLocalCommand } from "../lib/local-command.ts";
 
 /** The levels pi says the active model can reach; the full ladder when unknown. */
 function supportedLevels(ctx: ExtensionContext): ThinkingLevel[] {
@@ -193,7 +194,7 @@ export default function effortExtension(pi: ExtensionAPI) {
 		if (chosen) applyChoice(chosen, ctx);
 	};
 
-	pi.registerCommand("effort", {
+	registerLocalCommand(pi, "effort", {
 		description: `Set reasoning effort (shift+tab cycles the plain levels): /effort [${EFFORT_CHOICES.join("|")}] — ultracode is ${ULTRACODE_LEVEL} + workflows`,
 		getArgumentCompletions: (prefix) => {
 			const matches = acceptedEffortArgs().filter((value) => value.startsWith(prefix.trim().toLowerCase()));

package/extensions/footer/footer-line.ts

@@ -12,6 +12,7 @@
  */
 
 import { costOf, usageEntryCost } from "../lib/usage-bus.ts";
+import type { WorktreeLocation } from "../lib/worktree-channel.ts";
 
 export type Paint = (color: string, text: string) => string;
 
@@ -38,6 +39,18 @@ export interface FooterData {
 	effort?: string;
 }
 
+/**
+ * Where the footer says the session is: the active worktree's path and branch
+ * while `enter_worktree` is in effect (the process cwd never changes — the
+ * worktree extension rewrites tool inputs instead — so pi's own cwd and branch
+ * would keep naming the original checkout), else the process cwd and its
+ * branch.
+ */
+export function footerLocation(cwd: string, branch: string | undefined, worktree: WorktreeLocation | null | undefined): { cwd: string; branch?: string } {
+	if (worktree) return { cwd: worktree.path, branch: worktree.branch };
+	return { cwd, branch };
+}
+
 /** pi's token formatter, replicated so a "1.1M" here reads like pi's own. */
 export function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
@@ -197,6 +210,12 @@ export function computeMainUsage(entries: readonly unknown[]): { cost: number; c
 			cost += costOf(entry.message.usage);
 		} else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
 			cost += costOf(entry.usage);
+		} else if (entry.type === "usage" && entry.usage) {
+			// pi 0.86's model-attributed usage outside the LLM context — today its
+			// cache-warming refreshes (`kind: "cache_warm"`), billed as a cache read
+			// of the full context plus one output token. pi's /session counts them;
+			// so does the footer.
+			cost += costOf(entry.usage);
 		} else {
 			// Out-of-band calls (subagents, classifier, readers, recap, setup)
 			// persisted by recordUsage — the all-in half of the total.

package/extensions/footer/index.ts

@@ -22,7 +22,8 @@ import { linesComponent, safeThemePaint } from "../lib/tui-render.ts";
 import { formatModel, isRealModel } from "../permissions/modes.ts";
 import { ULTRACODE_STATUS_KEY } from "../effort/slider.ts";
 import { USAGE_CHANNEL } from "../lib/usage-bus.ts";
-import { buildFooterLines, computeMainUsage, type FooterData } from "./footer-line.ts";
+import { buildFooterLines, computeMainUsage, footerLocation, type FooterData } from "./footer-line.ts";
+import { WORKTREE_CHANNEL, type WorktreeLocation } from "../lib/worktree-channel.ts";
 import { fetchPrNumber } from "./pr.ts";
 
 export default function footerExtension(pi: ExtensionAPI) {
@@ -40,6 +41,16 @@ export default function footerExtension(pi: ExtensionAPI) {
 
 	/** Invalidate the memoized line and repaint; set once the footer mounts. */
 	let repaint = () => {};
+	/** The active worktree session, if any; shown in place of the process cwd + branch. */
+	let worktree: WorktreeLocation | null = null;
+	/** Re-point the PR lookup at the location currently shown; set once the footer mounts. */
+	let refreshLocation = () => {};
+
+	pi.events.on(WORKTREE_CHANNEL, (data: unknown) => {
+		worktree = data as WorktreeLocation | null;
+		refreshLocation();
+		repaint();
+	});
 
 	const recomputeMain = (ctx: ExtensionContext) => {
 		lastCtx = ctx;
@@ -85,15 +96,19 @@ export default function footerExtension(pi: ExtensionAPI) {
 				onBranchChange(cb: () => void): () => void;
 			};
 
+			/** The path + branch shown, and the PR looked up: the worktree's while one is active. */
+			const currentLocation = () => footerLocation(ctx.cwd, fd.getGitBranch() ?? undefined, worktree);
+
 			const snapshot = (): FooterData => {
 				const usage = ctx.getContextUsage();
 				const ultracode = fd.getExtensionStatuses().get(ULTRACODE_STATUS_KEY);
 				const effort = ultracode ?? safeThinkingLevel(ctx);
 				const model = ctx.model;
+				const location = currentLocation();
 				return {
-					cwd: ctx.cwd,
+					cwd: location.cwd,
 					home: process.env.HOME || process.env.USERPROFILE || "",
-					branch: fd.getGitBranch() ?? undefined,
+					branch: location.branch,
 					contextTokens: usage?.tokens ?? undefined,
 					contextWindow: usage?.contextWindow,
 					contextPercent: usage?.percent,
@@ -116,9 +131,13 @@ export default function footerExtension(pi: ExtensionAPI) {
 			// only disposes the component, so the subscription must be released
 			// here — otherwise each replaced footer keeps firing its `gh pr list`
 			// against a stale cwd on every branch change.
-			refreshPr(ctx.cwd, fd.getGitBranch());
+			refreshLocation = () => {
+				const location = currentLocation();
+				refreshPr(location.cwd, location.branch ?? null);
+			};
+			refreshLocation();
 			const stopFollowingBranch = fd.onBranchChange(() => {
-				refreshPr(ctx.cwd, fd.getGitBranch());
+				refreshLocation();
 				repaint();
 			});
 
@@ -126,6 +145,7 @@ export default function footerExtension(pi: ExtensionAPI) {
 				dispose: () => {
 					stopFollowingBranch();
 					repaint = () => {};
+					refreshLocation = () => {};
 				},
 			});
 		});

package/extensions/hooks/executor.ts

@@ -9,11 +9,18 @@
  * a JSON payload from stdin. (Ported from pi-code's runHookCommand, MIT — see
  * docs/decisions.md.)
  *
+ * The interpreter is Claude Code's: bash (Git Bash on Windows, honouring
+ * `CLAUDE_CODE_GIT_BASH_PATH`) unless the hook says `shell: "powershell"`, or
+ * the machine is a Windows box without Git Bash — lib/shell-spawn.ts resolves
+ * both through pi's own shell lookup.
+ *
  * Hardening carried over:
- * - absolute /bin/sh, so a repo-local `sh` on PATH can't hijack the hook
+ * - an absolute interpreter path, so a repo-local `sh` on PATH can't hijack
+ *   the hook
  * - detached:true makes the shell a process-group leader; timeout SIGKILLs
  *   the negative pid so grandchildren holding the stdio pipes die too —
  *   otherwise `close` never fires and the promise hangs past the timeout
+ *   (Windows: `taskkill /T /F` on the leader's pid does the same)
  * - setEncoding("utf8") so multi-byte characters can't be split across chunks
  * - output capped at 1MB per stream
  * - stdin errors ignored (a hook that exits without reading stdin — `exit 2`
@@ -38,8 +45,36 @@
  *   mechanism for the LSP client). A ref'd child holds the loop until `close`.
  */
 
-import { spawn } from "node:child_process";
-import { killProcessTree } from "../lib/process-tree.ts";
+import type { ChildProcess } from "node:child_process";
+import { detachedSpawnOptions, killProcessTree, waitForChildExit } from "../lib/process-tree.ts";
+import { bashSpawn, POWERSHELL_UTF8_PREFIX, powerShellSpawn, type ShellSpawn, spawnShellCommand } from "../lib/shell-spawn.ts";
+import type { HookShell } from "./settings.ts";
+
+/**
+ * Claude Code's default: hooks run in bash (Git Bash on Windows) when one
+ * exists, otherwise in PowerShell — which only happens on Windows without Git
+ * for Windows, since every other platform resolves a bash.
+ */
+export function defaultHookShell(): HookShell {
+	return bashSpawn().spawn ? "bash" : "powershell";
+}
+
+/** The interpreter for one hook, or the reason none can run it. */
+export function hookShellSpawn(shell: HookShell | undefined): { spec?: ShellSpawn; shell?: HookShell; error?: string } {
+	const want = shell ?? defaultHookShell();
+	if (want === "powershell") {
+		const spec = powerShellSpawn();
+		return spec ? { spec, shell: want } : { error: "hook needs PowerShell but no pwsh/powershell executable was found on PATH" };
+	}
+	const resolved = bashSpawn();
+	if (!resolved.spawn) return { error: resolved.error ?? "hook needs bash but none was found" };
+	if (resolved.spawn.commandTransport === "stdin") {
+		// pi's legacy-WSL launcher takes its script on stdin, which the hook
+		// payload already occupies.
+		return { error: `hook cannot run under ${resolved.spawn.shell} (a WSL launcher); set CLAUDE_CODE_GIT_BASH_PATH to Git Bash's bash.exe` };
+	}
+	return { spec: resolved.spawn, shell: want };
+}
 
 export interface HookRunResult {
 	/**
@@ -80,6 +115,8 @@ export interface HookRunOptions {
 	 * stdout/stderr are therefore empty for a detached hook — nothing reads them.
 	 */
 	detached?: boolean;
+	/** The hook's `shell` field; unset → `defaultHookShell()`. */
+	shell?: HookShell;
 }
 
 const MAX_OUTPUT_BYTES = 1_000_000;
@@ -92,11 +129,28 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 	const started = Date.now();
 
 	return new Promise((resolve) => {
-		let child: ReturnType<typeof spawn>;
+		let child: ChildProcess;
+		const failed = (spawnError: string) =>
+			resolve({ exitCode: null, timedOut: false, spawnError, stdout: "", stderr: "", durationMs: Date.now() - started });
+		const { spec, shell, error } = hookShellSpawn(opts.shell);
+		if (!spec) {
+			failed(error ?? "no shell available for the hook");
+			return;
+		}
+		// Windows PowerShell 5.1 (`powershell.exe`) defaults its console to
+		// UTF-16, which would corrupt this stream once decoded as UTF-8 below
+		// (setEncoding("utf8")) — the same fix every other PowerShell execution
+		// path applies (lib/shell-spawn.ts, extensions/powershell/index.ts).
+		const runCommand = shell === "powershell" ? `${POWERSHELL_UTF8_PREFIX}${command}` : command;
 		try {
-			child = spawn("/bin/sh", ["-c", command], {
+			// An absolute interpreter path (pi's resolver never yields a bare name
+			// where a real bash exists), so a repo-local `sh` on PATH cannot hijack
+			// the hook; the shell leads its own process group so a timeout kills
+			// grandchildren too (Windows: taskkill /T — lib/process-tree.ts).
+			child = spawnShellCommand(spec, runCommand, {
 				cwd: opts.cwd,
-				detached: true,
+				// A fire-and-forget hook must outlive a parent that is exiting.
+				...detachedSpawnOptions({ outlivesParent: opts.detached }),
 				stdio: opts.detached ? ["pipe", "ignore", "ignore"] : ["pipe", "pipe", "pipe"],
 				env: { ...process.env, CLAUDE_PROJECT_DIR: opts.projectDir ?? opts.cwd },
 			});
@@ -149,21 +203,33 @@ export function runHookCommand(command: string, stdinJson: string, opts: HookRun
 			resolve({ ...result, durationMs: Date.now() - started });
 		};
 
-		child.on("error", (error) => {
-			finish({ exitCode: null, timedOut, spawnError: error.message, stdout, stderr });
-		});
-		child.on("close", (code) => {
-			// A killed process reports null here, EXCEPT when the shell outlived the
-			// group kill just long enough to reap its child and exit 128+9 itself
-			// (see exitCode's contract). Normalizing keeps "we killed it" from ever
-			// looking like an ordinary non-zero exit, which fails OPEN downstream.
-			finish({ exitCode: timedOut ? null : code, timedOut, stdout, stderr });
-		});
+		// Settles on exit plus a short stdio grace, not on `close`: a grandchild
+		// the kill missed could otherwise hold the pipes — and this promise — open
+		// for its whole life (lib/process-tree.ts). A killed process reports null,
+		// EXCEPT when the shell outlived the group kill just long enough to reap
+		// its child and exit 128+9 itself (see exitCode's contract). Normalizing
+		// keeps "we killed it" from ever looking like an ordinary non-zero exit,
+		// which fails OPEN downstream.
+		waitForChildExit(child).then(
+			({ code }) => finish({ exitCode: timedOut ? null : code, timedOut, stdout, stderr }),
+			(error: Error) => finish({ exitCode: null, timedOut, spawnError: error.message, stdout, stderr }),
+		);
 
 		// A hook that never reads stdin (e.g. plain `exit 2`) closes the pipe
 		// early; the resulting EPIPE must not take the extension down.
 		child.stdin?.on("error", () => {});
-		child.stdin?.write(stdinJson.endsWith("\n") ? stdinJson : `${stdinJson}\n`);
-		child.stdin?.end();
+		const payload = stdinJson.endsWith("\n") ? stdinJson : `${stdinJson}\n`;
+		if (opts.detached) {
+			// Close the pipe the moment the payload is written, not with a graceful
+			// shutdown: on Windows libuv's pipe shutdown stays pending until the
+			// reader has drained the data, and a hook that never reads stdin would
+			// keep the process alive for its whole run (the probe test measured a
+			// `sleep 3` SessionEnd hook holding a one-shot open for 3 s). The data
+			// already written stays readable by the hook after the handle closes.
+			child.stdin?.write(payload, () => child.stdin?.destroy());
+		} else {
+			child.stdin?.write(payload);
+			child.stdin?.end();
+		}
 	});
 }

package/extensions/hooks/index.ts

@@ -196,6 +196,7 @@ export default function hooksExtension(pi: ExtensionAPI) {
 					const run = await runHookCommand(hook.command, stdin, {
 						cwd: ctx.cwd,
 						timeoutSeconds: hook.timeout,
+						shell: hook.shell,
 						projectDir: ctx.cwd,
 						// SessionEnd is fire-and-forget at shutdown: it must not hold a
 						// one-shot process open. Every other hook is awaited work that

package/extensions/hooks/matcher.ts

@@ -15,6 +15,7 @@ import { ccAliasesForTool } from "../permissions/matcher.ts";
  */
 const CC_CANONICAL: Record<string, string> = {
 	bash: "Bash",
+	powershell: "PowerShell",
 	read: "Read",
 	edit: "Edit",
 	write: "Write",
@@ -88,19 +89,32 @@ export function toolMatchCandidates(nativeName: string): string[] {
 	return [...new Set([nativeName, ccToolName(nativeName), ...ccAliasesForTool(nativeName)])];
 }
 
-/**
- * Whether a CC matcher applies to any candidate spelling. Anchored and
- * case-insensitive (`^(?:matcher)$`, the CC semantics); an invalid regex
- * falls back to case-insensitive exact comparison rather than throwing.
- */
-export function matcherApplies(matcher: string | undefined, candidates: string[]): boolean {
-	if (matcher === undefined || matcher === "" || matcher === "*") return true;
+/** One matcher spelling: a regex when it compiles, else a case-insensitive exact match. */
+function matchesAlternative(alternative: string, candidates: string[]): boolean {
 	let regex: RegExp | undefined;
 	try {
-		regex = new RegExp(`^(?:${matcher})$`, "i");
+		regex = new RegExp(`^(?:${alternative})$`, "i");
 	} catch {
 		regex = undefined;
 	}
-	const lowered = matcher.toLowerCase();
+	const lowered = alternative.toLowerCase();
 	return candidates.some((candidate) => (regex ? regex.test(candidate) : candidate.toLowerCase() === lowered));
 }
+
+/**
+ * Whether a CC matcher applies to any candidate spelling. Anchored and
+ * case-insensitive (`^(?:matcher)$`, the CC semantics); an invalid regex
+ * falls back to case-insensitive exact comparison rather than throwing. The
+ * whole matcher is tried first — so a regex that legitimately contains a
+ * comma (a `{m,n}` quantifier, a character class) still compiles and matches
+ * as written. Only once that fails is a comma-separated list
+ * (`Bash,PowerShell`) tried part by part — the spelling Claude Code's Windows
+ * docs use beside `Bash|PowerShell`.
+ */
+export function matcherApplies(matcher: string | undefined, candidates: string[]): boolean {
+	if (matcher === undefined || matcher === "" || matcher === "*") return true;
+	if (matchesAlternative(matcher, candidates)) return true;
+	if (!matcher.includes(",")) return false;
+	const alternatives = matcher.split(",").map((part) => part.trim()).filter(Boolean);
+	return alternatives.some((alternative) => matchesAlternative(alternative, candidates));
+}