@oh-my-pi/pi-coding-agent 15.12.3 → 15.12.4

package/src/session/agent-storage.ts

@@ -4,6 +4,7 @@ import * as path from "node:path";
 import {
 	type AuthCredential,
 	type AuthCredentialStore,
+	isSqliteBusyError,
 	SqliteAuthCredentialStore,
 	type StoredAuthCredential,
 } from "@oh-my-pi/pi-ai";
@@ -78,10 +79,14 @@ export class AgentStorage {
 	 * AuthCredentialStore handles auth_credentials and cache tables.
 	 */
 	#initializeSchema(): void {
+		// Install the busy handler BEFORE any lock-taking statement (incl.
+		// `PRAGMA journal_mode=WAL`, which acquires an exclusive lock during WAL
+		// recovery). Without this, concurrent omp startups can crash here with
+		// `SQLITE_BUSY` / `SQLITE_BUSY_RECOVERY`. See issue #2421.
+		this.#db.run("PRAGMA busy_timeout = 5000");
 		this.#db.run(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS model_usage (
 	model_key TEXT PRIMARY KEY,
@@ -208,7 +213,8 @@ FROM model_usage_legacy
 
 	/**
 	 * Returns singleton instance for the given database path, creating if needed.
-	 * Retries on SQLITE_BUSY with exponential backoff.
+	 * Retries on the `SQLITE_BUSY` family (including `SQLITE_BUSY_RECOVERY`) with
+	 * exponential backoff. See issue #2421.
 	 * @param dbPath - Path to the SQLite database file (defaults to config path)
 	 * @returns AgentStorage instance for the given path
 	 */
@@ -216,7 +222,7 @@ FROM model_usage_legacy
 		const existing = instances.get(dbPath);
 		if (existing) return existing;
 
-		const maxRetries = 3;
+		const maxRetries = 4;
 		const baseDelayMs = 100;
 		let lastError: Error | undefined;
 
@@ -226,17 +232,20 @@ FROM model_usage_legacy
 				instances.set(dbPath, storage);
 				return storage;
 			} catch (err) {
-				const isSqliteBusy = err && typeof err === "object" && (err as { code?: string }).code === "SQLITE_BUSY";
-				if (!isSqliteBusy) {
+				if (!isSqliteBusyError(err)) {
 					throw err;
 				}
-				lastError = err as Error;
-				const delayMs = baseDelayMs * 2 ** attempt;
-				await Bun.sleep(delayMs);
+				lastError = err instanceof Error ? err : new Error(String(err));
+				if (attempt < maxRetries - 1) {
+					await Bun.sleep(baseDelayMs * 2 ** attempt);
+				}
 			}
 		}
 
