gsd-pi 2.27.0 → 2.28.0-dev.346ee62

package/packages/pi-coding-agent/src/core/resolve-config-value.test.ts

@@ -89,6 +89,64 @@ describe("resolveConfigValue — command allowlist enforcement", () => {
 	});
 });
 
+describe("resolveConfigValue — shell operator bypass prevention", () => {
+	it("blocks semicolon chaining (pass; malicious)", () => {
+		const result = resolveConfigValue("!pass show key; curl http://evil.com");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks pipe operator (pass | evil)", () => {
+		const result = resolveConfigValue("!pass show key | cat /etc/passwd");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks && chaining (pass && evil)", () => {
+		const result = resolveConfigValue("!pass show key && rm -rf /");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks || chaining (pass || evil)", () => {
+		const result = resolveConfigValue("!pass show key || curl evil.com");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks backtick subshell (pass `evil`)", () => {
+		const result = resolveConfigValue("!pass show `curl evil.com`");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks $() subshell (pass $(evil))", () => {
+		const result = resolveConfigValue("!pass show $(curl evil.com)");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks output redirection (pass > file)", () => {
+		const result = resolveConfigValue("!pass show key > /tmp/stolen");
+		assert.equal(result, undefined);
+	});
+
+	it("blocks input redirection (pass < file)", () => {
+		const result = resolveConfigValue("!pass show key < /dev/null");
+		assert.equal(result, undefined);
+	});
+
+	it("writes stderr warning when shell operators detected", () => {
+		const stderrChunks: string[] = [];
+		const originalWrite = process.stderr.write.bind(process.stderr);
+		process.stderr.write = (chunk: string | Uint8Array, ...args: unknown[]) => {
+			stderrChunks.push(chunk.toString());
+			return true;
+		};
+
+		try {
+			resolveConfigValue("!pass show key; curl evil.com");
+			assert.ok(stderrChunks.some((line) => line.includes("shell operators")));
+		} finally {
+			process.stderr.write = originalWrite;
+		}
+	});
+});
+
 describe("resolveConfigValue — caching", () => {
 	it("caches the result of a blocked command", () => {
 		const callCount = { n: 0 };

package/packages/pi-coding-agent/src/core/resolve-config-value.ts

@@ -3,7 +3,10 @@
  * Used by auth-storage.ts and model-registry.ts.
  */
 
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
+import { COMMAND_EXECUTION_TIMEOUT_MS } from "./constants.js";
+
+const SHELL_OPERATORS = /[;|&`$><]/;
 
 // Cache for shell command results (persists for process lifetime)
 const commandResultCache = new Map<string, string | undefined>();
@@ -40,18 +43,25 @@ function executeCommand(commandConfig: string): string | undefined {
 	}
 
 	const command = commandConfig.slice(1);
-	const firstToken = command.split(/\s+/)[0];
+	const tokens = command.split(/\s+/).filter(Boolean);
+	const firstToken = tokens[0];
 	if (!SAFE_COMMAND_PREFIXES.includes(firstToken)) {
 		process.stderr.write(`[resolve-config-value] Blocked disallowed command: "${firstToken}". Allowed: ${SAFE_COMMAND_PREFIXES.join(", ")}\n`);
 		commandResultCache.set(commandConfig, undefined);
 		return undefined;
 	}
 
+	if (SHELL_OPERATORS.test(command)) {
+		process.stderr.write(`[resolve-config-value] Blocked shell operators in command: "${command}"\n`);
+		commandResultCache.set(commandConfig, undefined);
+		return undefined;
+	}
+
 	let result: string | undefined;
 	try {
-		const output = execSync(command, {
+		const output = execFileSync(firstToken, tokens.slice(1), {
 			encoding: "utf-8",
-			timeout: 10000,
+			timeout: COMMAND_EXECUTION_TIMEOUT_MS,
 			stdio: ["ignore", "pipe", "ignore"],
 		});
 		result = output.trim() || undefined;

package/packages/pi-coding-agent/src/core/session-manager.ts

@@ -13,8 +13,10 @@ import {
 	statSync,
 	writeFileSync,
 } from "fs";
+import { atomicWriteFileSync } from "./fs-utils.js";
 import { readdir, readFile, stat } from "fs/promises";
 import { join, resolve } from "path";
+import lockfile from "proper-lockfile";
 import { getAgentDir as getDefaultAgentDir, getBlobsDir, getSessionsDir } from "../config.js";
 import {
 	type BashExecutionMessage,
@@ -25,6 +27,25 @@ import {
 } from "./messages.js";
 import { BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store.js";
 
+/** Inline concurrency limiter to cap parallel async operations. */
+function pLimit(concurrency: number) {
+	const queue: (() => void)[] = [];
+	let active = 0;
+	return <T>(fn: () => Promise<T>): Promise<T> => {
+		return new Promise<T>((resolve, reject) => {
+			const run = () => {
+				active++;
+				fn().then(resolve, reject).finally(() => {
+					active--;
+					if (queue.length > 0) queue.shift()!();
+				});
+			};
+			if (active < concurrency) run();
+			else queue.push(run);
+		});
+	};
+}
+
 const BLOB_EXTERNALIZE_THRESHOLD = 1024; // 1KB minimum to externalize
 const MAX_PERSIST_CHARS = 500_000;
 const TRUNCATION_NOTICE = "\n\n[Session persistence truncated large content]";
@@ -821,6 +842,37 @@ export class SessionManager {
 		}
 	}
 
+	/**
+	 * Check if the last assistant turn in the session appears to have been
+	 * interrupted (e.g., the last message is from the assistant with tool_use
+	 * blocks but no subsequent tool_result message).
+	 */
+	wasInterrupted(): boolean {
+		// Walk backwards to find the last message entry
+		for (let i = this.fileEntries.length - 1; i >= 0; i--) {
+			const entry = this.fileEntries[i];
+			if (entry.type !== "message") continue;
+
+			const msg = entry.message;
+			if (msg.role === "user") return false; // clean user turn boundary
+			if (msg.role === "assistant") {
+				// Check if the assistant message contains tool_use blocks
+				const content = Array.isArray(msg.content) ? msg.content : [];
+				const hasToolUse = content.some(
+					(block) => block.type === "toolCall",
+				);
+				if (hasToolUse) {
+					// If the last message is an assistant tool_use with no following
+					// tool_result message, the turn was likely interrupted
+					return true;
+				}
+				return false; // assistant message without tool_use = completed text response
+			}
+			return false;
+		}
+		return false;
+	}
+
 	/** Switch to a different session file (used for resume and branching) */
 	setSessionFile(sessionFile: string): void {
 		this.sessionFile = resolve(sessionFile);
@@ -903,10 +955,43 @@ export class SessionManager {
 		}
 	}
 
+	private acquireSessionLock(path: string): (() => void) | undefined {
+		const maxAttempts = 10;
+		const delayMs = 20;
+		let lastError: unknown;
+
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			try {
+				return lockfile.lockSync(path, { realpath: false });
+			} catch (error) {
+				const code =
+					typeof error === "object" && error !== null && "code" in error
+						? String((error as { code?: unknown }).code)
+						: undefined;
+				if (code !== "ELOCKED" || attempt === maxAttempts) {
+					// Non-fatal: proceed without lock rather than losing data
+					return undefined;
+				}
+				lastError = error;
+				const start = Date.now();
+				while (Date.now() - start < delayMs) {
+					// Busy-wait to avoid async
+				}
+			}
+		}
+		return undefined;
+	}
+
 	private _rewriteFile(): void {
 		if (!this.persist || !this.sessionFile) return;
 		const content = `${this.fileEntries.map((e) => JSON.stringify(e)).join("\n")}\n`;
-		writeFileSync(this.sessionFile, content);
+		let release: (() => void) | undefined;
+		try {
+			release = this.acquireSessionLock(this.sessionFile);
+			atomicWriteFileSync(this.sessionFile, content);
+		} finally {
+			release?.();
+		}
 	}
 
 	isPersisted(): boolean {
@@ -939,15 +1024,21 @@ export class SessionManager {
 			return;
 		}
 
-		if (!this.flushed) {
-			for (const e of this.fileEntries) {
-				const prepared = prepareForPersistence(e, this.blobStore) as FileEntry;
+		let release: (() => void) | undefined;
+		try {
+			release = this.acquireSessionLock(this.sessionFile);
+			if (!this.flushed) {
+				for (const e of this.fileEntries) {
+					const prepared = prepareForPersistence(e, this.blobStore) as FileEntry;
+					appendFileSync(this.sessionFile, `${JSON.stringify(prepared)}\n`);
+				}
+				this.flushed = true;
+			} else {
+				const prepared = prepareForPersistence(entry, this.blobStore) as FileEntry;
 				appendFileSync(this.sessionFile, `${JSON.stringify(prepared)}\n`);
 			}
-			this.flushed = true;
-		} else {
-			const prepared = prepareForPersistence(entry, this.blobStore) as FileEntry;
-			appendFileSync(this.sessionFile, `${JSON.stringify(prepared)}\n`);
+		} finally {
+			release?.();
 		}
 	}
 
@@ -1495,14 +1586,14 @@ export class SessionManager {
 			cwd: targetCwd,
 			parentSession: sourcePath,
 		};
-		appendFileSync(newSessionFile, `${JSON.stringify(newHeader)}\n`);
-
-		// Copy all non-header entries from source
+		// Build complete fork content and write atomically to prevent partial files on crash
+		const lines = [JSON.stringify(newHeader)];
 		for (const entry of sourceEntries) {
 			if (entry.type !== "session") {
-				appendFileSync(newSessionFile, `${JSON.stringify(entry)}\n`);
+				lines.push(JSON.stringify(entry));
 			}
 		}
+		atomicWriteFileSync(newSessionFile, lines.join("\n") + "\n");
 
 		return new SessionManager(targetCwd, dir, newSessionFile, true);
 	}
@@ -1552,13 +1643,17 @@ export class SessionManager {
 			const sessions: SessionInfo[] = [];
 			const allFiles = dirFiles.flat();
 
+			// Limit concurrency to avoid memory spikes with many session files
+			const limit = pLimit(10);
 			const results = await Promise.all(
-				allFiles.map(async (file) => {
-					const info = await buildSessionInfo(file);
-					loaded++;
-					onProgress?.(loaded, totalFiles);
-					return info;
-				}),
+				allFiles.map((file) =>
+					limit(async () => {
+						const info = await buildSessionInfo(file);
+						loaded++;
+						onProgress?.(loaded, totalFiles);
+						return info;
+					}),
+				),
 			);
 
 			for (const info of results) {

package/packages/pi-coding-agent/src/core/settings-manager.ts

@@ -3,6 +3,12 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import lockfile from "proper-lockfile";
 import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
+import {
+	COMPACTION_KEEP_RECENT_TOKENS,
+	COMPACTION_RESERVE_TOKENS,
+	RETRY_BASE_DELAY_MS,
+	RETRY_MAX_DELAY_MS,
+} from "./constants.js";
 import type { BashInterceptorRule } from "./tools/bash-interceptor.js";
 
 export interface CompactionSettings {
@@ -134,6 +140,7 @@ export interface Settings {
 	thinkingBudgets?: ThinkingBudgetsSettings; // Custom token budgets for thinking levels
 	editorPaddingX?: number; // Horizontal padding for input editor (default: 0)
 	autocompleteMaxVisible?: number; // Max visible items in autocomplete dropdown (default: 5)
+	respectGitignoreInPicker?: boolean; // When false, @ file picker shows gitignored files (default: true)
 	showHardwareCursor?: boolean; // Show terminal cursor while still positioning it for IME
 	markdown?: MarkdownSettings;
 	memory?: MemorySettings;
@@ -709,11 +716,11 @@ export class SettingsManager {
 	}
 
 	getCompactionReserveTokens(): number {
-		return this.settings.compaction?.reserveTokens ?? 16384;
+		return this.settings.compaction?.reserveTokens ?? COMPACTION_RESERVE_TOKENS;
 	}
 
 	getCompactionKeepRecentTokens(): number {
-		return this.settings.compaction?.keepRecentTokens ?? 20000;
+		return this.settings.compaction?.keepRecentTokens ?? COMPACTION_KEEP_RECENT_TOKENS;
 	}
 
 	getCompactionSettings(): { enabled: boolean; reserveTokens: number; keepRecentTokens: number } {
@@ -726,7 +733,7 @@ export class SettingsManager {
 
 	getBranchSummarySettings(): { reserveTokens: number; skipPrompt: boolean } {
 		return {
-			reserveTokens: this.settings.branchSummary?.reserveTokens ?? 16384,
+			reserveTokens: this.settings.branchSummary?.reserveTokens ?? COMPACTION_RESERVE_TOKENS,
 			skipPrompt: this.settings.branchSummary?.skipPrompt ?? false,
 		};
 	}
@@ -752,8 +759,8 @@ export class SettingsManager {
 		return {
 			enabled: this.getRetryEnabled(),
 			maxRetries: this.settings.retry?.maxRetries ?? 3,
-			baseDelayMs: this.settings.retry?.baseDelayMs ?? 2000,
-			maxDelayMs: this.settings.retry?.maxDelayMs ?? 300000,
+			baseDelayMs: this.settings.retry?.baseDelayMs ?? RETRY_BASE_DELAY_MS,
+			maxDelayMs: this.settings.retry?.maxDelayMs ?? RETRY_MAX_DELAY_MS,
 		};
 	}
 
@@ -1024,6 +1031,16 @@ export class SettingsManager {
 		this.save();
 	}
 
+	getRespectGitignoreInPicker(): boolean {
+		return this.settings.respectGitignoreInPicker ?? true;
+	}
+
+	setRespectGitignoreInPicker(value: boolean): void {
+		this.globalSettings.respectGitignoreInPicker = value;
+		this.markModified("respectGitignoreInPicker");
+		this.save();
+	}
+
 	getCodeBlockIndent(): string {
 		return this.settings.markdown?.codeBlockIndent ?? "  ";
 	}

package/packages/pi-coding-agent/src/core/tools/edit-diff.ts

@@ -9,7 +9,7 @@
 
 import { constants } from "fs";
 import { access, readFile } from "fs/promises";
-import { resolveToCwd } from "./path-utils.js";
+import { resolveToCwd, UNICODE_SPACES } from "./path-utils.js";
 
 export function detectLineEnding(content: string): "\r\n" | "\n" {
 	const crlfIdx = content.indexOf("\r\n");
@@ -41,7 +41,7 @@ export function normalizeForFuzzyMatch(text: string): string {
 		.replace(/[“”]/g, '"')
 		.replace(/[‘’]/g, "'")
 		.replace(/[‐‑‒–—−]/g, "-")
-		.replace(/[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g, " ")
+		.replace(UNICODE_SPACES, " ")
 		.split("\n")
 		.map((line) => line.replace(/[ \t]+$/g, ""))
 		.join("\n");

package/packages/pi-coding-agent/src/core/tools/find.ts

@@ -3,6 +3,7 @@ import { glob as nativeGlob } from "@gsd/native/glob";
 import { type Static, Type } from "@sinclair/typebox";
 import { existsSync } from "fs";
 import path from "path";
+import { FIND_DEFAULT_LIMIT } from "../constants.js";
 import { resolveToCwd } from "./path-utils.js";
 import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateHead } from "./truncate.js";
 
@@ -16,7 +17,7 @@ const findSchema = Type.Object({
 
 export type FindToolInput = Static<typeof findSchema>;
 
-const DEFAULT_LIMIT = 1000;
+const DEFAULT_LIMIT = FIND_DEFAULT_LIMIT;
 
 export interface FindToolDetails {
 	truncation?: TruncationResult;

package/packages/pi-coding-agent/src/core/tools/hashline-edit.ts

@@ -20,7 +20,7 @@ import {
 	applyHashlineEdits,
 	computeLineHash,
 	type HashlineEdit,
-	hashlineParseText,
+	parseHashlineText,
 	parseTag,
 } from "./hashline.js";
 import { resolveToCwd } from "./path-utils.js";
@@ -99,7 +99,7 @@ function tryParseTag(raw: string): Anchor | undefined {
 function resolveEditAnchors(edits: HashlineEditItem[]): HashlineEdit[] {
 	const result: HashlineEdit[] = [];
 	for (const edit of edits) {
-		const lines = hashlineParseText(edit.lines);
+		const lines = parseHashlineText(edit.lines);
 		const tag = edit.pos ? tryParseTag(edit.pos) : undefined;
 		const end = edit.end ? tryParseTag(edit.end) : undefined;
 
@@ -207,9 +207,9 @@ export function createHashlineEditTool(cwd: string, options?: HashlineEditToolOp
 							for (const edit of edits) {
 								if ((edit.op === "append" || edit.op === "prepend") && !edit.pos && !edit.end) {
 									if (edit.op === "prepend") {
-										lines.unshift(...hashlineParseText(edit.lines));
+										lines.unshift(...parseHashlineText(edit.lines));
 									} else {
-										lines.push(...hashlineParseText(edit.lines));
+										lines.push(...parseHashlineText(edit.lines));
 									}
 								} else {
 									throw new Error(`File not found: ${path}`);

package/packages/pi-coding-agent/src/core/tools/hashline.test.ts

@@ -8,7 +8,7 @@ import {
 	validateLineRef,
 	applyHashlineEdits,
 	HashlineMismatchError,
-	hashlineParseText,
+	parseHashlineText,
 	stripNewLinePrefixes,
 	type HashlineEdit,
 	type Anchor,
@@ -395,31 +395,31 @@ describe("stripNewLinePrefixes", () => {
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-// hashlineParseText
+// parseHashlineText
 // ═══════════════════════════════════════════════════════════════════════════
 
-describe("hashlineParseText", () => {
+describe("parseHashlineText", () => {
 	it("returns empty array for null", () => {
-		assert.deepEqual(hashlineParseText(null), []);
+		assert.deepEqual(parseHashlineText(null), []);
 	});
 
 	it("returns array input as-is when no strip heuristic applies", () => {
 		const input = ["- [x] done", "- [ ] todo"];
-		assert.equal(hashlineParseText(input), input);
+		assert.equal(parseHashlineText(input), input);
 	});
 
 	it("splits string on newline and preserves Markdown list '-' prefix", () => {
-		const result = hashlineParseText("- item one\n- item two\n- item three");
+		const result = parseHashlineText("- item one\n- item two\n- item three");
 		assert.deepEqual(result, ["- item one", "- item two", "- item three"]);
 	});
 
 	it("strips '+' diff markers from string input", () => {
-		const result = hashlineParseText("+line one\n+line two");
+		const result = parseHashlineText("+line one\n+line two");
 		assert.deepEqual(result, ["line one", "line two"]);
 	});
 
 	it("still strips trailing empty from string split", () => {
-		assert.deepEqual(hashlineParseText("foo\n"), ["foo"]);
+		assert.deepEqual(parseHashlineText("foo\n"), ["foo"]);
 	});
 });
 

package/packages/pi-coding-agent/src/core/tools/hashline.ts

@@ -230,7 +230,7 @@ export function stripNewLinePrefixes(lines: string[]): string[] {
  * Parse edit content — handles string, array, or null input.
  * Strips hashline prefixes and diff markers from model output.
  */
-export function hashlineParseText(edit: string[] | string | null): string[] {
+export function parseHashlineText(edit: string[] | string | null): string[] {
 	if (edit === null) return [];
 	if (typeof edit === "string") {
 		const normalizedEdit = edit.endsWith("\n") ? edit.slice(0, -1) : edit;

package/packages/pi-coding-agent/src/core/tools/index.ts

@@ -99,7 +99,7 @@ export {
 	formatLineTag,
 	type HashlineEdit,
 	HashlineMismatchError,
-	hashlineParseText,
+	parseHashlineText,
 	type HashMismatch,
 	parseTag,
 	stripNewLinePrefixes,

package/packages/pi-coding-agent/src/core/tools/path-utils.ts

@@ -2,7 +2,7 @@ import { accessSync, constants } from "node:fs";
 import * as os from "node:os";
 import { isAbsolute, resolve as resolvePath } from "node:path";
 
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+export const UNICODE_SPACES = /[\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/g;
 const NARROW_NO_BREAK_SPACE = "\u202F";
 function normalizeUnicodeSpaces(str: string): string {
 	return str.replace(UNICODE_SPACES, " ");

package/packages/pi-coding-agent/src/core/tools/truncate.ts

@@ -8,7 +8,9 @@
  * Never returns partial lines (except bash tail truncation edge case).
  */
 
-export const DEFAULT_MAX_LINES = 2000;
+import { TRUNCATE_DEFAULT_MAX_LINES } from "../constants.js";
+
+export const DEFAULT_MAX_LINES = TRUNCATE_DEFAULT_MAX_LINES;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
 

package/packages/pi-coding-agent/src/index.ts

@@ -302,7 +302,16 @@ export {
 	type PrintModeOptions,
 	runPrintMode,
 	runRpcMode,
+	type ModelInfo,
+	RpcClient,
+	type RpcClientOptions,
+	type RpcEventListener,
+	type RpcCommand,
+	type RpcResponse,
+	type RpcSessionState,
 } from "./modes/index.js";
+// RPC JSONL utilities
+export { attachJsonlLineReader, serializeJsonLine } from "./modes/rpc/jsonl.js";
 // UI components for extensions
 export {
 	ArminComponent,

package/packages/pi-coding-agent/src/main.ts

@@ -577,6 +577,13 @@ async function handleConfigCommand(args: string[]): Promise<boolean> {
 }
 
 export async function main(args: string[]) {
+	// Catch unhandled promise rejections so the process doesn't silently disappear
+	process.on("unhandledRejection", (reason) => {
+		const message = reason instanceof Error ? reason.stack ?? reason.message : String(reason);
+		console.error(`\nFatal: unhandled promise rejection\n${message}`);
+		process.exitCode = 1;
+	});
+
 	const offlineMode = args.includes("--offline") || isTruthyEnvFlag(process.env.PI_OFFLINE);
 	if (offlineMode) {
 		process.env.PI_OFFLINE = "1";

package/packages/pi-coding-agent/src/modes/interactive/components/extension-selector.ts

@@ -1,6 +1,7 @@
 /**
  * Generic selector component for extensions.
  * Displays a list of string options with keyboard navigation.
+ * Options starting with SEPARATOR_PREFIX are rendered as non-selectable group headers.
  */
 
 import { Container, getEditorKeybindings, Spacer, Text, type TUI } from "@gsd/pi-tui";
@@ -9,6 +10,9 @@ import { CountdownTimer } from "./countdown-timer.js";
 import { DynamicBorder } from "./dynamic-border.js";
 import { keyHint, rawKeyHint } from "./keybinding-hints.js";
 
+/** Prefix that marks an option as a non-selectable group header. */
+export const SEPARATOR_PREFIX = "───";
+
 export interface ExtensionSelectorOptions {
 	tui?: TUI;
 	timeout?: number;
@@ -71,16 +75,42 @@ export class ExtensionSelectorComponent extends Container {
 		this.addChild(new Spacer(1));
 		this.addChild(new DynamicBorder());
 
+		// Start on the first selectable (non-separator) item
+		this.selectedIndex = this.nextSelectable(0, 1);
 		this.updateList();
 	}
 
+	private isSeparator(index: number): boolean {
+		return this.options[index]?.startsWith(SEPARATOR_PREFIX) ?? false;
+	}
+
+	/**
+	 * Find the next selectable index starting from `from` in the given direction.
+	 * Returns `from` clamped to bounds if nothing selectable is found.
+	 */
+	private nextSelectable(from: number, direction: 1 | -1): number {
+		let idx = from;
+		while (idx >= 0 && idx < this.options.length && this.isSeparator(idx)) {
+			idx += direction;
+		}
+		if (idx < 0 || idx >= this.options.length) {
+			return Math.max(0, Math.min(from, this.options.length - 1));
+		}
+		return idx;
+	}
+
 	private updateList(): void {
 		this.listContainer.clear();
 		for (let i = 0; i < this.options.length; i++) {
+			const option = this.options[i];
+			if (this.isSeparator(i)) {
+				this.listContainer.addChild(new Text(theme.fg("borderAccent", `  ${option}`), 1, 0));
+				continue;
+			}
 			const isSelected = i === this.selectedIndex;
 			const text = isSelected
-				? theme.fg("accent", "→ ") + theme.fg("accent", this.options[i])
-				: `  ${theme.fg("text", this.options[i])}`;
+				? theme.fg("accent", "→ ") + theme.fg("accent", option)
+				: `  ${theme.fg("text", option)}`;
 			this.listContainer.addChild(new Text(text, 1, 0));
 		}
 	}
@@ -88,14 +118,28 @@ export class ExtensionSelectorComponent extends Container {
 	handleInput(keyData: string): void {
 		const kb = getEditorKeybindings();
 		if (kb.matches(keyData, "selectUp") || keyData === "k") {
-			this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+			let next = this.selectedIndex - 1;
+			if (next < 0) next = this.options.length - 1;
+			next = this.nextSelectable(next, -1);
+			if (this.isSeparator(next)) {
+				next = this.nextSelectable(this.options.length - 1, -1);
+			}
+			this.selectedIndex = next;
 			this.updateList();
 		} else if (kb.matches(keyData, "selectDown") || keyData === "j") {
-			this.selectedIndex = Math.min(this.options.length - 1, this.selectedIndex + 1);
+			let next = this.selectedIndex + 1;
+			if (next >= this.options.length) next = 0;
+			next = this.nextSelectable(next, 1);
+			if (this.isSeparator(next)) {
+				next = this.nextSelectable(0, 1);
+			}
+			this.selectedIndex = next;
 			this.updateList();
 		} else if (kb.matches(keyData, "selectConfirm") || keyData === "\n") {
 			const selected = this.options[this.selectedIndex];
-			if (selected) this.onSelectCallback(selected);
+			if (selected && !this.isSeparator(this.selectedIndex)) {
+				this.onSelectCallback(selected);
+			}
 		} else if (kb.matches(keyData, "selectCancel")) {
 			this.onCancelCallback();
 		}

package/packages/pi-coding-agent/src/modes/interactive/components/index.ts

@@ -12,7 +12,7 @@ export { type RenderDiffOptions, renderDiff } from "./diff.js";
 export { DynamicBorder } from "./dynamic-border.js";
 export { ExtensionEditorComponent } from "./extension-editor.js";
 export { ExtensionInputComponent } from "./extension-input.js";
-export { ExtensionSelectorComponent } from "./extension-selector.js";
+export { ExtensionSelectorComponent, SEPARATOR_PREFIX } from "./extension-selector.js";
 export { FooterComponent } from "./footer.js";
 export { appKey, appKeyHint, editorKey, keyHint, rawKeyHint } from "./keybinding-hints.js";
 export { LoginDialogComponent } from "./login-dialog.js";