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

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/cli.ts

@@ -68,6 +68,7 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestTinyTitleWorker } = await import("./tiny/title-client");
 	const { smokeTestSttWorker } = await import("./stt/asr-client");
 	const { smokeTestTtsWorker } = await import("./tts/tts-client");
+	const { smokeTestMnemopiEmbedWorker } = await import("./mnemopi/embed-client");
 	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
 	await smokeTestSyncWorker();
 
@@ -87,6 +88,7 @@ async function runSmokeTest(): Promise<void> {
 	await smokeTestSttWorker();
 	await smokeTestJsEvalWorker();
 	await smokeTestTtsWorker();
+	await smokeTestMnemopiEmbedWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -96,6 +98,7 @@ const TAB_WORKER_ARG = "__omp_worker_tab";
 const JS_EVAL_WORKER_ARG = "__omp_worker_js_eval";
 const STT_WORKER_ARG = "__omp_worker_stt";
 const TTS_WORKER_ARG = "__omp_worker_tts";
+const MNEMOPI_EMBED_WORKER_ARG = "__omp_worker_mnemopi_embed";
 
 async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 	if (arg === TINY_WORKER_ARG) {
@@ -151,6 +154,11 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		await runIpcSubprocessWorker(startTtsWorker);
 		return true;
 	}
+	if (arg === MNEMOPI_EMBED_WORKER_ARG) {
+		const { startMnemopiEmbedWorker } = await import("./mnemopi/embed-worker");
+		await runIpcSubprocessWorker(startMnemopiEmbedWorker);
+		return true;
+	}
 	return false;
 }
 

package/src/commands/token.ts

@@ -7,6 +7,7 @@ import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import chalk from "chalk";
 import { isAuthenticated, ModelRegistry } from "../config/model-registry";
 import { discoverAuthStorage } from "../sdk";