-		throw lastError ?? new Error("Failed to open database after retries");
+		throw new Error(
+			`Failed to open agent database at '${dbPath}' after ${maxRetries} attempts: ${lastError?.message}`,
+			{ cause: lastError },
+		);
 	}
 
 	/**

package/src/session/history-storage.ts

@@ -86,10 +86,11 @@ export class HistoryStorage {
 
 		const hasFts = this.#db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='history_fts'").get();
 
+		// Install the busy handler BEFORE any lock-taking statement. See #2421.
+		this.#db.run("PRAGMA busy_timeout = 5000");
 		this.#db.run(`
 PRAGMA journal_mode=WAL;
 PRAGMA synchronous=NORMAL;
-PRAGMA busy_timeout=5000;
 
 CREATE TABLE IF NOT EXISTS history (
 	id INTEGER PRIMARY KEY AUTOINCREMENT,

package/src/session/indexed-session-storage.ts

@@ -414,6 +414,13 @@ class IndexedSessionStorageWriter implements SessionStorageWriter {
 		await this.flush();
 	}
 
+	fsyncSync(): void {
+		// Indexed storage has no real fd to fsync; drain the pending chain
+		// synchronously is not possible, so this is a no-op. The async flush()
+		// above already ensures durability for the indexed backend.
+		if (this.#error) throw this.#error;
+	}
+
 	async close(): Promise<void> {
 		if (this.#closed) return;
 		this.#closed = true;

package/src/session/messages.ts

@@ -40,13 +40,11 @@ export interface SkillPromptDetails {
 	path: string;
 	args?: string;
 	lineCount: number;
-	/** Internal: tag used by AgentSession to remove the pending-display chip
-	 *  from `#steeringMessages` / `#followUpMessages` when the agent consumes
-	 *  this message. Not surfaced to renderers; the `__` prefix signals
-	 *  "private". Optional — non-streaming skill prompts never set it. Stripped
-	 *  from persisted `details` by `SessionManager.appendCustomMessageEntry`
-	 *  via the `INTERNAL_DETAILS_FIELDS` allowlist below. */
-	__pendingDisplayTag?: string;
+	/** Internal: compact label shown for a queued custom message. Optional —
+	 *  non-streaming skill prompts never set it. Stripped from persisted
+	 *  `details` by `SessionManager.appendCustomMessageEntry` via the
+	 *  `INTERNAL_DETAILS_FIELDS` allowlist below. */
+	__queueChipText?: string;
 }
 
 /** Sentinel value for `AssistantMessage.errorMessage` indicating that the abort
@@ -104,12 +102,12 @@ export function resolveAbortLabel(errorMessage: string | undefined, retryAttempt
 	return "Operation aborted";
 }
 
-/** Extract the optional `__pendingDisplayTag` field from a CustomMessage's
+/** Extract the optional `__queueChipText` field from a CustomMessage's
  *  `details` blob. Safe over `unknown`; returns undefined when the field is
  *  absent or non-string. */
