@oh-my-pi/pi-coding-agent 16.1.14 → 16.1.16

package/dist/types/advisor/runtime.d.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type SecretObfuscator } from "../secrets/obfuscator";
 /** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
 export interface AdvisorAgent {
     prompt(input: string): Promise<void>;
@@ -13,6 +14,8 @@ export interface AdvisorRuntimeHost {
     snapshotMessages(): AgentMessage[];
     /** Surface one advice note to the primary (enqueues into the session YieldQueue). */
     enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+    /** Redact primary transcript bytes before they reach the advisor model. */
+    obfuscator?: SecretObfuscator;
     /**
      * Pre-prompt context maintenance for the advisor's own append-only context.
      * Promotes the advisor model to a larger sibling when its context nears the

package/dist/types/cli/args.d.ts

@@ -1,7 +1,4 @@
-/**
- * CLI argument parsing and help display
- */
-import { type Effort } from "@oh-my-pi/pi-catalog/effort";
+import { type ConfiguredThinkingLevel } from "../thinking";
 export type Mode = "text" | "json" | "rpc" | "acp" | "rpc-ui";
 export interface Args {
     cwd?: string;
@@ -18,7 +15,7 @@ export interface Args {
     apiKey?: string;
     systemPrompt?: string;
     appendSystemPrompt?: string;
-    thinking?: Effort;
+    thinking?: ConfiguredThinkingLevel;
     hideThinking?: boolean;
     advisor?: boolean;
     continue?: boolean;

package/dist/types/cli/flag-tables.d.ts

@@ -29,7 +29,7 @@
  * tables), they're passed in through {@link ParseDeps} and `args.ts` wires the
  * 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";
 /**
  * Runtime dependencies injected into setters that need to validate input or
@@ -44,7 +44,7 @@ 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[];
 }

package/dist/types/cli/session-picker.d.ts

@@ -1,8 +1,10 @@
 import type { SessionInfo } from "../session/session-listing";
 /**
  * Show the TUI session selector and return the selected session, or null if
- * cancelled. Tab toggles between current-folder and all-projects scope; the
- * all-projects list is loaded lazily via `SessionManager.listAll`.
+ * cancelled. Rendered as a fullscreen overlay on the terminal's alternate
+ * screen, so the list scrolls and rows are clickable with the mouse. Tab
+ * toggles between current-folder and all-projects scope; the all-projects list
+ * is loaded lazily via `SessionManager.listAll`.
  */
 export declare function selectSession(sessions: SessionInfo[], options?: {
     allSessions?: SessionInfo[];

package/dist/types/commands/launch.d.ts

@@ -92,7 +92,7 @@ export default class Index extends Command {
         };
         thinking: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
-            options: import("@oh-my-pi/pi-catalog").Effort[];
+            options: string[];
         };
         "hide-thinking": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;

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

@@ -1636,6 +1636,26 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Share viewer/upload base used by /share (encrypted blob upload + viewer; links are <base>/<id>#<key>)";
         };
     };
+    readonly "share.store": {
+        readonly type: "enum";
+        readonly values: readonly ["blob", "gist"];
+        readonly default: "blob";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Share Store";
+            readonly description: "Where /share uploads the encrypted session blob";
+            readonly options: readonly [{
+                readonly value: "blob";
+                readonly label: "Encrypted Blob";
+                readonly description: "Upload to the share server (no GitHub account needed; avoids gist API rate limits)";
+            }, {
+                readonly value: "gist";
+                readonly label: "GitHub Gist";
+                readonly description: "Push to a secret gist (needs authenticated gh), falling back to the share server";
+            }];
+        };
+    };
     readonly "share.redactSecrets": {
         readonly type: "boolean";
         readonly default: true;
@@ -3706,7 +3726,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "tools";
             readonly group: "Discovery & MCP";
             readonly label: "Essential Tools Override";
-            readonly description: "Override the always-loaded built-in tools (default: read, bash, edit). Leave empty to use defaults.";
+            readonly description: "Override the always-loaded built-in tools (default: read, bash, edit, write, find, eval). Leave empty to use defaults.";
         };
     };
     readonly "mcp.enableProjectConfig": {
@@ -4915,6 +4935,16 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable Exa basic search, deep search, code search, and crawl tools";
         };
     };
