@oh-my-pi/pi-coding-agent 16.1.15 → 16.1.17

package/dist/types/task/isolation-runner.d.ts

@@ -0,0 +1,128 @@
+import type * as natives from "@oh-my-pi/pi-natives";
+import type { ToolSession } from "../tools";
+import type { ExecutorOptions } from "./executor";
+import type { SingleResult } from "./types";
+import { type WorktreeBaseline } from "./worktree";
+type IsoBackendKind = natives.IsoBackendKind;
+/** Resolved repo + baseline used by every isolated spawn in a single call. */
+export interface IsolationContext {
+    repoRoot: string;
+    baseline: WorktreeBaseline;
+}
+/**
+ * Resolve the git repo root and capture the worktree baseline used to diff
+ * each isolated spawn against. Throws when the cwd is not inside a git
+ * repository; callers surface the error as a task-tool failure.
+ */
+export declare function prepareIsolationContext(cwd: string): Promise<IsolationContext>;
+/** Build a commit-message callback for branch/nested commits; `undefined` ⇒ fall back to generic message. */
+export type BuildCommitMessage = () => undefined | ((diff: string) => Promise<string | null>);
+/**
+ * Construct the commit-message factory used by isolation branch commits and
+ * nested-repo patch commits. Returns a closure that, each time it's called,
+ * either yields an AI-backed `(diff) => Promise<string|null>` callback (when
+ * `task.isolation.commits === "ai"` and a model registry is available) or
+ * `undefined` so the caller falls back to a generic commit message.
+ *
+ * Centralized so `TaskTool` and the eval `agent()` bridge share one wiring;
+ * a drift here previously meant the two callers built subtly different
+ * generators for the same setting.
+ */
+export declare function makeIsolationCommitMessage(session: ToolSession): BuildCommitMessage;
+export interface IsolatedRunOptions {
+    /**
+     * Base run options handed to the subagent subprocess. This helper sets
+     * `worktree`, clears `preloadedExtensionPaths` / `preloadedCustomToolPaths`
+     * (isolated runs re-discover inside the worktree), and forwards everything
+     * else unchanged.
+     */
+    baseOptions: ExecutorOptions;
+    /** Context returned by {@link prepareIsolationContext}. Baseline is cloned per spawn. */
+    context: IsolationContext;
+    /** PAL backend hint from `parseIsolationMode(...)` (undefined ⇒ resolver picks). */
+    preferredBackend: IsoBackendKind | undefined;
+    /** Stable id used as the isolation worktree namespace and as the branch suffix. */
+    agentId: string;
+    /** Merge mode driving how changes are captured ("branch" commits, "patch" diffs). */
+    mergeMode: "patch" | "branch";
+    /** Output dir for `${agentId}.patch` artifacts (patch mode). */
+    artifactsDir: string;
+    /** Human description carried onto the branch commit (branch mode). */
+    description?: string;
+    /** Build a commit-message callback (`task.isolation.commits === "ai"`). */
+    buildCommitMessage?: BuildCommitMessage;
+    /**
+     * Construct a `SingleResult` when isolation setup throws — the caller has
+     * the full metadata (index, agent, assignment, modelOverride) needed to
+     * build a result shape consistent with their non-isolated path.
+     */
+    buildFailureResult: (err: unknown) => SingleResult;
+}
+/**
+ * Run a subagent inside an isolation worktree and capture its changes.
+ *
+ * Branch mode: on success, commits the diff onto `omp/task/${agentId}` and
+ * returns `branchName` + `nestedPatches`. On commit failure the branch is
+ * deleted and `result.error` carries the merge-failure message.
+ *
+ * Patch mode: on success, writes `${artifactsDir}/${agentId}.patch` and
+ * returns `patchPath` + `nestedPatches`.
+ *
+ * Failure paths preserve the underlying `SingleResult` whenever possible so
+ * the caller can still surface the subagent's output; only isolation setup
+ * itself routes through {@link IsolatedRunOptions.buildFailureResult}.
+ *
+ * The isolation handle is always torn down in `finally`.
+ */
+export declare function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<SingleResult>;
+export interface IsolationMergeOptions {
+    result: SingleResult;
+    repoRoot: string;
+    mergeMode: "patch" | "branch";
+}
+export interface IsolationMergeOutcome {
+    /** Trailing summary appended to the subagent's result text. May be empty. */
+    summary: string;
+    /**
+     * Tri-state apply outcome:
+     * - `true`  — merge ran (or had nothing to apply) and left the repo clean.
+     * - `false` — merge attempted and failed; artifacts are preserved.
+     * - `null`  — caller skipped the merge phase entirely (e.g. `apply=false`).
+     */
+    changesApplied: boolean | null;
+    hadAnyChanges: boolean;
+    /** True iff the root branch actually merged — gates nested-repo patch application. */
+    mergedBranchForNestedPatches: boolean;
+}
+/**
+ * Apply changes captured by {@link runIsolatedSubprocess} back to the parent
+ * repo: patch apply (patch mode) or cherry-pick + cleanup (branch mode).
+ *
+ * The caller decides whether to run this at all — eval `agent()` with
+ * `apply=False` skips this step and surfaces the patch artifact / branch name
+ * instead.
+ */
+export declare function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise<IsolationMergeOutcome>;
+export interface NestedPatchApplyOptions {
+    /** Subagent result carrying `nestedPatches`/`exitCode`/`aborted`. */
+    result: SingleResult;
+    repoRoot: string;
+    mergeMode: "patch" | "branch";
+    /** Parent merge outcome — patch mode skips nested apply when this is `false`. */
+    changesApplied: boolean | null;
+    /** Branch mode gates nested apply on whether the root branch merged. */
+    mergedBranchForNestedPatches: boolean;
+    /** Optional AI commit-message callback for nested commits; falls back to a generic message. */
+    commitMessage?: (diff: string) => Promise<string | null>;
+}
+/**
+ * Apply nested-repo patches after the parent merge phase. Centralizes the
+ * three-way gate (exitCode/aborted, patch-mode failed parent, branch-mode
+ * branch-merged) and the non-fatal failure handling so `TaskTool` and the
+ * eval `agent()` bridge use one implementation.
+ *
+ * Returns a system-notification suffix to append to the parent merge summary,
+ * or an empty string when nothing was applied or the nested apply succeeded.
+ */
+export declare function applyEligibleNestedPatches(opts: NestedPatchApplyOptions): Promise<string>;
+export {};

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

