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

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

@@ -3726,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": {
@@ -4935,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;
@@ -5202,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/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/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/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;
 }

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;