@oh-my-pi/pi-coding-agent 16.2.5 → 16.2.7

package/dist/types/session/session-manager.d.ts

@@ -1,4 +1,4 @@
-import type { ImageContent, Message, MessageAttribution, ServiceTier, TextContent } from "@oh-my-pi/pi-ai";
+import type { ImageContent, Message, MessageAttribution, ServiceTierByFamily, TextContent } from "@oh-my-pi/pi-ai";
 import { ArtifactManager } from "./artifacts";
 import { type BlobPutOptions, type BlobPutResult } from "./blob-store";
 import { type BashExecutionMessage, type CustomMessage, type FileMentionMessage, type HookMessage, type PythonExecutionMessage } from "./messages";
@@ -75,10 +75,9 @@ export declare class SessionManager {
     /** Flush pending writes. Call before switching sessions or on shutdown. */
     flush(): Promise<void>;
     /**
-     * Synchronously flush all in-memory entries to disk. Use when the process may
-     * exit before an async flush settles (Ctrl+C in the TUI). Software-crash
-     * durable; not atomic and not power-loss safe — a same-process crash never
-     * lands mid-`writeFileSync`.
+     * Synchronously makes the current append-only session durable. Avoid rewriting
+     * an already-current file: large restored sessions can contain GiB of compacted
+     * history, and Ctrl+C must not rebuild the whole JSONL string just to flush.
      */
     flushSync(): void;
     /** Flush, then close the append writer. */
@@ -142,7 +141,7 @@ export declare class SessionManager {
     appendMessage(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage): string;
     /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
     appendThinkingLevelChange(thinkingLevel?: string, configured?: string): string;
-    appendServiceTierChange(serviceTier: ServiceTier | null): string;
+    appendServiceTierChange(serviceTier: ServiceTierByFamily | null): string;
     appendModeChange(mode: string, data?: Record<string, unknown>): string;
     /**
      * Append a model change as a child of the current leaf, then advance the leaf.

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

@@ -0,0 +1 @@
+export {};

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

@@ -4,7 +4,7 @@
  * Runs each subagent on the main thread and forwards AgentEvents for progress tracking.
  */
 import type { AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { ServiceTier } from "@oh-my-pi/pi-ai";
+import type { ServiceTierByFamily } from "@oh-my-pi/pi-ai";
 import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -123,12 +123,12 @@ export interface ExecutorOptions {
     modelRegistry?: ModelRegistry;
     settings?: Settings;
     /**
-     * Parent session's live effective service tier, the source of truth for a
-     * subagent whose `serviceTierSubagent` is `"inherit"`. `null` = the parent
+     * Parent session's live per-family service tiers, the source of truth for a
+     * subagent whose `tier.subagent` is `"inherit"`. `null` = the parent
      * explicitly has no tier (e.g. `/fast off`); omitted = no live session, so
-     * inherit falls back to the configured `serviceTier` setting.
+     * inherit falls back to the subagent's configured `tier.*` settings.
      */
-    parentServiceTier?: ServiceTier | null;
+    parentServiceTier?: ServiceTierByFamily | null;
     /** Override local:// protocol options so subagent shares parent's local:// root */
     localProtocolOptions?: LocalProtocolOptions;
     /**
@@ -191,7 +191,7 @@ export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputA
  * Create proxy tools that reuse the parent's MCP connections.
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
-export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTier | null): Settings;
+export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;
 export declare function finalizeSubagentLifecycle(args: {
     id: string;
     session: AgentSession;

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

@@ -334,6 +334,12 @@ export interface SingleResult {
     patchPath?: string;
     /** Branch name for isolated branch-mode output */
     branchName?: string;
+    /**
+     * Baseline commit SHA the task branch was created from. Passed to
+     * `mergeTaskBranches` so cherry-pick uses the inclusive range
+     * `branchBaseSha..branchName` and preserves every agent commit's message.
+     */
+    branchBaseSha?: string;
     /** Nested repo patches to apply after parent merge */
     nestedPatches?: NestedRepoPatch[];
     /** Data extracted by registered subprocess tool handlers (keyed by tool name) */

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

@@ -80,11 +80,32 @@ export declare function cleanupIsolation(handle: IsolationHandle): Promise<void>
 export interface CommitToBranchResult {
     branchName?: string;
     nestedPatches: NestedRepoPatch[];
+    /**
+     * SHA of the parent-repo commit the task branch was created on top of, so
+     * {@link mergeTaskBranches} can cherry-pick the range `baseSha..branchName`
+     * and preserve every agent commit's message and author.
+     */
+    baseSha?: string;
 }
 /**
- * Commit task-only changes to a new branch.
- * Only root repo changes go on the branch. Nested repo patches are returned
- * separately since the parent git can't track files inside gitlinks.
+ * Capture task-only changes from the isolation worktree onto a parent-repo
+ * branch named `omp/task/${taskId}`. Only root-repo changes go on the branch;
+ * nested-repo patches are returned separately because the parent git can't
+ * track files inside gitlinks.
+ *
+ * If the agent committed inside isolation (HEAD moved past
+ * `baseline.root.headCommit`), clean-baseline runs fetch the raw commit range
+ * into the parent repo and later cherry-pick `baseSha..branchName`, preserving
+ * every message and author verbatim. Dirty-baseline runs rewrite each agent
+ * commit against the captured baseline WIP before committing it to the task
+ * branch, so user staged/unstaged/untracked changes present at isolation
+ * start are not replayed into the parent commit history.
+ *
+ * If the agent did not commit, the captured delta is collapsed onto a single
+ * branch commit with an AI-generated (or fallback) message — the legacy
+ * behaviour.
+ *
+ * Returns `null` when no root or nested changes exist.
  */
 export declare function commitToBranch(isolationDir: string, baseline: WorktreeBaseline, taskId: string, description: string | undefined, commitMessage?: (diff: string) => Promise<string | null>): Promise<CommitToBranchResult | null>;
 export interface MergeBranchResult {
@@ -95,14 +116,19 @@ export interface MergeBranchResult {
     stashConflict?: string;
 }
 /**
- * Cherry-pick task branch commits sequentially onto HEAD.
- * Each branch has a single commit that gets replayed cleanly.
- * Stops on first conflict and reports which branches succeeded.
+ * Cherry-pick task branch commits sequentially onto HEAD. When `baseSha` is
+ * provided the cherry-pick uses the inclusive range `baseSha..branchName`,
+ * replaying every commit individually and preserving each commit's message
+ * and author. When omitted, the branch is cherry-picked as a single commit
+ * (legacy callers).
+ *
+ * Stops on the first conflict and reports which branches succeeded.
  */
 export declare function mergeTaskBranches(repoRoot: string, branches: Array<{
     branchName: string;
     taskId: string;
     description?: string;
+    baseSha?: string;
 }>): Promise<MergeBranchResult>;
 /** Clean up temporary task branches. */
 export declare function cleanupTaskBranches(repoRoot: string, branches: string[]): Promise<void>;

package/dist/types/tiny/title-client.d.ts

@@ -1,5 +1,9 @@
 import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
+export interface TinyTitleDownloadResult {
+    ok: boolean;
+    error?: string;
+}
 export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
     onProgress?: (event: TinyTitleProgressEvent) => void;
@@ -52,7 +56,7 @@ export declare class TinyTitleClient {
         maxTokens?: number;
         signal?: AbortSignal;
     }): Promise<string | null>;
-    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<boolean>;
+    downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<TinyTitleDownloadResult>;
     terminate(): Promise<void>;
 }
 export declare const tinyTitleClient: TinyTitleClient;

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

@@ -1,6 +1,6 @@
 import type { InMemorySnapshotStore } from "@oh-my-pi/hashline";
 import type { AgentTelemetryConfig, AgentTool } from "@oh-my-pi/pi-agent-core";
-import type { FetchImpl, ImageContent, Model, ServiceTier, ToolChoice } from "@oh-my-pi/pi-ai";
+import type { FetchImpl, ImageContent, Model, ServiceTierByFamily, ToolChoice } from "@oh-my-pi/pi-ai";
 import type { AsyncJobManager } from "../async/job-manager";
 import type { Rule } from "../capability/rule";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -191,8 +191,8 @@ export interface ToolSession {
     getActiveModelString?: () => string | undefined;
     /** Get the current session model object (provider/api capabilities), regardless of how it was chosen. */
     getActiveModel?: () => Model | undefined;
-    /** Get the session's live effective service tier (undefined = none). Source of truth for subagent `serviceTierSubagent: inherit`. */
-    getServiceTier?: () => ServiceTier | undefined;
+    /** Get the session's live per-family service tiers (undefined = none). Source of truth for subagent `tier.subagent: inherit`. */
+    getServiceTierByFamily?: () => ServiceTierByFamily | undefined;
     /** Auth storage for passing to subagents (avoids re-discovery) */
     authStorage?: import("../session/auth-storage").AuthStorage;
     /** Model registry for passing to subagents (avoids re-discovery) */

package/dist/types/utils/git.d.ts

@@ -63,8 +63,18 @@ export interface StatusOptions {
     readonly untrackedFiles?: "all" | "no" | "normal";
     readonly z?: boolean;
 }
+export interface CommitAuthor {
+    readonly date?: string;
+    readonly email: string;
+    readonly name: string;
+}
+export interface CommitDetails {
+    readonly author: CommitAuthor;
+    readonly message: string;
+}
 export interface CommitOptions {
     readonly allowEmpty?: boolean;
+    readonly author?: CommitAuthor;
     readonly files?: readonly string[];
     readonly signal?: AbortSignal;
 }
@@ -78,6 +88,7 @@ export interface PatchOptions {
     readonly cached?: boolean;
     readonly check?: boolean;
     readonly env?: Record<string, string | undefined>;
+    readonly threeWay?: boolean;
     readonly signal?: AbortSignal;
 }
 export interface RestoreOptions {
@@ -195,12 +206,18 @@ export declare const show: ((cwd: string, revision: string, options?: {
     /** Get the path prefix of the current directory relative to the repo root. */
     prefix(cwd: string, signal?: AbortSignal): Promise<string>;
 };
+/** Read commit message and author metadata for replay/rewrite flows. */
+export declare function commitDetails(cwd: string, revision: string, signal?: AbortSignal): Promise<CommitDetails>;
 export declare const log: {
     /** Recent commit subjects (one-line each). */
     subjects(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
     /** Recent commits as `<short-sha> <subject>` onelines. */
     onelines(cwd: string, count: number, signal?: AbortSignal): Promise<string[]>;
 };
+export declare const revList: {
+    /** Commits in `base..head`, oldest first. */
+    range(cwd: string, base: string, head: string, signal?: AbortSignal): Promise<string[]>;
+};
 export declare const branch: {
     /** Current branch name, or null if detached/unavailable. */
     current(cwd: string, signal?: AbortSignal): Promise<string | null>;

package/dist/types/web/search/providers/duckduckgo.d.ts

@@ -2,9 +2,9 @@ import type { AuthStorage } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
-/** Execute DuckDuckGo Instant Answer API search. */
+/** Execute a DuckDuckGo web search via the no-JS HTML frontend. */
 export declare function searchDuckDuckGo(params: SearchParams): Promise<SearchResponse>;
-/** Search provider for DuckDuckGo Instant Answer API. */
+/** Search provider for DuckDuckGo (no API key required). */
 export declare class DuckDuckGoProvider extends SearchProvider {
     readonly id = "duckduckgo";
     readonly label = "DuckDuckGo";

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

@@ -78,7 +78,7 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
 }, {
     readonly value: "duckduckgo";
     readonly label: "DuckDuckGo";
-    readonly description: "Uses DuckDuckGo Instant Answer API (no API key)";
+    readonly description: "Scrapes the DuckDuckGo HTML frontend (no API key)";
 }];
 /** Supported web search providers (every option except `auto`). */
 export type SearchProviderId = Exclude<(typeof SEARCH_PROVIDER_OPTIONS)[number]["value"], "auto">;

package/package.json

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

package/src/cli/args.ts

@@ -94,6 +94,35 @@ const PARSE_DEPS: ParseDeps = {
 	thinkingEfforts: CLI_THINKING_LEVELS,
 };
 
+const WINDOWS_PATH_VALUE_FLAGS: ReadonlySet<string> = new Set(["--extension", "-e", "--hook"]);
+const WINDOWS_PATH_START_RE =
+	/^(?:[A-Za-z]:[\\/]|\\\\[?]\\(?:[A-Za-z]:[\\/]|UNC[\\/])|\\\\[^\\/]+[\\/][^\\/]+[\\/]|\/\/[?]\/(?:[A-Za-z]:\/|UNC\/)|\/\/[^/]+\/[^/]+\/)/;
+const WINDOWS_MODULE_PATH_SUFFIX_RE = /\.(?:[cm]?[jt]sx?)$/i;
+
+function consumeBuiltInStringValue(flag: string, args: string[], valueIndex: number): { value: string; index: number } {
+	const value = args[valueIndex];
+	if (
+		value === undefined ||
+		!WINDOWS_PATH_VALUE_FLAGS.has(flag) ||
+		!WINDOWS_PATH_START_RE.test(value) ||
+		WINDOWS_MODULE_PATH_SUFFIX_RE.test(value)
+	) {
+		return { value: value ?? "", index: valueIndex };
+	}
+
+	let candidate = value;
+	for (let index = valueIndex + 1; index < args.length; index++) {
+		const next = args[index];
+		if (next === PROFILE_BOOTSTRAP_BOUNDARY_ARG || next.startsWith("-")) break;
+		candidate += ` ${next}`;
+		if (WINDOWS_MODULE_PATH_SUFFIX_RE.test(candidate)) {
+			return { value: candidate, index };
+		}
+	}
+
+	return { value, index: valueIndex };
+}
+
 export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {
 	// Work on a copy: the `--option=value` handling below splices the value
 	// into the array, and callers reuse the same argv (the post-extension
@@ -161,7 +190,9 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			// here only when its boolean extension is NOT loaded) would otherwise swallow
 			// the marker as its value and drop the user's trailing message.
 			if (i + 1 < args.length && args[i + 1] !== PROFILE_BOOTSTRAP_BOUNDARY_ARG) {
-				STRING_SETTERS[arg](result, args[++i], PARSE_DEPS);
+				const consumed = consumeBuiltInStringValue(arg, args, i + 1);
+				i = consumed.index;
+				STRING_SETTERS[arg](result, consumed.value, PARSE_DEPS);
 			}
 		} else if (OPTIONAL_VALUE_FLAGS.has(arg)) {
 			const config = OPTIONAL_FLAGS[arg];

package/src/cli/bench-cli.ts

@@ -8,9 +8,12 @@ import type {
 	Context,
 	Effort,
 	Model,
+	ProviderSessionState,
+	ServiceTier,
+	ServiceTierByFamily,
 	SimpleStreamOptions,
 } from "@oh-my-pi/pi-ai";
-import { streamSimple } from "@oh-my-pi/pi-ai";
+import { resolveModelServiceTier, streamSimple } from "@oh-my-pi/pi-ai";
 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";
@@ -23,12 +26,14 @@ import {
 	getModelMatchPreferences,
 	resolveCliModel,
 } from "../config/model-resolver";
+import { buildServiceTierByFamily, serviceTierForAllFamilies, serviceTierSettingToTier } from "../config/service-tier";
 import { Settings } from "../config/settings";
 import benchPrompt from "../prompts/bench.md" with { type: "text" };
 import { discoverAuthStorage, loadCliExtensionProviders } from "../sdk";
 import { resolveThinkingLevelForModel, shouldDisableReasoning, toReasoningEffort } from "../thinking";
 
-const DEFAULT_RUNS = 1;
+const DEFAULT_RUNS = 10;
+const DEFAULT_PAR = 4;
 const DEFAULT_MAX_TOKENS = 512;
 const ERROR_WIDTH = 110;
 const BENCH_PROMPT = benchPrompt.trim();
@@ -39,7 +44,10 @@ export interface BenchCommandArgs {
 		runs?: number;
 		maxTokens?: number;
 		prompt?: string;
+		/** Service-tier setting value (`none` omits); overrides the configured `serviceTier` setting. */
+		serviceTier?: string;
 		json?: boolean;
+		par?: number;
 	};
 }
 
@@ -99,6 +107,8 @@ export interface BenchSummary {
 	maxTokens: number;
 	models: BenchModelReport[];
 	failures: number;
+	/** Requested per-family service tiers, resolved per model before reaching the wire. */
+	serviceTierByFamily?: ServiceTierByFamily;
 }
 
 type BenchStreamSimple = (
@@ -131,6 +141,13 @@ function normalizePositiveInteger(name: string, value: number | undefined, fallb
 	return value;
 }
 
+function closeProviderSessionStates(providerSessionState: Map<string, ProviderSessionState>): void {
+	for (const state of providerSessionState.values()) {
+		state.close();
+	}
+	providerSessionState.clear();
+}
+
 function isFirstTokenEvent(event: AssistantMessageEvent): boolean {
 	switch (event.type) {
 		case "text_delta":
@@ -188,6 +205,8 @@ interface BenchRequestOptions {
 	reasoning?: Effort;
 	/** Only set for an explicit `:off` suffix — some endpoints reject disablement. */
 	disableReasoning?: boolean;
+	/** Requested service tier passed to `streamSimple`; absent omits the option. The provider layer applies scope/support gating before it reaches the wire. */
+	serviceTier?: ServiceTier;
 }
 
 async function runBenchRequest(
@@ -198,6 +217,7 @@ async function runBenchRequest(
 ): Promise<BenchRunResult> {
 	const startedAt = now();
 	let firstTokenAt: number | undefined;
+	const providerSessionState = new Map<string, ProviderSessionState>();
 	try {
 		const context: Context = {
 			// Codex's Responses endpoint 400s with "Instructions are required" when no
@@ -214,6 +234,9 @@ async function runBenchRequest(
 					: options.maxTokens,
 			reasoning: options.reasoning,
 			disableReasoning: options.disableReasoning,
+			serviceTier: options.serviceTier,
+			providerSessionState,
+			preferWebsockets: true,
 			// pi-ai opts every OpenRouter request into response caching (1h TTL).
 			// Bench sends a byte-identical request each run, so within the TTL
 			// OpenRouter replays the cached generation with zeroed usage — the run
@@ -270,6 +293,8 @@ async function runBenchRequest(
 		};
 	} catch (error) {
 		return { ok: false, error: getErrorMessage(error) };
+	} finally {
+		closeProviderSessionStates(providerSessionState);
 	}
 }
 
@@ -469,10 +494,11 @@ function resolveBenchModels(
 	}
 	return resolved;
 }
-
 export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDependencies = {}): Promise<BenchSummary> {
 	const runs = normalizePositiveInteger("runs", command.flags.runs, DEFAULT_RUNS);
 	const maxTokens = normalizePositiveInteger("max-tokens", command.flags.maxTokens, DEFAULT_MAX_TOKENS);
+	const par =
+		command.flags.par !== undefined ? normalizePositiveInteger("par", command.flags.par, DEFAULT_PAR) : DEFAULT_PAR;
 	const prompt = command.flags.prompt?.trim() || BENCH_PROMPT;
 	const json = command.flags.json === true;
 	const randomSessionId = deps.randomSessionId ?? (() => Bun.randomUUIDv7());
@@ -493,6 +519,18 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 	const runtime = await (deps.createRuntime ?? createDefaultRuntime)();
 	try {
 		const targets = resolveBenchModels(command.models, runtime.modelRegistry, runtime.settings, writeStderr);
+		// Explicit `--service-tier` (a single value broadcast across families) wins;
+		// otherwise fall back to the configured per-family `tier.*` settings. Each
+		// model resolves its own family's tier below before reaching the wire.
+		const flagTier = command.flags.serviceTier ? serviceTierSettingToTier(command.flags.serviceTier) : undefined;
+		const serviceTierByFamily = command.flags.serviceTier
+			? serviceTierForAllFamilies(flagTier)
+			: buildServiceTierByFamily(
+					runtime.settings?.get("tier.openai") ?? "none",
+					runtime.settings?.get("tier.anthropic") ?? "none",
+					runtime.settings?.get("tier.google") ?? "none",
+				);
+		if (!json && flagTier) writeStdout(`${chalk.dim(`service tier: ${flagTier}`)}\n`);
 		const reports: BenchModelReport[] = [];
 		for (const { selector, model, thinking } of targets) {
 			if (!json) {
@@ -501,21 +539,29 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 				writeStdout(`${chalk.bold(resolvedModel)}${resolvedNote}\n`);
 			}
 			const results: BenchRunResult[] = [];
-			for (let index = 0; index < runs; index++) {
-				const sessionId = randomSessionId();
-				const initialKey = await runtime.modelRegistry.getApiKey(model, sessionId);
-				if (!initialKey) {
-					const failure: BenchRunFailure = {
-						ok: false,
-						error: `No credentials for provider "${model.provider}". Run \`omp\` and use /login, or set the provider API key.`,
-					};
-					results.push(failure);
-					if (!json) writeStdout(`${formatRunLine(failure, index, runs)}\n`);
-					break; // remaining runs would fail identically
-				}
-				if (!json && interactive) {
-					writeStdout(chalk.dim(`  … run ${index + 1}/${runs} streaming`));
-				}
+
+			// Preflight check: let's verify credentials before starting any runs.
+			// This matches the old sequential break behavior exactly and avoids launching/printing
+			// multiple failures.
+			const testSessionId = randomSessionId();
+			const preflightKey = await runtime.modelRegistry.getApiKey(model, testSessionId);
+			if (!preflightKey) {
+				const failure: BenchRunFailure = {
+					ok: false,
+					error: `No credentials for provider "${model.provider}". Run \`omp\` and use /login, or set the provider API key.`,
+				};
+				results.push(failure);
+				if (!json) writeStdout(`${formatRunLine(failure, 0, runs)}\n`);
+				reports.push(buildModelReport(selector, model, thinking, results));
+				continue;
+			}
+
+			// We will launch up to `par` workers/requests concurrently.
+			// To keep output clean, non-JSON output emits entries in correct index order.
+			let nextToPrint = 0;
+
+			const runWorker = async (index: number) => {
+				const sessionId = index === 0 ? testSessionId : randomSessionId();
 				const result = await runBenchRequest(
 					model,
 					{
@@ -525,20 +571,49 @@ export async function runBenchCommand(command: BenchCommandArgs, deps: BenchDepe
 						maxTokens,
 						reasoning: toReasoningEffort(thinking),
 						disableReasoning: shouldDisableReasoning(thinking) ? true : undefined,
+						serviceTier: resolveModelServiceTier(serviceTierByFamily, model),
 					},
 					streamFn,
 					now,
 				);
-				results.push(result);
+				results[index] = result;
+			};
+
+			// Concurrency-limited running pool
+			const queue = Array.from({ length: runs }, (_, i) => i);
+			const activeWorkers: Promise<void>[] = [];
+
+			const processNext = async (): Promise<void> => {
+				if (queue.length === 0) return;
+				const index = queue.shift()!;
+
+				// Pre-print a status update if requested and interactive
+				if (!json && interactive) {
+					writeStdout(chalk.dim(`  … run ${index + 1}/${runs} streaming\n`));
+				}
+
+				await runWorker(index);
+
+				// Attempt to print completed results that are in-order
 				if (!json) {
-					if (interactive) writeStdout("\r\x1b[2K");
-					writeStdout(`${formatRunLine(result, index, runs)}\n`);
+					while (nextToPrint < runs && results[nextToPrint] !== undefined) {
+						const res = results[nextToPrint];
+						writeStdout(`${formatRunLine(res, nextToPrint, runs)}\n`);
+						nextToPrint++;
+					}
 				}
+
+				await processNext();
+			};
+
+			for (let w = 0; w < Math.min(par, runs); w++) {
+				activeWorkers.push(processNext());
 			}
+			await Promise.all(activeWorkers);
 			reports.push(buildModelReport(selector, model, thinking, results));
 		}
 		const failures = reports.reduce((sum, report) => sum + report.results.filter(result => !result.ok).length, 0);
-		const summary: BenchSummary = { runs, maxTokens, models: reports, failures };
+		const summary: BenchSummary = { runs, maxTokens, models: reports, failures, serviceTierByFamily };
 		if (json) {
 			writeStdout(`${JSON.stringify(summary, null, 2)}\n`);
 		} else if (reports.length > 1 || runs > 1) {

package/src/cli/tiny-models-cli.ts

@@ -28,12 +28,21 @@ interface ProgressReporter {
 interface DownloadResult {
 	model: TinyLocalModelKey;
 	ok: boolean;
+	error?: string;
 }
 
 function writeLine(text = ""): void {
 	process.stdout.write(`${text}\n`);
 }
 
+function downloadErrorSummary(error: string | undefined): string | undefined {
+	return error
+		?.split(/\r?\n/)
+		.map(line => line.trim())
+		.find(line => line.length > 0)
+		?.replace(/^Error:\s*/, "");
+}
+
 export function resolveModels(model: string | undefined): TinyLocalModelKey[] {
 	if (!model) return [DEFAULT_TINY_TITLE_LOCAL_MODEL_KEY];
 	// `all` is a prefetch convenience: skip models that fail before load (unsupported
@@ -101,10 +110,15 @@ async function downloadOne(modelKey: TinyLocalModelKey, json: boolean | undefine
 	const label = getTinyLocalModelSpec(modelKey)?.label ?? modelKey;
 	if (!json && !process.stdout.isTTY) writeLine(`Downloading ${label} (${modelKey})...`);
 	const progress = makeProgressReporter(modelKey, json);
-	const ok = await tinyTitleClient.downloadModel(modelKey, { onProgress: progress.onProgress });
-	progress.finish(ok);
-	if (!json && !process.stdout.isTTY) writeLine(ok ? `Downloaded ${label}.` : `Failed to download ${label}.`);
-	return { model: modelKey, ok };
+	const result = await tinyTitleClient.downloadModel(modelKey, { onProgress: progress.onProgress });
+	progress.finish(result.ok);
+	const error = downloadErrorSummary(result.error);
+	if (!json && !process.stdout.isTTY) {
+		writeLine(result.ok ? `Downloaded ${label}.` : `Failed to download ${label}${error ? `: ${error}` : ""}.`);
+	} else if (!json && !result.ok && error) {
+		writeLine(`${label} failed: ${error}`);
+	}
+	return result.error ? { model: modelKey, ok: result.ok, error: result.error } : { model: modelKey, ok: result.ok };
 }
 
 export async function runTinyModelsCommand(command: TinyModelsCommandArgs): Promise<void> {

package/src/cli/web-search-cli.ts

@@ -4,8 +4,10 @@
  * Handles `omp q`/`omp web-search` subcommands for testing web search providers.
  */
 
-import { APP_NAME } from "@oh-my-pi/pi-utils";
+import { APP_NAME, getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { applyProviderGlobalsFromSettings } from "../config/provider-globals";
+import { Settings } from "../config/settings";
 import { initTheme, theme } from "../modes/theme/theme";
 import { runSearchQuery, type SearchQueryParams } from "../web/search/index";
 import { SEARCH_PROVIDER_ORDER } from "../web/search/provider";
@@ -85,6 +87,9 @@ export async function runSearchCommand(cmd: SearchCommandArgs): Promise<void> {
 		process.exit(1);
 	}
 
+	const settings = await Settings.init({ cwd: getProjectDir() });
+	applyProviderGlobalsFromSettings(settings);
+
 	await initTheme();
 
 	const params: SearchQueryParams = {