+import { getAvailableAuthMethods } from "../web/search/providers/perplexity-auth";
 
 export default class Token extends Command {
 	static description = "Get the API key or OAuth token for a provider";
@@ -41,49 +42,67 @@ export default class Token extends Command {
 		const provider = providerName.toLowerCase();
 
 		const authStorage = await discoverAuthStorage();
-		const modelRegistry = new ModelRegistry(authStorage);
+		try {
+			const modelRegistry = new ModelRegistry(authStorage);
 
-		// Resolve the API key / token
-		const apiKey = await modelRegistry.getApiKeyForProvider(provider, undefined, {
-			forceRefresh: flags["force-refresh"],
-		});
+			// Resolve the API key / token
+			let apiKey: string | undefined;
 
-		if (!isAuthenticated(apiKey)) {
-			// Find all active/configured providers
-			const activeProviders = new Set<string>();
-			for (const p of PROVIDER_REGISTRY) {
-				if (authStorage.hasAuth(p.id)) {
-					activeProviders.add(p.id);
+			if (provider === "perplexity") {
+				const methods = await getAvailableAuthMethods(authStorage, undefined, {
+					forceRefresh: flags["force-refresh"],
+				});
+				const printable = methods.find(m => m.type === "oauth" || m.type === "api_key");
+				if (printable) {
+					apiKey = printable.type === "oauth" ? printable.access.accessToken : printable.apiKey;
 				}
 			}
-			const all = authStorage.getAll();
-			for (const p in all) {
-				if (authStorage.hasAuth(p)) {
-					activeProviders.add(p);
-				}
+
+			if (!apiKey) {
+				apiKey = await modelRegistry.getApiKeyForProvider(provider, undefined, {
+					forceRefresh: flags["force-refresh"],
+				});
 			}
 
-			const msg = `No active credential found for provider "${providerName}".`;
-			process.stderr.write(`${chalk.red(msg)}\n`);
-			if (activeProviders.size > 0) {
-				process.stderr.write(`Configured providers: ${Array.from(activeProviders).sort().join(", ")}\n`);
+			if (!isAuthenticated(apiKey)) {
+				// Find all active/configured providers
+				const activeProviders = new Set<string>();
+				for (const p of PROVIDER_REGISTRY) {
+					if (authStorage.hasAuth(p.id)) {
+						activeProviders.add(p.id);
+					}
+				}
+				const all = authStorage.getAll();
+				for (const p in all) {
+					if (authStorage.hasAuth(p)) {
+						activeProviders.add(p);
+					}
+				}
+
+				const msg = `No active credential found for provider "${providerName}".`;
+				process.stderr.write(`${chalk.red(msg)}\n`);
+				if (activeProviders.size > 0) {
+					process.stderr.write(`Configured providers: ${Array.from(activeProviders).sort().join(", ")}\n`);
+				}
+				process.exitCode = 1;
+				return;
 			}
-			process.exitCode = 1;
-			return;
-		}
 
-		if (!flags.raw) {
-			try {
-				const parsed = JSON.parse(apiKey);
-				if (parsed && typeof parsed === "object" && typeof parsed.token === "string") {
-					process.stdout.write(`${parsed.token}\n`);
-					return;
+			if (!flags.raw) {
+				try {
+					const parsed = JSON.parse(apiKey);
+					if (parsed && typeof parsed === "object" && typeof parsed.token === "string") {
+						process.stdout.write(`${parsed.token}\n`);
+						return;
+					}
+				} catch {
+					// Not a JSON string, print as-is
 				}
-			} catch {
-				// Not a JSON string, print as-is
 			}
-		}
 
-		process.stdout.write(`${apiKey}\n`);
+			process.stdout.write(`${apiKey}\n`);
+		} finally {
+			authStorage.close();
+		}
 	}
 }

package/src/config/append-only-context-mode.ts

@@ -8,10 +8,55 @@ export interface AppendOnlyContextModel {
 	compatConfig?: object;
 }
 
+/**
+ * Local model servers (Ollama, LM Studio, llama.cpp, vLLM, sglang, …) all
+ * rely on llama.cpp-style prefix KV-cache reuse: identical leading tokens
+ * skip re-prefill on the next request. Append-only mode is the only way to
+ * guarantee byte-stable bytes across turns, since the live system prompt,
+ * tool catalogue, and message log all flow through fresh allocations every
+ * step (see `agent-loop.ts` `streamAssistantResponse` fallback path).
+ */
+const LOCAL_INFERENCE_PROVIDERS = new Set(["ollama", "ollama-cloud", "lm-studio", "llama.cpp"]);
+
+/** True when `baseUrl` resolves to a loopback or RFC1918 host — covers
+ * llama.cpp/vLLM/sglang servers registered under a user-defined provider id
+ * via `models.yaml`. Built-in local provider ids (`ollama`, `lm-studio`,
+ * `llama.cpp`) are already handled by `LOCAL_INFERENCE_PROVIDERS`.
+ * Substring match on the parsed hostname only; ports, paths, and unparseable
+ * URLs return false.
+ */
+function hasLocalLoopbackBaseUrl(baseUrl: string | undefined): boolean {
+	if (!baseUrl) return false;
+	let hostname: string;
+	try {
+		hostname = new URL(baseUrl).hostname.toLowerCase();
+	} catch {
+		return false;
+	}
+	if (
+		hostname === "localhost" ||
+		hostname === "127.0.0.1" ||
+		hostname === "0.0.0.0" ||
+		hostname === "::1" ||
+		hostname === "[::1]"
+	) {
+		return true;
+	}
+	// RFC1918 private IPv4 ranges.
+	if (/^10\./.test(hostname)) return true;
+	if (/^192\.168\./.test(hostname)) return true;
+	if (/^172\.(1[6-9]|2[0-9]|3[01])\./.test(hostname)) return true;
+	// Common ".local" mDNS hostnames used for home-LAN llama.cpp boxes.
+	if (hostname.endsWith(".local")) return true;
+	return false;
+}
+
 function shouldAutoEnableAppendOnlyContext(model: AppendOnlyContextModel | null | undefined): boolean {
 	if (!model) return false;
 	if (model.provider === "deepseek") return true;
+	if (LOCAL_INFERENCE_PROVIDERS.has(model.provider)) return true;
 	if (hostMatchesUrl(model.baseUrl, "xiaomi")) return true;
+	if (hasLocalLoopbackBaseUrl(model.baseUrl)) return true;
 	return !!model.compatConfig && "supportsStore" in model.compatConfig && model.compatConfig.supportsStore === true;
 }
 

package/src/config/model-discovery.ts

@@ -275,6 +275,7 @@ export async function discoverOllamaModels(
 			baseUrl: `${endpoint}/v1`,
 			reasoning: metadata?.reasoning ?? false,
 			input: metadata?.input ?? ["text"],
+			imageInputDecoder: "stb",
 			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 			contextWindow: metadata?.contextWindow ?? 128000,
 			maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, DISCOVERY_DEFAULT_MAX_TOKENS),
@@ -352,6 +353,7 @@ export async function discoverLlamaCppModels(
 				baseUrl,
 				reasoning: false,
 				input: serverMetadata?.input ?? ["text"],
+				imageInputDecoder: "stb",
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow: serverMetadata?.contextWindow ?? 128000,
 				maxTokens: Math.min(
@@ -424,6 +426,7 @@ export async function discoverOpenAIModelsList(
 				baseUrl,
 				reasoning: false,
 				input: nativeMetadataForModel?.input ?? ["text"],
+				...(providerConfig.discovery.type === "lm-studio" ? { imageInputDecoder: "stb" as const } : {}),
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow,
 				maxTokens: Math.min(contextWindow, discoveryDefaultMaxTokens(providerConfig.api)),

package/src/config/model-registry.ts

@@ -900,6 +900,7 @@ export class ModelRegistry {
 				...replacementModel,
 				contextWindow: replacementModel.contextWindow ?? existing.contextWindow,
 				maxTokens: replacementModel.maxTokens ?? existing.maxTokens,
+				omitMaxOutputTokens: replacementModel.omitMaxOutputTokens ?? existing.omitMaxOutputTokens,
 				...(supportsTools !== undefined ? { supportsTools } : {}),
 			};
 		});
@@ -1023,12 +1024,21 @@ export class ModelRegistry {
 	}
 
 	#normalizeDiscoverableModels(providerConfig: DiscoveryProviderConfig, models: Model<Api>[]): Model<Api>[] {
+		const withDecoderMetadata =
+			providerConfig.discovery.type === "ollama" ||
+			providerConfig.discovery.type === "llama.cpp" ||
+			providerConfig.discovery.type === "lm-studio"
+				? models.map(model =>
+						buildModel({ ...model, imageInputDecoder: "stb", compat: model.compatConfig } as ModelSpec<Api>),
+					)
+				: models;
+
 		if (providerConfig.provider !== "ollama" || providerConfig.api !== "openai-responses") {
-			return models;
+			return withDecoderMetadata;
 		}
 
 		const contextLengthOverride = getOllamaContextLengthOverride();
-		return models.map(model => {
+		return withDecoderMetadata.map(model => {
 			const normalized =
 				model.api === "openai-completions"
 					? buildModel({
@@ -1269,7 +1279,12 @@ export class ModelRegistry {
 					models: cached?.models.map(model => model.id) ?? [],
 				});
 				this.#lastDiscoveryWarnings.delete(providerConfig.provider);
-				return cached ? cached.models.map(model => buildModel(model)) : [];
+				return cached
+					? this.#normalizeDiscoverableModels(
+							providerConfig,
+							cached.models.map(model => buildModel(model)),
+						)
+					: [];
 			}
 		}
 
@@ -1569,6 +1584,9 @@ export class ModelRegistry {
 	}
 	#applyHardcodedModelPolicies(models: Model<Api>[]): Model<Api>[] {
 		return models.map(model => {
+			if (model.provider === "ollama-cloud" && model.omitMaxOutputTokens !== true) {
+				model = applyModelOverride(model, { omitMaxOutputTokens: true });
+			}
 			if (model.id !== "gpt-5.4" || model.provider === "github-copilot") {
 				return model;
 			}

package/src/config/model-resolver.ts

@@ -556,6 +556,27 @@ function isAlias(id: string): boolean {
 	return !datePattern.test(id);
 }
 
+function includeSyntheticAllowedModels(available: Model<Api>[], allowedModels: Iterable<Model<Api>>): Model<Api>[] {
+	const allowedByKey = new Map<string, Model<Api>>();
+	for (const model of allowedModels) {
+		const key = formatModelString(model);
+		if (!allowedByKey.has(key)) {
+			allowedByKey.set(key, model);
+		}
+	}
+	if (allowedByKey.size === 0) return [];
+
+	const result: Model<Api>[] = [];
+	for (const model of available) {
+		if (allowedByKey.delete(formatModelString(model))) {
+			result.push(model);
+		}
+	}
+
+	result.push(...allowedByKey.values());
+	return result;
+}
+
 /**
  * Find an exact explicit provider/model match.
  * Bare model ids are handled separately so canonical ids can coalesce variants.
@@ -1335,9 +1356,9 @@ export async function resolveModelScope(
  * the result to models matching those patterns.
  *
  * Returns the unfiltered available list when `enabledModels` is empty.
- * Returns an empty list when `enabledModels` is configured but no available
- * model matches any pattern — callers MUST treat this as "no usable model"
- * rather than falling back to the global default (see issue #1022).
+ * Returns an empty list when `enabledModels` is configured but no model matches
+ * any pattern — callers MUST treat this as "no usable model" rather than
+ * falling back to the global default (see issue #1022).
  */
 export async function resolveAllowedModels(
 	modelRegistry: Pick<ModelRegistry, "getAvailable" | "getCanonicalVariants">,
@@ -1353,8 +1374,10 @@ export async function resolveAllowedModels(
 	if (scoped.length === 0) {
 		return [];
 	}
-	const allowed = new Set(scoped.map(entry => `${entry.model.provider}/${entry.model.id}`));
-	return available.filter(model => allowed.has(`${model.provider}/${model.id}`));
+	return includeSyntheticAllowedModels(
+		available,
+		scoped.map(entry => entry.model),
+	);
 }
 
 /**
@@ -1382,9 +1405,9 @@ export function filterAvailableModelsByEnabledPatterns(
 	if (patterns.length === 0) return available;
 
 	const context = buildPreferenceContext(available, undefined);
-	const allowed = new Set<string>();
+	const allowedModels: Model<Api>[] = [];
 	const addAllowed = (model: Model<Api>) => {
-		allowed.add(`${model.provider}/${model.id}`);
+		allowedModels.push(model);
 	};
 
 	for (const pattern of patterns) {
@@ -1409,7 +1432,7 @@ export function filterAvailableModelsByEnabledPatterns(
 		}
 	}
 
-	return allowed.size === 0 ? [] : available.filter(model => allowed.has(`${model.provider}/${model.id}`));
+	return includeSyntheticAllowedModels(available, allowedModels);
 }
 
 export interface ResolveCliModelResult {

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/discovery/builtin-rules/ts-no-return-type.md

@@ -39,7 +39,6 @@ import type { LoadedConfig } from "./config";
 
 ## Exceptions
 
-- Timer handles: `ReturnType<typeof setTimeout>` / `setInterval`.
 - Generic type utilities where the function is a type parameter.
 
 Concrete function? Export a concrete type.

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.