-export function readPendingDisplayTag(details: unknown): string | undefined {
+export function readQueueChipText(details: unknown): string | undefined {
 	if (typeof details !== "object" || details === null) return undefined;
-	const candidate = (details as { __pendingDisplayTag?: unknown }).__pendingDisplayTag;
+	const candidate = (details as { __queueChipText?: unknown }).__queueChipText;
 	return typeof candidate === "string" ? candidate : undefined;
 }
 
@@ -118,7 +116,7 @@ export function readPendingDisplayTag(details: unknown): string | undefined {
  *  the CustomMessageEntry to disk. Scoped intentionally narrow: only fields
  *  declared here are stripped. Adding a new entry is a deliberate, reviewed
  *  change — unrelated future payload fields are never silently dropped. */
-export const INTERNAL_DETAILS_FIELDS = ["__pendingDisplayTag"] as const;
+export const INTERNAL_DETAILS_FIELDS = ["__queueChipText"] as const;
 
 /** Return a `details` copy with every key in `INTERNAL_DETAILS_FIELDS`
  *  removed. Returns the input unchanged when there is nothing to strip

package/src/session/session-dump-format.ts

@@ -5,6 +5,7 @@ import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { INTENT_FIELD } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import { isZodSchema, zodToWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
+import { getVisibleThinkingText } from "../utils/thinking-display";
 import {
 	type BashExecutionMessage,
 	type BranchSummaryMessage,
@@ -126,9 +127,10 @@ export function formatSessionDumpText(options: FormatSessionDumpTextOptions): st
 				if (c.type === "text") {
 					lines.push(c.text);
 				} else if (c.type === "thinking") {
-					if (c.thinking.trim().length === 0) continue;
+					const thinking = getVisibleThinkingText(c);
+					if (thinking.length === 0) continue;
 					lines.push("<thinking>");
-					lines.push(c.thinking);
+					lines.push(thinking);
 					lines.push("</thinking>\n");
 				} else if (c.type === "toolCall") {
 					lines.push(`<invoke name="${c.name}">`);

package/src/session/session-manager.ts

@@ -1527,6 +1527,17 @@ class NdjsonFileWriter {
 		}
 	}
 
+	/** Synchronously fsync the underlying file descriptor to physical disk. */
+	fsyncSync(): void {
+		if (this.#closed) return;
+		if (this.#error) throw this.#error;
+		try {
+			this.#writer.fsyncSync();
+		} catch (err) {
+			throw this.#recordError(err);
+		}
+	}
+
 	/** Close the writer, flushing all data. */
 	async close(): Promise<void> {
 		if (this.#closed || this.#closing) return;
@@ -2592,6 +2603,111 @@ export class SessionManager {
 		if (this.#persistError) throw this.#persistError;
 	}
 
+	/**
+	 * Synchronously flush all in-memory entries to disk and fsync.
+	 * Use when the process may exit before an async flush settles (e.g. Ctrl+C
+	 * in the TUI, where raw mode consumes the keystroke so postmortem's SIGINT
+	 * handler never fires).
+	 *
+	 * Hot path: the persist writer is open and flushed, so a single fsyncSync
+	 * pushes the page-cache data to physical disk.
+	 *
+	 * Cold path: entries are only in memory (session just started, or a rewrite
+	 * is pending). Writes all entries to a temp file, fsyncs, and atomically
+	 * renames over the session file — then re-opens an append writer so the
+	 * hot path resumes on subsequent `_persist` calls.
+	 */
+	flushSync(): void {
+		if (!this.persist || !this.#sessionFile) return;
+		if (this.#persistError) throw this.#persistError;
+
+		// Hot path: writer is open and all entries have been written via writeSync.
+		// Just fsync the fd — the data is already in the kernel page cache.
+		if (this.#persistWriter?.isOpen() && this.#flushed && !this.#needsFullRewriteOnNextPersist) {
+			this.#persistWriter.fsyncSync();
+			return;
+		}
+
+		// Cold path: write all in-memory entries to a temp file and atomically
+		// replace the session file. This is safe to run even when an async
+		// rewrite is queued on #persistChain: the async task won't progress
+		// while we're on the sync call stack, and the file we produce is a
+		// superset of whatever the async rewrite would write.
+		const dir = path.resolve(this.#sessionFile, "..");
+		const tempPath = path.join(dir, `.${path.basename(this.#sessionFile)}.${Snowflake.next()}.tmp`);
+		const fd = fs.openSync(tempPath, "w");
+		try {
+			for (const entry of this.#fileEntries) {
+				const persisted = prepareEntryForPersistenceSync(entry, this.#blobStore);
+				const line = `${JSON.stringify(persisted)}\n`;
+				fs.writeSync(fd, line);
+			}
+			fs.fsyncSync(fd);
+		} finally {
+			fs.closeSync(fd);
+		}
+
+		// Atomic replace (with EPERM retry for Windows)
+		try {
+			fs.renameSync(tempPath, this.#sessionFile);
+		} catch (err) {
+			if (!hasFsCode(err, "EPERM")) {
+				try {
+					fs.unlinkSync(tempPath);
+				} catch {
+					/* best effort */
+				}
+				throw toError(err);
+			}
+			// Windows: move the old file aside, then rename
+			const backupPath = path.join(dir, `${path.basename(this.#sessionFile)}.${Snowflake.next()}.bak`);
+			try {
+				fs.renameSync(this.#sessionFile, backupPath);
+			} catch (moveAsideErr) {
+				if (isEnoent(moveAsideErr)) {
+					fs.renameSync(tempPath, this.#sessionFile);
+					return;
+				}
+				try {
+					fs.unlinkSync(tempPath);
+				} catch {
+					/* best effort */
+				}
+				throw toError(err);
+			}
+			try {
+				fs.renameSync(tempPath, this.#sessionFile);
+			} catch (replaceErr) {
+				// Roll back
+				try {
+					fs.renameSync(backupPath, this.#sessionFile);
+				} catch {
+					/* best effort */
+				}
+				throw toError(replaceErr);
+			}
+			try {
+				fs.unlinkSync(backupPath);
+			} catch {
+				/* best effort */
+			}
+		}
+
+		// Re-open the persist writer in append mode so the hot path resumes.
+		if (this.#persistWriter) {
+			// The old writer is stale (pointed at the pre-rewrite file or was
+			// mid-close). Close it asynchronously — it's a no-op if already
+			// closed, and we don't want to block on draining its queue.
+			void this.#persistWriter.close().catch(() => {});
+		}
+		this.#persistWriter = new NdjsonFileWriter(this.storage, this.#sessionFile, {
+			onError: err => this.#recordPersistError(err),
+		});
+		this.#persistWriterPath = this.#sessionFile;
+		this.#flushed = true;
+		this.#needsFullRewriteOnNextPersist = false;
+	}
+
 	/** Close the persistent writer after flushing all pending data. */
 	async close(): Promise<void> {
 		if (!this.#persistWriter) return;

package/src/session/session-storage.ts

@@ -23,6 +23,11 @@ export interface SessionStorageWriter {
 	writeLineSync(line: string): void;
 	flush(): Promise<void>;
 	fsync(): Promise<void>;
+	/**
+	 * Synchronously fsync the underlying file descriptor. Returns once the data
+	 * is on the physical disk. Throws synchronously on I/O error.
+	 */
+	fsyncSync(): void;
 	close(): Promise<void>;
 	getError(): Error | undefined;
 }
@@ -118,6 +123,16 @@ class FileSessionStorageWriter implements SessionStorageWriter {
 		}
 	}
 
+	fsyncSync(): void {
+		if (this.#closed) throw new Error("Writer closed");
+		if (this.#error) throw this.#error;
+		try {
+			fs.fsyncSync(this.#fd);
+		} catch (err) {
+			throw this.#recordError(err);
+		}
+	}
+
 	async close(): Promise<void> {
 		if (this.#closed) return;
 		this.#closed = true;
@@ -291,6 +306,11 @@ class MemorySessionStorageWriter implements SessionStorageWriter {
 		if (this.#error) throw this.#error;
 	}
 
+	fsyncSync(): void {
+		// No-op for in-memory storage
+		if (this.#error) throw this.#error;
+	}
+
 	async close(): Promise<void> {
 		if (this.#closed) return;
 		this.#closed = true;

package/src/slash-commands/builtin-registry.ts

@@ -1005,7 +1005,21 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 	{
 		name: "logout",
 		description: "Logout from OAuth provider",
-		handleTui: (_command, runtime) => {
+		inlineHint: "[provider]",
+		allowArgs: true,
+		handleTui: (command, runtime) => {
+			const providerId = command.args.trim();
+			if (providerId) {
+				const matchedProvider = getOAuthProviders().find(provider => provider.id === providerId);
+				if (!matchedProvider) {
+					runtime.ctx.showWarning(`Unknown OAuth provider: ${providerId}`);
+					runtime.ctx.editor.setText("");
+					return;
+				}
+				void runtime.ctx.showOAuthSelector("logout", matchedProvider.id);
+				runtime.ctx.editor.setText("");
+				return;
+			}
 			void runtime.ctx.showOAuthSelector("logout");
 			runtime.ctx.editor.setText("");
 		},

package/src/slash-commands/helpers/logout.ts

@@ -0,0 +1,88 @@
+import type { OAuthAccountIdentity, StoredAuthCredential } from "../../session/auth-storage";
+
+export interface LogoutAccount {
+	credentialId: number;
+	provider: string;
+	label: string;
+	detail: string;
+	type: "api_key" | "oauth";
+	active: boolean;
+}
+
+interface LogoutAccountOptions {
+	activeIdentity?: OAuthAccountIdentity;
+	activeApiKey?: boolean;
+}
+
+function nonEmpty(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+
+function oauthLabel(row: StoredAuthCredential): string {
+	const credential = row.credential;
+	if (credential.type !== "oauth") return `API key #${row.id}`;
+	return (
+		nonEmpty(credential.email) ??
+		nonEmpty(credential.accountId) ??
+		nonEmpty(credential.projectId) ??
+		nonEmpty(credential.enterpriseUrl) ??
+		`OAuth credential #${row.id}`
+	);
+}
+
+function oauthDetail(row: StoredAuthCredential, label: string): string {
+	const credential = row.credential;
+	if (credential.type === "api_key") return `stored API key #${row.id}`;
+	const parts: string[] = [];
+	const email = nonEmpty(credential.email);
+	const accountId = nonEmpty(credential.accountId);
+	const projectId = nonEmpty(credential.projectId);
+	const enterpriseUrl = nonEmpty(credential.enterpriseUrl);
+	if (email && email !== label) parts.push(email);
+	if (accountId && accountId !== label) parts.push(`account ${accountId}`);
+	if (projectId && projectId !== label) parts.push(`project ${projectId}`);
+	if (enterpriseUrl && enterpriseUrl !== label) parts.push(enterpriseUrl);
+	parts.push(`oauth #${row.id}`);
+	return parts.join(" · ");
+}
+
+function oauthMatchesActiveIdentity(
+	row: StoredAuthCredential,
+	activeIdentity: OAuthAccountIdentity | undefined,
+): boolean {
+	if (!activeIdentity || row.credential.type !== "oauth") return false;
+	const credential = row.credential;
+	return (
+		(activeIdentity.accountId !== undefined && credential.accountId === activeIdentity.accountId) ||
+		(activeIdentity.email !== undefined && credential.email === activeIdentity.email) ||
+		(activeIdentity.projectId !== undefined && credential.projectId === activeIdentity.projectId)
+	);
+}
+
+export function toLogoutAccounts(
+	provider: string,
+	credentials: StoredAuthCredential[],
+	options: LogoutAccountOptions = {},
+): LogoutAccount[] {
+	return credentials
+		.map(row => {
+			const label = oauthLabel(row);
+			const active =
+				row.credential.type === "oauth"
+					? oauthMatchesActiveIdentity(row, options.activeIdentity)
+					: options.activeApiKey === true;
+			return {
+				credentialId: row.id,
+				provider,
+				label,
+				detail: oauthDetail(row, label),
+				type: row.credential.type,
+				active,
+			} satisfies LogoutAccount;
+		})
+		.sort((left, right) => {
+			if (left.active !== right.active) return left.active ? -1 : 1;
+			return left.label.localeCompare(right.label) || left.credentialId - right.credentialId;
+		});
+}

package/src/task/types.ts

@@ -1,7 +1,7 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { AgentSessionEvent } from "../session/agent-session";
 import type { NestedRepoPatch } from "./worktree";
 

package/src/tools/ask.ts

@@ -18,7 +18,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { type Component, Markdown, type MarkdownTheme, renderInlineMarkdown, TERMINAL, Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { ExtensionUISelectItem } from "../extensibility/extensions";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";

package/src/tools/ast-edit.ts

@@ -5,7 +5,7 @@ import { type AstReplaceChange, type AstReplaceFileChange, astEdit } from "@oh-m
 import type { Component } from "@oh-my-pi/pi-tui";
 import { replaceTabs, Text } from "@oh-my-pi/pi-tui";
 import { $envpos, prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { canonicalSnapshotKey, getFileSnapshotStore } from "../edit/file-snapshot-store";
 import { normalizeToLF } from "../edit/normalize";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";

package/src/tools/ast-grep.ts

@@ -5,7 +5,7 @@ import { type AstFindMatch, astGrep } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { recordFileSnapshot } from "../edit/file-snapshot-store";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";

package/src/tools/bash.ts

@@ -9,7 +9,7 @@ import type {
 import type { Component } from "@oh-my-pi/pi-tui";
 import { ImageProtocol, TERMINAL } from "@oh-my-pi/pi-tui";
 import { getProjectDir, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { type BashResult, executeBash } from "../exec/bash-executor";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { InternalUrlRouter } from "../internal-urls";