+    readonly "exa.searchDelayMs": {
+        readonly type: "number";
+        readonly default: 1000;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Exa Search Delay";
+            readonly description: "Minimum delay between Exa web search requests in milliseconds; set 0 to disable pacing";
+        };
+    };
     readonly "exa.enableResearcher": {
         readonly type: "boolean";
         readonly default: false;
@@ -5182,6 +5212,7 @@ export interface TtsrSettings {
 export interface ExaSettings {
     enabled: boolean;
     enableSearch: boolean;
+    searchDelayMs: number;
     enableResearcher: boolean;
     enableWebsets: boolean;
 }

package/dist/types/eval/agent-bridge.d.ts

@@ -1,3 +1,4 @@
+import { type NestedRepoPatch } from "../task/worktree";
 import type { ToolSession } from "../tools";
 import type { JsStatusEvent } from "./js/shared/types";
 import "../tools/review";
@@ -17,6 +18,24 @@ export interface EvalAgentResult {
         id: string;
         model?: string | string[];
         structured: boolean;
+        /** True iff this run executed inside an isolation worktree. */
+        isolated?: boolean;
+        /** Captured patch artifact (patch mode) — surfaced regardless of `apply`. */
+        patchPath?: string;
+        /** Captured branch (branch mode) — surfaced regardless of `apply`. */
+        branchName?: string;
+        /** Captured nested repository patches — surfaced for isolated `apply=false` manual application. */
+        nestedPatches?: NestedRepoPatch[];
+        /**
+         * Tri-state apply outcome for isolated runs:
+         * - `true`  — apply ran (or had nothing to do) and left the repo clean.
+         * - `false` — apply attempted and failed; artifacts preserved.
+         * - `null`  — caller opted out via `apply=false`.
+         * Omitted for non-isolated runs.
+         */
+        changesApplied?: boolean | null;
+        /** Human-readable isolation apply/merge summary; kept out of schema-backed `text`. */
+        isolationSummary?: string;
     };
 }
 /**

package/dist/types/eval/js/shared/helpers.d.ts

@@ -1,13 +1,7 @@
 import type { JsStatusEvent } from "./types";
 export interface HelperOptions {
-    path?: string;
-    hidden?: boolean;
-    maxDepth?: number;
     limit?: number;
     offset?: number;
-    reverse?: boolean;
-    unique?: boolean;
-    count?: boolean;
 }
 /**
  * Inputs the helper factory needs from its host runtime. `cwd` is a getter so the runtime
@@ -27,18 +21,12 @@ export interface HelperContext {
 }
 /**
  * The set of functions exposed to user code via `globalThis.__omp_helpers__`. The JS
- * prelude reads from this bag and attaches short aliases (`read`, `write`, `tree`, ...)
+ * prelude reads from this bag and attaches short aliases (`read`, `write`, `env`, ...)
  * onto the global scope.
  */
 export interface HelperBundle {
     read(rawPath: string, options?: HelperOptions): Promise<string>;
     writeFile(rawPath: string, data: unknown): Promise<string>;
-    append(rawPath: string, content: string): Promise<string>;
-    sortText(text: string, options?: HelperOptions): string;
-    uniqText(text: string, options?: HelperOptions): string | Array<[number, string]>;
-    counter(items: string | string[], options?: HelperOptions): Array<[number, string]>;
-    diff(rawA: string, rawB: string): Promise<string>;
-    tree(searchPath?: string, options?: HelperOptions): Promise<string>;
     env(key?: string, value?: string): string | Record<string, string> | undefined;
 }
 export declare function createHelpers(ctx: HelperContext): HelperBundle;

package/dist/types/eval/js/shared/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * Structured status payload emitted by helpers (`read`, `write`, `tree`, etc.) and the
+ * Structured status payload emitted by helpers (`read`, `write`, `env`, etc.) and the
  * tool-call bridge. Surfaces to the model as part of `displays` so it has machine-readable
  * context about what side effects happened.
  */

package/dist/types/eval/js/worker-protocol.d.ts

@@ -5,7 +5,7 @@ export interface SessionSnapshot {
     sessionId: string;
     /**
      * On-disk roots the helpers substitute for internal-URL schemes
-     * (e.g. `{ local: "/…/artifacts/local" }`). Lets `read`/`write`/`append`
+     * (e.g. `{ local: "/…/artifacts/local" }`). Lets `read`/`write`
      * accept `local://…` paths instead of writing a literal `local:/` directory.
      */
     localRoots?: Record<string, string>;

package/dist/types/eval/py/executor.d.ts

@@ -45,7 +45,7 @@ export interface PythonExecutorOptions {
     artifactPath?: string;
     artifactId?: string;
     /**
-     * On-disk roots the prelude helpers (`read`/`write`/`append`) substitute for
+     * On-disk roots the prelude helpers (`read`/`write`) substitute for
      * internal-URL schemes (e.g. `{ local: "/…/artifacts/local" }`). Exported to
      * the kernel as `PI_EVAL_LOCAL_ROOTS` (JSON) so `write("local://x")` lands
      * where `read local://x` resolves instead of a literal `local:/` directory.

package/dist/types/export/share.d.ts

@@ -6,9 +6,16 @@ import { type SessionData } from "./html";
 export { DEFAULT_SHARE_URL };
 /** Hard cap for blobs accepted by the share server (mirrors relay shareMaxBytes). */
 export declare const SERVER_MAX_SEALED_BYTES = 1000000;
+export type ShareStore = "blob" | "gist";
 export interface ShareSessionOptions {
     /** Share server/viewer base URL; defaults to {@link DEFAULT_SHARE_URL}. */
     serverUrl?: string;
+    /**
+     * Where to upload the sealed blob. `"blob"` (default) posts to the share
+     * server; `"gist"` pushes to a secret GitHub gist first (needs an
+     * authenticated `gh`) and falls back to the server.
+     */
+    store?: ShareStore;
     /** Agent state for system prompt + tool descriptions in the snapshot. */
     state?: AgentState;
     /**
@@ -36,7 +43,7 @@ export interface ShareSessionResult {
 }
 /** Build the snapshot that gets sealed and uploaded, redacted when an obfuscator is provided. */
 export declare function buildShareSnapshot(sm: SessionManager, options?: ShareSessionOptions): SessionData;
-/** Share the session; tries a secret gist first, then the share server. */
+/** Share the session; uploads to the share server unless `options.store` is `"gist"`. */
 export declare function shareSession(sm: SessionManager, options?: ShareSessionOptions): Promise<ShareSessionResult>;
 /** Strip trailing slashes so `<base>/<id>` composes cleanly. */
 export declare function normalizeShareServerUrl(serverUrl?: string): string;

package/dist/types/internal-urls/local-protocol.d.ts

@@ -8,7 +8,7 @@ export declare function resolveLocalRoot(options: LocalProtocolOptions, platform
 /** Resolve a local:// URL to an on-disk path under the active session's local root. */
 export declare function resolveLocalUrlToPath(input: string | InternalUrl, options: LocalProtocolOptions, platform?: NodeJS.Platform): string;
 /**
- * On-disk roots the eval helpers (`read`/`write`/`append`) substitute for
+ * On-disk roots the eval helpers (`read`/`write`) substitute for
  * internal-URL schemes so e.g. `write("local://x.md")` lands where a later
  * `read local://x.md` resolves — instead of a literal `local:/` directory under
  * the cwd (a stdlib `pathlib.Path`/`path.resolve` collapses `local://` to
@@ -17,6 +17,23 @@ export declare function resolveLocalUrlToPath(input: string | InternalUrl, optio
  * re-plumbing the worker boundary.
  */
 export declare function buildEvalUrlRoots(options: LocalProtocolOptions): Record<string, string>;
+/**
+ * Resolve a local:// URL to a regular on-disk file, applying the same
+ * realpath + containment guarantees as {@link LocalProtocolHandler.resolve}
+ * but WITHOUT reading or UTF-8-decoding its contents. Returns null when there
+ * is no active session or when the URL targets the root listing or a directory;
+ * throws the handler's not-found and "escapes local root" errors for missing
+ * files and symlink escapes.
+ *
+ * Options are resolved via {@link LocalProtocolHandler.resolveOptions} so the
+ * caller-options → override → registry order matches router resolution exactly.
+ * The read tool uses this to detect and emit image files from their real path
+ * before the text-only resource contract would decode the binary into mojibake.
+ */
+export declare function resolveLocalUrlToFile(input: string | InternalUrl, context?: ResolveContext): Promise<{
+    path: string;
+    size: number;
+} | null>;
 /**
  * Protocol handler for local:// URLs.
  *

package/dist/types/main.d.ts

@@ -1,4 +1,5 @@
 import { type Args } from "./cli/args";
+import { selectSession } from "./cli/session-picker";
 import { ModelRegistry } from "./config/model-registry";
 import { type ScopedModel } from "./config/model-resolver";
 import { Settings } from "./config/settings";
@@ -59,6 +60,7 @@ export declare function applyResolvedSystemPromptInputs(options: CreateAgentSess
 interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
+    selectSession?: typeof selectSession;
     runAcpMode?: RunAcpMode;
     settings?: Settings;
     forceSetupWizard?: boolean;

package/dist/types/mcp/transports/stdio.d.ts

@@ -16,7 +16,18 @@ export interface ResolveStdioSpawnOptions {
     env: Record<string, string | undefined>;
     platform?: NodeJS.Platform;
 }
-/** Resolve the subprocess argv used to launch an MCP stdio server. */
+/**
+ * Resolve the subprocess argv used to launch an MCP stdio server.
+ *
+ * On Windows, our PATH/PATHEXT walk may return `null` for a bare command
+ * (e.g. `npx`) — `Bun.env.PATH` empty under a restricted parent process,
+ * UNC/network mounts that reject `fs.access`, locked-down shells. The
+ * legacy fallback handed `Bun.spawn` the bare name, but `CreateProcess`
+ * only appends `.exe` for extensionless names — `.cmd`/`.bat` are never
+ * tried, so `npx` (which exists only as `npx.cmd` on Windows) crashes the
+ * subprocess immediately. When the resolver can't pin the command down,
+ * route through `cmd.exe /d /s /c` so Windows's own PATHEXT lookup runs.
+ */
 export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
 interface FrameSink {

package/dist/types/modes/components/plugin-settings.d.ts

@@ -14,6 +14,11 @@ import type { InstalledPluginSummary } from "../../extensibility/plugins/marketp
 import type { InstalledPlugin } from "../../extensibility/plugins/types";
 /**
  * Forwards a keystroke to `input`, but cancels via `onCancel` when the user presses Escape.
+ *
+ * Escape is decoded via `matchesKey` rather than a raw `\x1b` compare: inside the
+ * fullscreen settings overlay the kitty keyboard protocol is active (ghostty/kitty),
+ * where the Escape key arrives as the CSI-u sequence `\x1b[27u`, not a bare `\x1b`.
+ * The literal fallbacks preserve legacy single/double-escape on terminals without it.
  */
 export declare function handleInputOrEscape(data: string, input: {
     handleInput(data: string): void;

package/dist/types/modes/components/session-selector.d.ts

@@ -39,6 +39,12 @@ declare class SessionList implements Component {
     /** Replace the visible dataset, e.g. when toggling folder/all-projects scope. */
     setSessions(sessions: SessionInfo[], showCwd: boolean): void;
     removeSession(sessionPath: string): void;
+    /** Resolve a list-local rendered-line index to a filtered-session index. */
+    hitTestSession(line: number): number | undefined;
+    /** Wheel notch: move the selection one step (clamped, no wrap). */
+    handleWheel(delta: -1 | 1): void;
+    /** Mouse click: select the session under the pointer and resume it. */
+    selectAndConfirm(index: number): void;
     invalidate(): void;
     render(width: number): readonly string[];
     handleInput(keyData: string): void;
@@ -55,6 +61,13 @@ export interface SessionSelectorOptions {
      * Omitted only in tests; defaults to a conservative 24 rows.
      */
     getTerminalRows?: () => number;
+    /**
+     * Fill the whole viewport and pin the footer (hint + bottom border) to the
+     * last rows, so the footer stops drifting as the list window changes height.
+     * Set by the standalone `--resume` picker (fullscreen alternate screen); the
+     * in-editor selector leaves it off and renders compactly.
+     */
+    fillHeight?: boolean;
 }
 /**
  * Component that renders a session selector with optional confirmation dialog
@@ -63,6 +76,18 @@ export declare class SessionSelectorComponent extends Container {
     #private;
     constructor(sessions: SessionInfo[], onSelect: (session: SessionInfo) => void, onCancel: () => void, onExit: () => void, options?: SessionSelectorOptions);
     setOnRequestRender(callback: () => void): void;
+    /**
+     * Concatenate the children's renders (like {@link Container}) while recording
+     * the line where the session list begins, so the fullscreen picker can hit-
+     * test mouse rows against the live list window. SessionList rebuilds its lines
+     * every frame, so Container's reference-memoization never applied here.
+     *
+     * In fill-height mode the body is padded (or, on a cramped terminal, trimmed)
+     * to leave exactly enough room for the footer at the screen bottom, so the
+     * footer is always visible and never drifts as the list window resizes. The
+     * in-editor selector just appends the footer directly.
+     */
+    render(width: number): readonly string[];
     handleInput(keyData: string): void;
     getSessionList(): SessionList;
 }

package/dist/types/modes/components/status-line/context-thresholds.d.ts

@@ -2,8 +2,9 @@ import type { ThemeColor } from "../../../modes/theme/theme";
 export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
 export declare function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel;
 /**
- * Format context usage as `<percent>%/<window>` (e.g. `5.1%/1M`), matching the
- * status line's context gauge so subagent and footer renderers stay in sync.
+ * Format context usage as `<percent>%/<window>` when the model window is known.
+ * Unknown windows render as `<tokens>/?`, because `0.0%/0` suggests a real
+ * empty context instead of missing provider metadata.
  */
-export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number): string;
+export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number, usedTokens?: number): string;
 export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

package/dist/types/modes/components/status-line/types.d.ts

@@ -72,6 +72,7 @@ export interface SegmentContext {
     };
     /** Context usage percent, or null when unknown (e.g. right after compaction). */
     contextPercent: number | null;
+    contextTokens: number;
     contextWindow: number;
     autoCompactEnabled: boolean;
     subagentCount: number;

package/dist/types/secrets/obfuscator.d.ts

@@ -34,9 +34,9 @@ export declare class SecretObfuscator {
 export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
 export declare function deobfuscateAgentMessages(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[];
 /**
- * Restore placeholders in assistant content: visible text, thinking text, and
- * tool-call arguments/intent/rawBlock. Signatures and redacted-thinking bytes
- * are opaque provider-replay data and pass through byte-identical.
+ * Restore placeholders in assistant content: visible text and tool-call
+ * arguments/intent/rawBlock. Thinking and signatures are opaque
+ * provider-replay/hidden-reasoning data and pass through byte-identical.
  */
 export declare function deobfuscateAssistantContent(obfuscator: SecretObfuscator, content: AssistantMessage["content"]): AssistantMessage["content"];
 /**

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/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

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;
 }