@oh-my-pi/pi-coding-agent 15.10.10 → 15.10.12

package/src/cli.ts

@@ -14,9 +14,9 @@ try {
  * CLI entry point — registers all commands explicitly and delegates to the
  * lightweight CLI runner from pi-utils.
  */
-import { type CliConfig, run } from "@oh-my-pi/pi-utils/cli";
+import type { CliConfig } from "@oh-my-pi/pi-utils/cli";
 import { APP_NAME, MIN_BUN_VERSION, VERSION } from "@oh-my-pi/pi-utils/dirs";
-import { commands, isSubcommand } from "./cli-commands";
+import { declareWorkerHostEntry } from "@oh-my-pi/pi-utils/env";
 
 if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.stderr.write(
@@ -27,6 +27,12 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 
 process.title = APP_NAME;
 
+// Declare this module as the worker-host entry: Worker threads and worker
+// subprocesses re-enter `Bun.main` with a hidden argv selector instead of
+// loading separate worker entrypoints (single-entry contract across source,
+// npm bundle, and compiled binary).
+declareWorkerHostEntry();
+
 async function showHelp(config: CliConfig): Promise<void> {
 	const { renderRootHelp } = await import("@oh-my-pi/pi-utils/cli");
 	const { getExtraHelpText } = await import("./cli/args");
@@ -54,6 +60,45 @@ async function runSmokeTest(): Promise<void> {
 	process.stdout.write("smoke-test: ok\n");
 }
 
+const TINY_WORKER_ARGS = new Set(["--tiny-worker", "__tiny_worker"]);
+const STATS_SYNC_WORKER_ARG = "__omp_stats_sync_worker";
+const TAB_WORKER_ARG = "__omp_tab_worker";
+const JS_EVAL_WORKER_ARG = "__omp_js_eval_worker";
+
+async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
+	if (arg === STATS_SYNC_WORKER_ARG) {
+		// The sync worker handles messages via `self.onmessage`, assigned during
+		// this *async* dynamic import. Bun flushes the worker's initial message
+		// buffer when the entry module's top-level evaluation finishes — before
+		// this dispatch completes — so anything the parent posted right after
+		// spawning (the smoke ping, the first parse request) would be dropped.
+		// Park early events and replay them once the module's handler is live.
+		// (The tab/eval workers are immune: `parentPort.on("message")` queues
+		// until a listener attaches.)
+		const scope = globalThis as unknown as { onmessage: ((event: MessageEvent) => void) | null };
+		const pending: MessageEvent[] = [];
+		const buffer = (event: MessageEvent): void => {
+			pending.push(event);
+		};
+		scope.onmessage = buffer;
+		await import("@oh-my-pi/omp-stats/sync-worker");
+		const handler = scope.onmessage;
+		if (handler && handler !== buffer) {
+			for (const event of pending) handler.call(scope, event);
+		}
+		return true;
+	}
+	if (arg === TAB_WORKER_ARG) {
+		await import("./tools/browser/tab-worker-entry");
+		return true;
+	}
+	if (arg === JS_EVAL_WORKER_ARG) {
+		await import("./eval/js/worker-entry");
+		return true;
+	}
+	return false;
+}
+
 /**
  * Hidden subcommand that boots the tiny-model worker inside this process
  * over the parent's IPC channel. The agent's main process spawns the same
@@ -90,11 +135,16 @@ async function runTinyWorker(): Promise<void> {
 			};
 		},
 	});
+	const keepalive = setInterval(() => {}, 2 ** 30);
 	// Parent went away (crashed, SIGKILL, etc.) — commit suicide so we don't
 	// linger as an orphan. SIGKILL via `process.kill` keeps us symmetrical
 	// with the parent's hard-kill on shutdown: skip every JS/native finalizer.
 	process.on("disconnect", () => shutdown());
-	await shuttingDown;
+	try {
+		await shuttingDown;
+	} finally {
+		clearInterval(keepalive);
+	}
 	process.kill(process.pid, "SIGKILL");
 }
 
@@ -104,20 +154,33 @@ export async function runCli(argv: string[]): Promise<void> {
 		await runSmokeTest();
 		return;
 	}
-	if (argv[0] === "--tiny-worker") {
+	if (TINY_WORKER_ARGS.has(argv[0] ?? "")) {
 		await runTinyWorker();
 		return;
 	}
+	if (await runWorkerEntrypoint(argv[0])) {
+		return;
+	}
+	const [{ run }, { commands, resolveCliArgv }] = await Promise.all([
+		import("@oh-my-pi/pi-utils/cli"),
+		import("./cli-commands"),
+	]);
 	// --help and --version are handled by run() directly, don't rewrite those.
 	// Everything else that isn't a known subcommand routes to "launch".
-	const first = argv[0];
-	const runArgv =
-		first === "--help" || first === "-h" || first === "--version" || first === "-v" || first === "help"
-			? argv
-			: isSubcommand(first)
-				? argv
-				: ["launch", ...argv];
-	return run({ bin: APP_NAME, version: VERSION, argv: runArgv, commands, help: showHelp });
+	const resolved = resolveCliArgv(argv);
+	if ("error" in resolved) {
+		process.stderr.write(`error: ${resolved.error}\n`);
+		process.exitCode = 1;
+		return;
+	}
+	return run({ bin: APP_NAME, version: VERSION, argv: resolved.argv, commands, help: showHelp });
 }
 
-await runCli(process.argv.slice(2));
+// Floating call instead of top-level await: TLA forces `--bytecode` (CJS
+// lowering) builds to fail, and the entrypoint needs nothing after this.
+// The catch mirrors what an unhandled TLA rejection produced: error dump to
+// stderr, exit code 1. Success paths resolve without touching the exit code.
+runCli(process.argv.slice(2)).catch((err: unknown) => {
+	process.stderr.write(`${Bun.inspect(err, { colors: process.stderr.isTTY === true })}\n`);
+	process.exit(1);
+});

package/src/commands/complete.ts

@@ -8,7 +8,7 @@
  * first field. The import surface is kept deliberately narrow so a TAB press
  * doesn't pay for the full agent boot.
  */
-import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-ai/models";
+import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-catalog/models";
 import { Command } from "@oh-my-pi/pi-utils/cli";
 import { SessionManager } from "../session/session-manager";
 

package/src/commands/launch.ts

@@ -2,7 +2,7 @@
  * Root command for the coding agent CLI.
  */
 
-import { THINKING_EFFORTS } from "@oh-my-pi/pi-ai/effort";
+import { THINKING_EFFORTS } from "@oh-my-pi/pi-catalog/effort";
 import { APP_NAME } from "@oh-my-pi/pi-utils";
 import { Args, Command, Flags } from "@oh-my-pi/pi-utils/cli";
 import { parseArgs } from "../cli/args";
@@ -56,6 +56,10 @@ export default class Index extends Command {
 			description: "Output mode: text (default), json, rpc, or rpc-ui",
 			options: ["text", "json", "rpc", "acp", "rpc-ui"],
 		}),
+		config: Flags.string({
+			description: "Load an extra config.yml-style overlay for this run (repeatable)",
+			multiple: true,
+		}),
 		print: Flags.boolean({
 			char: "p",
 			description: "Non-interactive mode: process prompt and exit",

package/src/commands/read.ts

@@ -1,16 +1,17 @@
 /**
- * Show what the read tool will return for a given path.
+ * Show what the read tool will return for a path, URL, or internal URI.
  */
 import { Args, Command } from "@oh-my-pi/pi-utils/cli";
 import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
 import { initTheme } from "../modes/theme/theme";
 
 export default class Read extends Command {
-	static description = "Show what the read tool will return for a path or URL";
+	static description = "Show what the read tool will return for a path, URL, or internal URI";
 
 	static args = {
 		path: Args.string({
-			description: "Path or URL to read (append :sel for line ranges or raw mode, e.g. src/foo.ts:50-100)",
+			description:
+				"Path, URL, or internal URI to read (append :sel for line ranges or raw mode, e.g. src/foo.ts:50-100)",
 			required: true,
 		}),
 	};
@@ -20,6 +21,8 @@ export default class Read extends Command {
 		"omp read src/foo.ts:50-100",
 		"omp read src/foo.ts:raw",
 		"omp read https://example.com",
+		"omp read omp://",
+		"omp read issue://123",
 		"omp read path/to/archive.zip:dir/file.ts",
 		"omp read path/to/db.sqlite:users:42",
 	];

package/src/commands/usage.ts

@@ -0,0 +1,35 @@
+/**
+ * Show provider usage limits for every authenticated account.
+ */
+import { Command, Flags } from "@oh-my-pi/pi-utils/cli";
+import { runUsageCommand } from "../cli/usage-cli";
+
+export default class Usage extends Command {
+	static description = "Show provider usage limits for every authenticated account";
+
+	static flags = {
+		json: Flags.boolean({ char: "j", description: "Output usage reports as JSON", default: false }),
+		provider: Flags.string({ char: "p", description: "Only show usage for this provider id (e.g. anthropic)" }),
+		redact: Flags.boolean({
+			char: "r",
+			description: "Redact account emails/ids (shortest unique prefix) for sharing screenshots",
+			default: false,
+		}),
+	};
+
+	static examples = [
+		"# Detailed per-account usage breakdown across all providers\n  omp usage",
+		"# Only Anthropic accounts\n  omp usage --provider anthropic",
+		"# Redact account identifiers for screenshots\n  omp usage --redact",
+		"# Machine-readable output\n  omp usage --json",
+	];
+
+	async run(): Promise<void> {
+		const { flags } = await this.parse(Usage);
+		await runUsageCommand({
+			json: flags.json,
+			provider: flags.provider,
+			redact: flags.redact,
+		});
+	}
+}

package/src/commit/agentic/agent.ts

@@ -213,7 +213,7 @@ function writeAssistantMessage(message: string): void {
 	}
 }
 
-function renderMarkdownLines(message: string): string[] {
+function renderMarkdownLines(message: string): readonly string[] {
 	const width = Math.max(40, process.stdout.columns ?? 100);
 	const markdown = new Markdown(message, 0, 0, getMarkdownTheme());
 	return markdown.render(width);

package/src/commit/model-selection.ts

@@ -1,7 +1,6 @@
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, ApiKey, Model } from "@oh-my-pi/pi-ai";
 import type { ApiKeyResolverRegistry } from "../config/api-key-resolver";
-import { MODEL_ROLE_IDS } from "../config/model-registry";
 import {
 	getModelMatchPreferences,
 	type ModelLookupRegistry,
@@ -9,6 +8,7 @@ import {
 	resolveModelRoleValue,
 	resolveRoleSelection,
 } from "../config/model-resolver";
+import { MODEL_ROLE_IDS } from "../config/model-roles";
 import type { Settings } from "../config/settings";
 import MODEL_PRIO from "../priority.json" with { type: "json" };
 
@@ -48,7 +48,7 @@ export async function resolvePrimaryModel(
 	}
 	return {
 		model,
-		apiKey: modelRegistry.resolver(model.provider, { baseUrl: model.baseUrl }),
+		apiKey: modelRegistry.resolver(model.provider, { baseUrl: model.baseUrl, modelId: model.id }),
 		thinkingLevel: resolved?.thinkingLevel,
 	};
 }
@@ -68,6 +68,7 @@ export async function resolveSmolModel(
 				model: resolvedSmol.model,
 				apiKey: modelRegistry.resolver(resolvedSmol.model.provider, {
 					baseUrl: resolvedSmol.model.baseUrl,
+					modelId: resolvedSmol.model.id,
 				}),
 				thinkingLevel: resolvedSmol.thinkingLevel,
 			};
@@ -82,7 +83,7 @@ export async function resolveSmolModel(
 		if (apiKey) {
 			return {
 				model: candidate,
-				apiKey: modelRegistry.resolver(candidate.provider, { baseUrl: candidate.baseUrl }),
+				apiKey: modelRegistry.resolver(candidate.provider, { baseUrl: candidate.baseUrl, modelId: candidate.id }),
 			};
 		}
 	}

package/src/config/api-key-resolver.ts

@@ -5,6 +5,8 @@ export interface ApiKeyResolverOptions {
 	sessionId?: string;
 	/** Provider base URL hint forwarded to the auth-storage cascade. */
 	baseUrl?: string;
+	/** Provider model id forwarded to model-scoped usage ranking/backoff. */
+	modelId?: string;
 }
 
 /**
@@ -16,7 +18,7 @@ export interface ApiKeyResolverRegistry {
 	getApiKeyForProvider(
 		provider: string,
 		sessionId?: string,
-		options?: { baseUrl?: string; forceRefresh?: boolean; signal?: AbortSignal },
+		options?: { baseUrl?: string; modelId?: string; forceRefresh?: boolean; signal?: AbortSignal },
 	): Promise<string | undefined>;
 	authStorage: Pick<AuthStorage, "rotateSessionCredential">;
 	/**
@@ -39,10 +41,10 @@ export function createApiKeyResolver(
 	provider: string,
 	options: ApiKeyResolverOptions = {},
 ): ApiKeyResolver {
-	const { sessionId, baseUrl } = options;
+	const { sessionId, baseUrl, modelId } = options;
 	return async ({ lastChance, error, signal }) => {
 		if (error === undefined) {
-			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl });
+			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl, modelId });
 		}
 		if (lastChance) {
 			// Account constraint (401 / usage / account-rate-limit): rotate to a
@@ -50,9 +52,9 @@ export function createApiKeyResolver(
 			// sibling exists we switch immediately; the precise no-sibling backoff
 			// is owned by `markUsageLimitReached` (default + server usage-report
 			// reset) and the outer whole-turn retry layer.
-			await registry.authStorage.rotateSessionCredential(provider, sessionId, { error, signal });
-			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl });
+			await registry.authStorage.rotateSessionCredential(provider, sessionId, { error, modelId, signal });
+			return registry.getApiKeyForProvider(provider, sessionId, { baseUrl, modelId });
 		}
-		return registry.getApiKeyForProvider(provider, sessionId, { baseUrl, forceRefresh: true, signal });
+		return registry.getApiKeyForProvider(provider, sessionId, { baseUrl, modelId, forceRefresh: true, signal });
 	};
 }

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

@@ -1,24 +1,18 @@
+import { hostMatchesUrl } from "@oh-my-pi/pi-catalog/hosts";
+
 /** Provider metadata needed to resolve append-only context mode. */
 export interface AppendOnlyContextModel {
 	provider: string;
 	baseUrl: string;
-	compat?: object;
-}
-
-function isXiaomiHost(baseUrl: string): boolean {
-	try {
-		const host = new URL(baseUrl).hostname;
-		return host === "xiaomimimo.com" || host.endsWith(".xiaomimimo.com");
-	} catch {
-		return false;
-	}
+	/** Verbatim sparse compat config (explicit user intent), never the resolved record. */
+	compatConfig?: object;
 }
 
 function shouldAutoEnableAppendOnlyContext(model: AppendOnlyContextModel | null | undefined): boolean {
 	if (!model) return false;
 	if (model.provider === "deepseek") return true;
-	if (isXiaomiHost(model.baseUrl)) return true;
-	return !!model.compat && "supportsStore" in model.compat && model.compat.supportsStore === true;
+	if (hostMatchesUrl(model.baseUrl, "xiaomi")) return true;
+	return !!model.compatConfig && "supportsStore" in model.compatConfig && model.compatConfig.supportsStore === true;
 }
 
 /** Resolves whether append-only context should be active for a model and setting. */