@@ -25,6 +25,10 @@ export interface ParallelResult<R> {
 export declare function mapWithConcurrencyLimit<T, R>(items: T[], concurrency: number, fn: (item: T, index: number, signal: AbortSignal) => Promise<R>, signal?: AbortSignal): Promise<ParallelResult<R>>;
 /**
  * Simple counting semaphore for limiting concurrency across independently-scheduled async work.
+ *
+ * `max <= 0` (or any non-finite input) means unbounded — every `acquire()` resolves
+ * immediately — matching `task.maxConcurrency = 0`'s "Unlimited" semantics in the
+ * settings UI ([#3305](https://github.com/can1357/oh-my-pi/issues/3305)).
  */
 export declare class Semaphore {
     #private;

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

@@ -33,10 +33,23 @@ export interface DeltaPatchResult {
 export declare function captureDeltaPatch(isolationDir: string, baseline: WorktreeBaseline): Promise<DeltaPatchResult>;
 /**
  * Apply nested repo patches directly to their working directories after parent merge.
+ *
+ * Pre-existing dirty state in a nested repo is stashed before the patch is
+ * applied and popped back (with `--index` so staged WIP stays staged) after
+ * the commit, so unrelated user edits never get folded into the agent's
+ * commit. A failing `git stash pop` (e.g. user edits collide with the patched
+ * lines) leaves the stash entry intact, emits a `logger.warn`, and is
+ * returned to the caller as a human-readable warning string — the agent
+ * commit already landed, so this is a partial success the workflow needs to
+ * see, not a thrown failure.
+ *
+ * Returns the collected stash-restore warnings (empty when every nested repo
+ * was restored cleanly). Throws when the patch apply itself fails.
+ *
  * @param commitMessage Optional async function to generate a commit message from the combined diff.
  *                      If omitted or returns null, falls back to a generic message.
  */
-export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<void>;
+export declare function applyNestedPatches(repoRoot: string, patches: NestedRepoPatch[], commitMessage?: (diff: string) => Promise<string | null>): Promise<string[]>;
 /**
  * User-facing isolation mode names exposed by the `task.isolation.mode`
  * setting. Mapped to a backend-kind hint via {@link parseIsolationMode};

package/dist/types/thinking.d.ts

@@ -55,6 +55,21 @@ export interface ConfiguredThinkingLevelMetadata {
 export declare function parseConfiguredThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined;
 /** Returns display metadata for a configured selector, including `auto`. */
 export declare function getConfiguredThinkingLevelMetadata(level: ConfiguredThinkingLevel): ConfiguredThinkingLevelMetadata;
+/**
+ * Thinking selectors accepted by the `--thinking` CLI flag, in display order:
+ * `off`, every concrete effort (`minimal`..`xhigh`), then `auto`. Single source
+ * for the flag's `options` list, shell completions, and the "invalid level"
+ * warning so all three stay in sync.
+ */
+export declare const CLI_THINKING_LEVELS: readonly string[];
+/**
+ * Parses a `--thinking` CLI value. Accepts every {@link parseConfiguredThinkingLevel}
+ * selector (`off`, `auto`, `minimal`..`xhigh`, plus the `max` alias) but rejects
+ * `inherit`: an explicit `inherit` on the command line would suppress the
+ * settings/scoped-model fallback during startup resolution only to resolve back
+ * to the provider default, which is never what the user means.
+ */
+export declare function parseCliThinkingLevel(value: string | null | undefined): ConfiguredThinkingLevel | undefined;
 /**
  * Resolves an auto-classified effort against the active model's supported
  * range. Unlike {@link clampThinkingLevelForModel}, `auto` never resolves below
@@ -62,8 +77,15 @@ export declare function getConfiguredThinkingLevelMetadata(level: ConfiguredThin
  * above Low (falling back to the full supported set only when the model maxes
  * out below Low). Within that pool the request snaps to the highest level not
  * exceeding it, or the pool minimum when the request is below the pool.
+ *
+ * Returns `undefined` for reasoning-capable models without a controllable
+ * effort surface (`thinking.efforts` empty — e.g. devin-agent models, where
+ * Cascade selects effort by routing to sibling model ids). Matches
+ * {@link clampThinkingLevelForModel}: with no effort to pick, `auto` must not
+ * forward a concrete effort that would then trip {@link requireSupportedEffort}
+ * downstream.
  */
-export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort;
+export declare function clampAutoThinkingEffort(model: Model | undefined, effort: Effort): Effort | undefined;
 /**
  * The provisional concrete level shown while `auto` is configured but before a
  * turn has been classified. Prefers the model's `defaultLevel`, otherwise High,

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

@@ -1,4 +1,4 @@
-import { type SpawnedSubprocess, type WorkerHandle } from "../subprocess/worker-client";
+import { type RefCountedWorkerHandle, type SpawnedSubprocess } from "../subprocess/worker-client";
 import type { TinyTitleProgressEvent, TinyTitleWorkerInbound, TinyTitleWorkerOutbound } from "./title-protocol";
 export interface TinyTitleDownloadOptions {
     signal?: AbortSignal;
@@ -44,7 +44,7 @@ export declare function tinyWorkerEnv(): Record<string, string>;
 export declare function createTinyTitleSubprocess(): SpawnedSubprocess<TinyTitleWorkerOutbound>;
 export declare class TinyTitleClient {
     #private;
-    constructor(spawnWorker?: () => WorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
+    constructor(spawnWorker?: () => RefCountedWorkerHandle<TinyTitleWorkerInbound, TinyTitleWorkerOutbound>);
     onProgress(listener: (event: TinyTitleProgressEvent) => void): () => void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;

package/dist/types/tools/eval-render.d.ts

@@ -20,6 +20,9 @@ interface EvalRenderCellArg {
     title?: string;
 }
 interface EvalRenderArgs {
+    language?: string;
+    code?: string;
+    title?: string;
     cells?: EvalRenderCellArg[];
     __partialJson?: string;
 }

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

@@ -6,29 +6,21 @@ export { EVAL_DEFAULT_PREVIEW_LINES, evalToolRenderer } from "./eval-render";
 /** Language tokens the eval tool accepts, in stable display order. */
 export type EvalLanguageToken = "py" | "js" | "rb" | "jl";
 /**
- * Per-cell input. Each cell runs in order; state persists within a language
- * across cells and across tool calls. This static schema carries the full
- * language union for typing; {@link buildEvalSchema} narrows the wire copy per
- * session so disabled backends are never advertised to the model.
+ * Per-call input: a single cell. State persists within a language across
+ * separate eval calls and across tool calls, so each call is one logical step
+ * and later calls reuse what earlier ones defined. This static schema carries
+ * the full language union for typing; {@link buildEvalSchema} narrows the wire
+ * copy per session so disabled backends are never advertised to the model.
  */
-declare const evalCellSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+export declare const evalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     title?: string | undefined;
     timeout?: number | undefined;
     reset?: boolean | undefined;
     language: "jl" | "js" | "py" | "rb";
     code: string;
 }, {}>;
-export type EvalCellInput = typeof evalCellSchema.infer;
-export declare const evalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    cells: {
-        title?: string | undefined;
-        timeout?: number | undefined;
-        reset?: boolean | undefined;
-        language: "jl" | "js" | "py" | "rb";
-        code: string;
-    }[];
-}, {}>;
 export type EvalToolParams = typeof evalSchema.infer;
+export type EvalCellInput = EvalToolParams;
 export type EvalToolResult = {
     content: Array<{
         type: "text";
@@ -62,10 +54,12 @@ export declare class EvalTool implements AgentTool<typeof evalSchema> {
     readonly approval: "exec";
     readonly formatApprovalDetails: (args: unknown) => string[];
     get summary(): string;
-    readonly loadMode = "discoverable";
+    readonly loadMode = "essential";
     readonly label = "Eval";
     get description(): string;
-    readonly examples: readonly ToolExample<typeof evalSchema.infer>[];
+    /** All reuse-chain examples; the `examples` getter filters by enabled languages. */
+    private static readonly ALL_EXAMPLES;
+    get examples(): readonly ToolExample<typeof evalSchema.infer>[];
     get parameters(): typeof evalSchema;
     readonly concurrency = "exclusive";
     readonly strict = true;

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

@@ -24,16 +24,14 @@ export interface TodoToolDetails {
     completedTasks?: TodoCompletionTransition[];
 }
 declare const todoSchema: import("arktype/internal/variants/object.ts").ObjectType<{
-    ops: {
-        op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
-        list?: {
-            phase: string;
-            items: string[];
-        }[] | undefined;
-        task?: string | undefined;
-        phase?: string | undefined;
-        items?: string[] | undefined;
-    }[];
+    op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
+    list?: {
+        phase: string;
+        items: string[];
+    }[] | undefined;
+    task?: string | undefined;
+    phase?: string | undefined;
+    items?: string[] | undefined;
 }, {}>;
 type TodoParams = TodoSchema;
 type TodoSchema = typeof todoSchema.infer;
@@ -70,7 +68,7 @@ export declare function selectStickyTodoWindow(tasks: TodoItem[], maxVisible?: n
  */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
 /** Apply an array of `todo`-style ops to existing phases. Used by /todo slash command. */
-export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams["ops"]): {
+export declare function applyOpsToPhases(currentPhases: TodoPhase[], ops: TodoParams[]): {
     phases: TodoPhase[];
     errors: string[];
 };
@@ -90,16 +88,14 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
     readonly summary = "Write a structured todo list to track progress within a session";
     readonly description: string;
     readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
-        ops: {
-            op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
-            list?: {
-                phase: string;
-                items: string[];
-            }[] | undefined;
-            task?: string | undefined;
-            phase?: string | undefined;
-            items?: string[] | undefined;
-        }[];
+        op: "append" | "done" | "drop" | "init" | "rm" | "start" | "view";
+        list?: {
+            phase: string;
+            items: string[];
+        }[] | undefined;
+        task?: string | undefined;
+        phase?: string | undefined;
+        items?: string[] | undefined;
     }, {}>;
     readonly concurrency = "exclusive";
     readonly strict = true;
@@ -108,13 +104,15 @@ export declare class TodoTool implements AgentTool<typeof todoSchema, TodoToolDe
     constructor(session: ToolSession);
     execute(_toolCallId: string, params: TodoParams, _signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<TodoToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<TodoToolDetails>>;
 }
-type TodoRenderArgs = {
-    ops?: Array<{
-        op?: string;
-        task?: string;
-        phase?: string;
-        items?: string[];
-    }>;
+type TodoRenderOp = {
+    op?: string;
+    task?: string;
+    phase?: string;
+    items?: string[];
+};
+/** New single-op shape `{op,...}`; legacy `{ops:[...]}` still seen in old transcripts. */
+type TodoRenderArgs = TodoRenderOp & {
+    ops?: TodoRenderOp[];
 };
 /** One-based ASCII roman numeral for display (I, II, III, IV, …). */
 export declare function phaseRomanNumeral(oneBasedIndex: number): string;

package/dist/types/tui/output-block.d.ts

@@ -26,6 +26,14 @@ export type FramedBlockComponent = Component & {
 };
 export declare function markFramedBlockComponent<T extends Component>(component: T): T & FramedBlockComponent;
 export declare function isFramedBlockComponent(component: Component): boolean;
+/**
+ * Inner content width that {@link renderOutputBlock} wraps its body to, for a
+ * given outer `width`: both vertical borders (1 cell each) plus the left
+ * content padding. Renderers that size a tail window MUST budget visual rows
+ * against this, not the outer width — otherwise the block re-wraps their lines
+ * into more rows than they counted and the box overflows its intended height.
+ */
+export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number): number;
 export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
 /**
  * Cached wrapper around `renderOutputBlock`.

package/dist/types/utils/image-resize.d.ts

@@ -2,6 +2,8 @@ import type { ImageContent } from "@oh-my-pi/pi-ai";
 export interface ImageResizeOptions {
     maxWidth?: number;
     maxHeight?: number;
+    /** Smallest allowed edge length (px). Inputs below this are scaled up. */
+    minDimension?: number;
     maxBytes?: number;
     jpegQuality?: number;
     excludeWebP?: boolean;

package/dist/types/utils/tools-manager.d.ts

@@ -1,6 +1,8 @@
 export declare function ffmpegAssetName(_version: string, plat: string, architecture: string): string | null;
 export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura" | "ffmpeg";
 export declare function getToolPath(tool: ToolName): string | null;
+/** Download a tool asset without handing the streaming Response to Bun.write. */
+export declare function downloadFile(url: string, dest: string, signal?: AbortSignal): Promise<void>;
 type EnsureToolOptions = {
     signal?: AbortSignal;
     silent?: boolean;

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

@@ -10,6 +10,8 @@ import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types";
 import type { SearchParams } from "./base";
 import { SearchProvider } from "./base";
+/** Reset Exa request pacing state for isolated provider tests. */
+export declare function resetExaSearchThrottleForTest(): void;
 type ExaSearchType = "neural" | "fast" | "auto" | "deep";
 type ExaSearchParamType = ExaSearchType | "keyword";
 export interface ExaSearchParams {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.15",
+	"version": "16.1.17",
 	"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.15",
-		"@oh-my-pi/omp-stats": "16.1.15",
-		"@oh-my-pi/pi-agent-core": "16.1.15",
-		"@oh-my-pi/pi-ai": "16.1.15",
-		"@oh-my-pi/pi-catalog": "16.1.15",
-		"@oh-my-pi/pi-mnemopi": "16.1.15",
-		"@oh-my-pi/pi-natives": "16.1.15",
-		"@oh-my-pi/pi-tui": "16.1.15",
-		"@oh-my-pi/pi-utils": "16.1.15",
-		"@oh-my-pi/pi-wire": "16.1.15",
-		"@oh-my-pi/snapcompact": "16.1.15",
+		"@oh-my-pi/hashline": "16.1.17",
+		"@oh-my-pi/omp-stats": "16.1.17",
+		"@oh-my-pi/pi-agent-core": "16.1.17",
+		"@oh-my-pi/pi-ai": "16.1.17",
+		"@oh-my-pi/pi-catalog": "16.1.17",
+		"@oh-my-pi/pi-mnemopi": "16.1.17",
+		"@oh-my-pi/pi-natives": "16.1.17",
+		"@oh-my-pi/pi-tui": "16.1.17",
+		"@oh-my-pi/pi-utils": "16.1.17",
+		"@oh-my-pi/pi-wire": "16.1.17",
+		"@oh-my-pi/snapcompact": "16.1.17",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/scripts/build-binary.ts

@@ -5,7 +5,15 @@ import * as path from "node:path";
 
 const packageDir = path.join(import.meta.dir, "..");
 const repoRoot = path.join(packageDir, "..", "..");
-const outputPath = path.join(packageDir, "dist", "omp");
+// Optional cross-compile target, e.g. CROSS_TARGET=linux-arm64 → bun build
+// --target=bun-linux-arm64, embeds the matching native, outputs dist/omp-<target>.
+const crossTarget = Bun.env.CROSS_TARGET || null;
+const [crossPlatform, crossArch] = crossTarget ? crossTarget.split("-") : [null, null];
+// x64 uses the baseline bun runtime so it runs under Rosetta / pre-AVX2 CPUs
+// (the modern bun-linux-x64 target SIGILLs under Apple-Silicon Rosetta).
+const bunTarget = crossTarget ? (crossTarget === "linux-x64" ? "bun-linux-x64-baseline" : `bun-${crossTarget}`) : null;
+const outName = crossTarget ? `omp-${crossTarget}` : "omp";
+const outputPath = path.join(packageDir, "dist", outName);
 
 // Transformers.js is an optional, native-heavy dependency that is never bundled
 // into the binary; the tiny-model worker `bun install`s it into a runtime cache
@@ -17,7 +25,7 @@ const transformersVersion = (
 ).version;
 
 function shouldAdhocSignDarwinBinary(): boolean {
-	return process.platform === "darwin";
+	return process.platform === "darwin" && !crossTarget;
 }
 
 async function runCommand(
@@ -43,7 +51,12 @@ async function main(): Promise<void> {
 	try {
 		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
 		await runCommand(["bun", "scripts/generate-docs-index.ts", "--generate"]);
-		await runCommand(["bun", "--cwd=../natives", "run", "embed:native"]);
+		await runCommand(
+			["bun", "--cwd=../natives", "run", "embed:native"],
+			crossTarget
+				? { ...Bun.env, TARGET_PLATFORM: crossPlatform as string, TARGET_ARCH: crossArch as string }
+				: Bun.env,
+		);
 		await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--generate"]);
 		try {
 			const buildEnv = shouldAdhocSignDarwinBinary() ? { ...Bun.env, BUN_NO_CODESIGN_MACHO_BINARY: "1" } : Bun.env;
@@ -52,6 +65,7 @@ async function main(): Promise<void> {
 					"bun",
 					"build",
 					"--compile",
+					...(bunTarget ? ["--target", bunTarget] : []),
 					"--no-compile-autoload-bunfig",
 					"--no-compile-autoload-dotenv",
 					"--no-compile-autoload-tsconfig",
@@ -85,7 +99,7 @@ async function main(): Promise<void> {
 					"./packages/coding-agent/src/extensibility/legacy-pi-ai-shim.ts",
 					"./packages/coding-agent/src/extensibility/legacy-pi-coding-agent-shim.ts",
 					"--outfile",
-					"packages/coding-agent/dist/omp",
+					`packages/coding-agent/dist/${outName}`,
 				],
 				buildEnv,
 				repoRoot,

package/src/auto-thinking/classifier.ts

@@ -55,10 +55,15 @@ export interface ClassifyDifficultyDeps {
 }
 
 /**
- * Classify `promptText` and return a concrete effort clamped to `deps.model`.
+ * Classify `promptText` and return a concrete effort clamped to `deps.model`,
+ * or `undefined` when the model has no controllable effort surface (auto has
+ * nothing to pick — the caller leaves the prior reasoning level in place).
  * @throws when the backend cannot produce a usable classification.
  */
-export async function classifyDifficulty(promptText: string, deps: ClassifyDifficultyDeps): Promise<Effort> {
+export async function classifyDifficulty(
+	promptText: string,
+	deps: ClassifyDifficultyDeps,
+): Promise<Effort | undefined> {
 	const backend = deps.settings.get("providers.autoThinkingModel");
 	const input = prepareClassifierInput(promptText);
 	const effort =

package/src/cli/args.ts

@@ -1,10 +1,9 @@
 /**
  * CLI argument parsing and help display
  */
-import { type Effort, THINKING_EFFORTS } from "@oh-my-pi/pi-catalog/effort";
 import { APP_NAME, CONFIG_DIR_NAME, logger } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import { parseEffort } from "../thinking";
+import { CLI_THINKING_LEVELS, type ConfiguredThinkingLevel, parseCliThinkingLevel } from "../thinking";
 import { BUILTIN_TOOL_NAMES } from "../tools/builtin-names";
 import {
 	OPTIONAL_FLAGS,
@@ -32,7 +31,7 @@ export interface Args {
 	apiKey?: string;
 	systemPrompt?: string;
 	appendSystemPrompt?: string;
-	thinking?: Effort;
+	thinking?: ConfiguredThinkingLevel;
 	hideThinking?: boolean;
 	advisor?: boolean;
 	continue?: boolean;
@@ -89,9 +88,9 @@ export interface Args {
  */
 const PARSE_DEPS: ParseDeps = {
 	logger,
-	parseEffort,
+	parseThinking: parseCliThinkingLevel,
 	builtinToolNames: BUILTIN_TOOL_NAMES,
-	thinkingEfforts: THINKING_EFFORTS,
+	thinkingEfforts: CLI_THINKING_LEVELS,
 };
 
 export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { type: "boolean" | "string" }>): Args {

package/src/cli/flag-tables.ts

@@ -30,7 +30,7 @@
  * real implementations at the dispatch site.
  */
 
-import type { Effort } from "@oh-my-pi/pi-ai";
+import type { ConfiguredThinkingLevel } from "../thinking";
 import type { Args } from "./args";
 
 /**
@@ -44,7 +44,7 @@ import type { Args } from "./args";
  */
 export interface ParseDeps {
 	logger: { warn: (message: string, meta?: Record<string, unknown>) => void };
-	parseEffort: (value: string | null | undefined) => Effort | undefined;
+	parseThinking: (value: string | null | undefined) => ConfiguredThinkingLevel | undefined;
 	builtinToolNames: readonly string[];
 	thinkingEfforts: readonly string[];
 }
@@ -165,7 +165,7 @@ export const STRING_SETTERS: Record<string, StringSetter> = {
 		result.tools = valid;
 	},
 	"--thinking": (result, value, deps) => {
-		const thinking = deps.parseEffort(value);
+		const thinking = deps.parseThinking(value);
 		if (thinking !== undefined) {
 			result.thinking = thinking;
 		} else {

package/src/cli/gallery-fixtures/interaction.ts

@@ -5,17 +5,14 @@ export const interactionFixtures: Record<string, GalleryFixture> = {
 	todo: {
 		label: "Todo",
 		streamingArgs: {
-			ops: [{ op: "init", list: [{ phase: "Foundation", items: ["Scaffold crate"] }] }],
+			op: "init",
+			list: [{ phase: "Foundation", items: ["Scaffold crate"] }],
 		},
 		args: {
-			ops: [
-				{
-					op: "init",
-					list: [
-						{ phase: "Foundation", items: ["Scaffold crate", "Wire workspace"] },
-						{ phase: "Auth", items: ["Port credential store", "Wire OAuth providers"] },
-					],
-				},
+			op: "init",
+			list: [
+				{ phase: "Foundation", items: ["Scaffold crate", "Wire workspace"] },
+				{ phase: "Auth", items: ["Port credential store", "Wire OAuth providers"] },
 			],
 		},
 		result: {