@oh-my-pi/pi-coding-agent 16.1.1 → 16.1.2

package/dist/types/cli/bench-cli.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKeyResolver, AssistantMessageEventStream, Context, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
-import type { CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
+import { type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import type { ApiKeyResolverModel } from "../config/api-key-resolver";
 import { type CanonicalModelQueryOptions } from "../config/model-registry";
 import { Settings } from "../config/settings";
@@ -20,6 +20,7 @@ export interface BenchModelRegistry {
     resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
     getCanonicalVariants?(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
     getCanonicalId?(model: Model<Api>): string | undefined;
+    hasConfiguredAuth?(model: Model<Api>): boolean;
 }
 export interface BenchRuntime {
     modelRegistry: BenchModelRegistry;

package/dist/types/config/settings-schema.d.ts

@@ -874,7 +874,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly inlineToolDescriptors: {
         readonly type: "boolean";
-        readonly default: true;
+        readonly default: false;
         readonly ui: {
             readonly tab: "model";
             readonly group: "Prompt";

package/dist/types/main.d.ts

@@ -54,6 +54,8 @@ export declare class SessionResolutionError extends Error {
 }
 /** Resolves CLI session flags into an existing, forked, in-memory, or cancelled session manager. */
 export declare function createSessionManager(parsed: Args, cwd: string, activeSettings?: Settings, askToForkSession?: SessionPrompt, askToMoveSession?: SessionPrompt): Promise<SessionManager | undefined>;
+/** Apply resolved CLI/discovered prompt files without bypassing system prompt templates. */
+export declare function applyResolvedSystemPromptInputs(options: CreateAgentSessionOptions, resolvedSystemPrompt: string | undefined, resolvedAppendPrompt: string | undefined): void;
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;

package/dist/types/modes/components/assistant-message.d.ts

@@ -28,6 +28,18 @@ export declare class AssistantMessageComponent extends Container {
      */
     setErrorPinned(pinned: boolean): void;
     isTranscriptBlockFinalized(): boolean;
+    /**
+     * Whether this still-live block's scrolled-off rows may be committed to
+     * immutable native scrollback (the {@link TranscriptContainer} durable-
+     * snapshot path). Reflowing Markdown — a streaming mermaid diagram or a GFM
+     * table — re-lays-out its body as source arrives (the diagram reshapes, the
+     * table re-aligns its columns), so committing an intermediate layout strands
+     * a stale fragment in native scrollback that only a full repaint (Ctrl+L) can
+     * clear. While such content is still streaming the block therefore stays
+     * wholly in the repaintable live region and commits once, at its final
+     * layout, when the turn finalizes.
+     */
+    isTranscriptBlockCommitStable(): boolean;
     getTranscriptBlockVersion(): number;
     markTranscriptBlockFinalized(): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;

package/dist/types/modes/components/welcome.d.ts

@@ -9,7 +9,7 @@ export declare const WELCOME_SESSION_SLOTS = 4;
  * the box height is constant regardless of how many servers a project has.
  */
 export declare const WELCOME_LSP_SLOTS = 4;
-export declare function renderWelcomeTip(tip: string, boxWidth: number): string[];
+export declare function renderWelcomeTip(tip: string, boxWidth: number, phase?: number): string[];
 export interface RecentSession {
     name: string;
     timeAgo: string;

package/dist/types/sdk.d.ts

@@ -18,7 +18,7 @@ import { MCPManager, type MCPToolsLoadResult } from "./mcp";
 import type { MnemopiSessionState } from "./mnemopi/state";
 import { AgentRegistry } from "./registry/agent-registry";
 import { AgentSession } from "./session/agent-session";
-import { AuthStorage } from "./session/auth-storage";
+import type { AuthStorage } from "./session/auth-storage";
 import { SessionManager } from "./session/session-manager";
 import { type BuildSystemPromptResult } from "./system-prompt";
 import { type ConfiguredThinkingLevel } from "./thinking";
@@ -48,8 +48,12 @@ export interface CreateAgentSessionOptions {
         model: Model;
         thinkingLevel?: ThinkingLevel;
     }>;
-    /** System prompt blocks. Array replaces default, function receives default blocks and returns final blocks. */
+    /** Provider-facing system prompt override. Replaces the fully rendered default blocks. */
     systemPrompt?: string | string[] | ((defaultPrompt: string[]) => string | string[]);
+    /** Already-loaded custom prompt text rendered through the bundled custom system prompt template. */
+    customSystemPrompt?: string;
+    /** Already-loaded text appended through the bundled system prompt templates. */
+    appendSystemPrompt?: string;
     /** Optional provider-facing session identifier for prompt caches and sticky auth selection.
      * Keeps persisted session files isolated while reusing provider-side caches. */
     providerSessionId?: string;
@@ -179,6 +183,15 @@ export interface CreateAgentSessionOptions {
      * `@opentelemetry/api` package returns a no-op tracer in that case.
      */
     telemetry?: AgentTelemetryConfig;
+    /**
+     * Fired once, when the agent loop hands its first request to the provider
+     * transport (i.e. the `streamFn` wrapper is first invoked). Used to measure
+     * subagent launch latency — the boundary between "session built" and "model
+     * call dispatched". This is the loop's dispatch point, slightly before the
+     * actual provider HTTP call (per-request prep, identical across all
+     * requests, follows it), which is the right granularity for launch timing.
+     */
+    onFirstChatDispatch?: () => void;
     /** Whether to auto-approve all tool calls (--auto-approve CLI flag). Default: false */
     autoApprove?: boolean;
 }
@@ -222,6 +235,9 @@ export { BashTool, BUILTIN_TOOLS, createTools, EditTool, EvalTool, FindTool, HID
  * the client receives access tokens with `refresh = "__remote__"` and calls
  * back into the broker through the {@link AuthStorageOptions.refreshOAuthCredential}
  * override to re-mint access tokens when needed.
+ *
+ * Delegates to {@link ./session/auth-broker-config} so the TUI and the catalog
+ * generator share the same credential-discovery logic.
  */
 export declare function discoverAuthStorage(agentDir?: string): Promise<AuthStorage>;
 /**
@@ -287,6 +303,7 @@ export interface BuildSystemPromptOptions {
         content: string;
     }>;
     cwd?: string;
+    customPrompt?: string;
     appendPrompt?: string;
     inlineToolDescriptors?: boolean;
 }

package/dist/types/session/auth-broker-config.d.ts

@@ -1,9 +1,27 @@
-export interface AuthBrokerClientConfig {
-    url: string;
-    token: string;
-}
-/** Path to the local bearer token file. Created on the broker host by `omp auth-broker token`. */
-export declare function getAuthBrokerTokenFilePath(): string;
+/**
+ * Resolve auth-broker connection configuration for the local omp client.
+ *
+ * This is a thin coding-agent wrapper around the shared resolver in
+ * `@oh-my-pi/pi-ai/auth-broker/discover` that preserves the process-lifetime
+ * memoization expected by the CLI and injects the full `resolveConfigValue`
+ * (including `!command` config indirection) from coding-agent's config layer.
+ *
+ * Precedence (highest first):
+ *   1. `OMP_AUTH_BROKER_URL` / `OMP_AUTH_BROKER_TOKEN` env vars.
+ *   2. `auth.broker.url` / `auth.broker.token` in `~/.omp/agent/config.yml`
+ *      (hidden from the settings UI; `!command` resolution supported).
+ *   3. Token file `~/.omp/auth-broker.token` (paired with URL from env or config).
+ *
+ * Returns null when no broker URL is configured — caller falls back to the
+ * local SQLite store.
+ *
+ * Reads config.yml directly (instead of going through `Settings.init`) because
+ * `discoverAuthStorage` runs before the settings singleton is initialized in
+ * `runRootCommand`, and we want hand-edited config entries to be honoured at
+ * boot without forcing a startup reorder.
+ */
+import { type AuthBrokerClientConfig, type DiscoverAuthStorageOptions, discoverAuthStorage as discoverAuthStorageShared, getAuthBrokerTokenFilePath } from "@oh-my-pi/pi-ai/auth-broker/discover";
+export { type AuthBrokerClientConfig, getAuthBrokerTokenFilePath };
 /**
  * Read broker configuration. Returns null when the URL is missing
  * (broker disabled — local store is used). Throws when URL is set but no
@@ -15,3 +33,12 @@ export declare function getAuthBrokerTokenFilePath(): string;
  * retried. Concurrent callers share one in-flight resolution.
  */
 export declare function resolveAuthBrokerConfig(): Promise<AuthBrokerClientConfig | null>;
+/**
+ * Create an AuthStorage instance, using the broker when configured and falling
+ * back to the local SQLite store otherwise. Delegates to the shared resolver in
+ * pi-ai so the CLI, subagents, and the catalog generator all see the same
+ * credentials.
+ *
+ * Default `agentDir` is the current configured agent directory.
+ */
+export declare function discoverAuthStorage(agentDir?: string, options?: Omit<DiscoverAuthStorageOptions, "agentDir" | "configValueResolver">): ReturnType<typeof discoverAuthStorageShared>;

package/dist/types/system-prompt.d.ts

@@ -48,13 +48,17 @@ export declare function buildSystemPromptToolMetadata(tools: Map<string, AgentTo
 export interface BuildSystemPromptOptions {
     /** Custom system prompt (replaces default). */
     customPrompt?: string;
+    /** Already-loaded custom system prompt text; bypasses path resolution. */
+    resolvedCustomPrompt?: string;
     /** Tools to include in prompt. */
     tools?: Map<string, SystemPromptToolMetadata>;
     /** Tool names to include in prompt. */
     toolNames?: string[];
     /** Text to append to system prompt. */
     appendSystemPrompt?: string;
-    /** Inline full tool descriptors in the system prompt. Default: true */
+    /** Already-loaded append prompt text; bypasses path resolution. */
+    resolvedAppendSystemPrompt?: string;
+    /** Inline full tool descriptors in the system prompt. Default: false */
     inlineToolDescriptors?: boolean;
     /**
      * Whether provider-native tool calling is active (no owned/in-band syntax).

package/dist/types/task/executor.d.ts

@@ -83,6 +83,16 @@ export interface ExecutorOptions {
     enableLsp?: boolean;
     signal?: AbortSignal;
     onProgress?: (progress: AgentProgress) => void;
+    /**
+     * Epochs (ms, `Date.now()`) bracketing the concurrency-semaphore wait:
+     * `invokedAt` is stamped at the spawn boundary before `acquire()`,
+     * `acquiredAt` immediately after. {@link runSubprocess} reports true queue
+     * wait (`acquiredAt - invokedAt`) and pre-run setup (`startTime - acquiredAt`)
+     * separately in the launch-timing debug log. Undefined for callers that
+     * bypass the semaphore path.
+     */
+    invokedAt?: number;
+    acquiredAt?: number;
     sessionFile?: string | null;
     persistArtifacts?: boolean;
     artifactsDir?: string;

package/dist/types/tools/find.d.ts

@@ -11,7 +11,6 @@ declare const findSchema: import("arktype/internal/variants/object.ts").ObjectTy
     hidden?: boolean | undefined;
     gitignore?: boolean | undefined;
     limit?: number | undefined;
-    timeout?: number | undefined;
 }, {}>;
 export type FindToolInput = typeof findSchema.infer;
 export interface FindToolDetails {
@@ -70,7 +69,6 @@ export declare class FindTool implements AgentTool<typeof findSchema, FindToolDe
         hidden?: boolean | undefined;
         gitignore?: boolean | undefined;
         limit?: number | undefined;
-        timeout?: number | undefined;
     }, {}>;
     readonly examples: readonly ToolExample<typeof findSchema.infer>[];
     readonly strict = true;

package/dist/types/tools/search.d.ts

@@ -8,7 +8,7 @@ import type { OutputMeta } from "./output-meta";
 declare const searchSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     pattern: string;
     paths?: string | string[] | undefined;
-    i?: boolean | undefined;
+    case?: boolean | undefined;
     gitignore?: boolean | undefined;
     skip?: number | null | undefined;
 }, {}>;
@@ -67,7 +67,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
         pattern: string;
         paths?: string | string[] | undefined;
-        i?: boolean | undefined;
+        case?: boolean | undefined;
         gitignore?: boolean | undefined;
         skip?: number | null | undefined;
     }, {}>;
@@ -78,7 +78,7 @@ export declare class SearchTool implements AgentTool<typeof searchSchema, Search
 interface SearchRenderArgs {
     pattern: string;
     paths?: string | string[];
-    i?: boolean;
+    case?: boolean;
     gitignore?: boolean;
     skip?: number;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.1",
+	"version": "16.1.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.1",
-		"@oh-my-pi/omp-stats": "16.1.1",
-		"@oh-my-pi/pi-agent-core": "16.1.1",
-		"@oh-my-pi/pi-ai": "16.1.1",
-		"@oh-my-pi/pi-catalog": "16.1.1",
-		"@oh-my-pi/pi-mnemopi": "16.1.1",
-		"@oh-my-pi/pi-natives": "16.1.1",
-		"@oh-my-pi/pi-tui": "16.1.1",
-		"@oh-my-pi/pi-utils": "16.1.1",
-		"@oh-my-pi/pi-wire": "16.1.1",
-		"@oh-my-pi/snapcompact": "16.1.1",
+		"@oh-my-pi/hashline": "16.1.2",
+		"@oh-my-pi/omp-stats": "16.1.2",
+		"@oh-my-pi/pi-agent-core": "16.1.2",
+		"@oh-my-pi/pi-ai": "16.1.2",
+		"@oh-my-pi/pi-catalog": "16.1.2",
+		"@oh-my-pi/pi-mnemopi": "16.1.2",
+		"@oh-my-pi/pi-natives": "16.1.2",
+		"@oh-my-pi/pi-tui": "16.1.2",
+		"@oh-my-pi/pi-utils": "16.1.2",
+		"@oh-my-pi/pi-wire": "16.1.2",
+		"@oh-my-pi/snapcompact": "16.1.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/measure-prompt-tokens.ts

@@ -0,0 +1,63 @@
+import { countTokens } from "@oh-my-pi/pi-agent-core";
+import { Settings } from "@oh-my-pi/pi-coding-agent/config/settings";
+import { estimateToolSchemaTokens } from "@oh-my-pi/pi-coding-agent/modes/utils/context-usage";
+import { buildSystemPrompt } from "@oh-my-pi/pi-coding-agent/system-prompt";
+import { createTools, type Tool, type ToolSession } from "@oh-my-pi/pi-coding-agent/tools";
+
+function bytes(s: string): number {
+	return Buffer.byteLength(s, "utf-8");
+}
+function est(s: string): number {
+	return (bytes(s) + 3) >> 2;
+}
+
+await Settings.init({ inMemory: true, cwd: process.cwd() });
+const settings = Settings.isolated({});
+
+const session: ToolSession = {
+	cwd: process.cwd(),
+	hasUI: false,
+	getSessionFile: () => null,
+	getSessionSpawns: () => "*",
+	settings,
+} as ToolSession;
+
+const tools = await createTools(session);
+const toolsMap = new Map<string, Tool>(tools.map(t => [t.name, t]));
+
+console.log(`active tools (${tools.length}): ${tools.map(t => t.name).join(", ")}\n`);
+
+const rows: Array<{ name: string; descBytes: number; tok: number; schemaTok: number }> = [];
+for (const t of tools) {
+	const tok = estimateToolSchemaTokens([t as never]);
+	const descBytes = bytes(t.description ?? "");
+	const descTok = est(t.description ?? "");
+	rows.push({ name: t.name, descBytes, tok, schemaTok: tok - descTok });
+}
+rows.sort((a, b) => b.tok - a.tok);
+
+const totalTok = estimateToolSchemaTokens(tools as never);
+console.log("per-tool tokens (sorted): name | total tok | desc bytes | ~schema tok");
+for (const r of rows) {
+	console.log(
+		`  ${r.name.padEnd(20)} ${String(r.tok).padStart(6)}  ${String(r.descBytes).padStart(7)}  ${String(r.schemaTok).padStart(6)}`,
+	);
+}
+console.log(`\nTOOLS TOTAL tokens: ${totalTok}\n`);
+
+const built = await buildSystemPrompt({
+	tools: toolsMap as never,
+	toolNames: tools.map(t => t.name),
+	inlineToolDescriptors: false,
+	nativeTools: true,
+	cwd: process.cwd(),
+	skills: [],
+	contextFiles: [],
+	workspaceTree: { rootPath: process.cwd(), rendered: "", truncated: false, totalLines: 0, agentsMdFiles: [] },
+});
+const parts = built.systemPrompt;
+const part0 = parts[0] ?? "";
+const rest = parts.slice(1).join("\n");
+console.log(`system prompt parts: ${parts.length}`);
+console.log(`SYSTEM PROMPT tokens (part0, no skills): ${countTokens(part0)}  (bytes=${bytes(part0)})`);
+console.log(`SYSTEM CONTEXT tokens (parts[1..]): ${countTokens(rest)}  (bytes=${bytes(rest)})`);

package/src/cli/bench-cli.ts

@@ -11,7 +11,7 @@ import type {
 	SimpleStreamOptions,
 } from "@oh-my-pi/pi-ai";
 import { streamSimple } from "@oh-my-pi/pi-ai";
-import type { CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
+import { buildModelProviderPriorityRank, type CanonicalModelVariant } from "@oh-my-pi/pi-catalog/identity";
 import { replaceTabs, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { formatDuration, getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
@@ -50,6 +50,7 @@ export interface BenchModelRegistry {
 	resolveCanonicalModel?(canonicalId: string, options?: CanonicalModelQueryOptions): Model<Api> | undefined;
 	getCanonicalVariants?(canonicalId: string, options?: CanonicalModelQueryOptions): CanonicalModelVariant[];
 	getCanonicalId?(model: Model<Api>): string | undefined;
+	hasConfiguredAuth?(model: Model<Api>): boolean;
 }
 
 export interface BenchRuntime {
@@ -346,6 +347,56 @@ interface BenchTarget {
 	thinking: ResolvedThinkingLevel | undefined;
 }
 
+/** Highest-priority provider variant: native/OAuth transports outrank mirrors. */
+function pickHighestPriorityProvider(models: Model<Api>[], providerOrder?: readonly string[]): Model<Api> | undefined {
+	if (models.length <= 1) return models[0];
+	const priority = buildModelProviderPriorityRank(providerOrder);
+	return [...models].sort((a, b) => {
+		const aRank = priority.get(a.provider.toLowerCase()) ?? Number.POSITIVE_INFINITY;
+		const bRank = priority.get(b.provider.toLowerCase()) ?? Number.POSITIVE_INFINITY;
+		return aRank - bRank;
+	})[0];
+}
+
+/**
+ * Bench resolves selectors against the entire catalog (credentials are ignored),
+ * so an ambiguous id shared by several providers can land on one the user never
+ * authenticated. For non-pinned selectors, redirect to an equivalent model under
+ * a provider with configured auth. An explicit `provider/id` selector is honored
+ * verbatim — even unauthenticated — so forced benchmarking keeps working.
+ */
+function resolveAuthenticatedAlternative(
+	selector: string,
+	model: Model<Api>,
+	modelRegistry: BenchModelRegistry,
+	providerOrder?: readonly string[],
+): Model<Api> | undefined {
+	if (!modelRegistry.hasConfiguredAuth) return undefined;
+	// A pinned `provider/...` selector is authoritative; never redirect off it.
+	if (selector.trim().toLowerCase().startsWith(`${model.provider.toLowerCase()}/`)) return undefined;
+	if (modelRegistry.hasConfiguredAuth(model)) return undefined;
+
+	const seen = new Set<string>();
+	const authenticated: Model<Api>[] = [];
+	const consider = (candidate: Model<Api>): void => {
+		const key = `${candidate.provider}/${candidate.id}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (modelRegistry.hasConfiguredAuth?.(candidate)) authenticated.push(candidate);
+	};
+	// Canonical variants link the same logical model across providers even when
+	// ids differ (e.g. fireworks `gpt-oss-20b` <-> openrouter `openai/gpt-oss-20b`).
+	const canonicalId = modelRegistry.getCanonicalId?.(model);
+	if (canonicalId) {
+		for (const variant of modelRegistry.getCanonicalVariants?.(canonicalId) ?? []) consider(variant.model);
+	}
+	// Same-id fallback for entries outside the canonical index.
+	for (const candidate of modelRegistry.getAll()) {
+		if (candidate.id === model.id) consider(candidate);
+	}
+	return pickHighestPriorityProvider(authenticated, providerOrder);
+}
+
 function resolveBenchModels(
 	selectors: string[],
 	modelRegistry: BenchModelRegistry,
@@ -366,10 +417,20 @@ function resolveBenchModels(
 			continue;
 		}
 		if (result.warning) writeStderr(`${chalk.yellow(`Warning: ${result.warning}`)}\n`);
+		let model = result.model;
+		const authenticated = resolveAuthenticatedAlternative(selector, model, modelRegistry, preferences.providerOrder);
+		if (authenticated) {
+			writeStderr(
+				`${chalk.yellow(
+					`Warning: no credentials for "${model.provider}"; benchmarking ${formatModelString(authenticated)} instead. Pin "${formatModelString(model)}" to force it.`,
+				)}\n`,
+			);
+			model = authenticated;
+		}
 		resolved.push({
 			selector,
-			model: result.model,
-			thinking: resolveThinkingLevelForModel(result.model, result.thinkingLevel),
+			model,
+			thinking: resolveThinkingLevelForModel(model, result.thinkingLevel),
 		});
 	}
 	if (errors.length > 0) {

package/src/cli/startup-cwd.ts

@@ -1,7 +1,6 @@
-import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getProjectDir, normalizePathForComparison, setProjectDir } from "@oh-my-pi/pi-utils";
+import { directoryExists, getProjectDir, normalizePathForComparison, setProjectDir } from "@oh-my-pi/pi-utils";
 import type { Args } from "./args";
 
 async function maybeAutoChdir(parsed: Args): Promise<void> {
@@ -22,19 +21,10 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 		return;
 	}
 
-	const isDirectory = async (p: string) => {
-		try {
-			const s = await fs.stat(p);
-			return s.isDirectory();
-		} catch {
-			return false;
-		}
-	};
-
 	const candidates = [path.join(home, "tmp"), "/tmp", "/var/tmp"];
 	for (const candidate of candidates) {
 		try {
-			if (!(await isDirectory(candidate))) {
+			if (!(await directoryExists(candidate))) {
 				continue;
 			}
 			setProjectDir(candidate);
@@ -46,7 +36,7 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 
 	try {
 		const fallback = os.tmpdir();
-		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
+		if (fallback && normalizePath(fallback) !== cwd && (await directoryExists(fallback))) {
 			setProjectDir(fallback);
 		}
 	} catch {

package/src/config/settings-schema.ts

@@ -924,7 +924,7 @@ export const SETTINGS_SCHEMA = {
 
 	inlineToolDescriptors: {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "model",
 			group: "Prompt",

package/src/cursor.ts

@@ -181,7 +181,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		const toolResultMessage = await executeTool(this.options, "search", toolCallId, {
 			pattern: args.pattern,
 			paths: [searchPath],
-			i: args.caseInsensitive || undefined,
+			case: args.caseInsensitive === true ? false : undefined,
 		});
 		return toolResultMessage;
 	}

package/src/debug/raw-sse-buffer.ts

@@ -119,9 +119,16 @@ export class RawSseDebugBuffer {
 	#records: RawSseDebugRecord[] = [];
 	// Parallel to `#records`: `#recordChars[i]` is the precomputed char count
 	// for `#records[i]`. Kept in lockstep by `#append` (push both) and
-	// `#enforceLimits` (shift both). See the comment above the class for why
-	// this is a sidecar array instead of a per-record property.
+	// `#enforceLimits` (advance `#head` to evict, then `slice` both together
+	// when compacting). See the comment above the class for why this is a
+	// sidecar array instead of a per-record property.
 	#recordChars: number[] = [];
+	// Head-index ring over `#records`/`#recordChars`: index of the oldest live
+	// record. Eviction advances `#head` (amortized O(1)) rather than an O(n)
+	// front `shift()`; the dead `[0, #head)` prefix is reclaimed lazily by
+	// `#enforceLimits`. Live count is `#records.length - #head`; the live
+	// records are `#records[#head ..]`.
+	#head = 0;
 	#totalChars = 0;
 	#droppedRecords = 0;
 	#droppedChars = 0;
@@ -181,7 +188,7 @@ export class RawSseDebugBuffer {
 
 	snapshot(): RawSseDebugSnapshot {
 		return {
-			records: [...this.#records],
+			records: this.#records.slice(this.#head),
 			droppedRecords: this.#droppedRecords,
 			droppedChars: this.#droppedChars,
 			totalEvents: this.#totalEvents,
@@ -190,9 +197,12 @@ export class RawSseDebugBuffer {
 	}
 
 	toRawText(): string {
-		// Reads the live array directly: `rawRecordText` only computes a string
-		// from each record, so no caller-visible mutation is possible.
-		const body = this.#records.map(rawRecordText).join("\n");
+		// Reads the live window directly: `rawRecordText` only computes a string
+		// from each record, so no caller-visible mutation is possible. With a
+		// non-empty dead prefix we map a slice past `#head`; `#head === 0` (the
+		// common case) maps `#records` in place with no extra copy.
+		const live = this.#head === 0 ? this.#records : this.#records.slice(this.#head);
+		const body = live.map(rawRecordText).join("\n");
 		if (this.#droppedRecords === 0) return body;
 		const dropped = `: omp-debug-dropped records=${this.#droppedRecords} chars=${this.#droppedChars}\n\n`;
 		return body.length > 0 ? `${dropped}${body}` : dropped;
@@ -208,14 +218,25 @@ export class RawSseDebugBuffer {
 	}
 
 	#enforceLimits(): void {
-		while (this.#records.length > MAX_RAW_SSE_EVENTS || this.#totalChars > MAX_RAW_SSE_CHARS) {
-			if (this.#records.length === 0) return;
-			this.#records.shift();
-			const chars = this.#recordChars.shift() ?? 0;
+		while (this.#records.length - this.#head > MAX_RAW_SSE_EVENTS || this.#totalChars > MAX_RAW_SSE_CHARS) {
+			if (this.#records.length - this.#head === 0) break;
+			const chars = this.#recordChars[this.#head] ?? 0;
+			this.#head += 1;
 			this.#totalChars = Math.max(0, this.#totalChars - chars);
 			this.#droppedRecords += 1;
 			this.#droppedChars += chars;
 		}
+		// Reclaim the consumed `[0, #head)` prefix once it grows large: one O(n)
+		// memmove amortized over many O(1) evictions, bounding the backing arrays
+		// to ~2x the live window. `#head >= MAX_RAW_SSE_EVENTS` covers the
+		// full-record-count steady state; `#head > liveCount` covers a small live
+		// window held by a few large records under the char budget.
+		const liveCount = this.#records.length - this.#head;
+		if (this.#head >= MAX_RAW_SSE_EVENTS || this.#head > liveCount) {
+			this.#records = this.#records.slice(this.#head);
+			this.#recordChars = this.#recordChars.slice(this.#head);
+			this.#head = 0;
+		}
 	}
 
 	#emit(): void {

package/src/eval/py/prelude.py

@@ -5,7 +5,7 @@ if "__omp_prelude_loaded__" not in globals():
     from pathlib import Path
     import os, json, math, re
     from urllib.parse import unquote
-    INTENT_FIELD = "_i"
+    INTENT_FIELD = "i"
 
     # __omp_display is injected by runner.py before the prelude executes; it
     # mirrors IPython's display() semantics with the same MIME bundle output.