@oh-my-pi/pi-coding-agent 17.1.6 → 17.1.8

package/dist/types/advisor/advise-tool.d.ts

@@ -36,13 +36,6 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
  * and `blocker` interrupt; a plain `nit` queues.
  */
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
-/**
- * Append a staleness caveat to an advisor note when newer primary turns arrived
- * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
- * advisor runtime at delivery time). Pure function — no session coupling — so it
- * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
- */
-export declare function annotateForStaleness(note: string, hasFreshBacklog: boolean): string;
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
 /** Half-open turn-count fence for the post-interrupt cooldown. */

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

@@ -95,15 +95,6 @@ export declare class AdvisorRuntime {
     get failureNotified(): boolean;
     /** True after the runtime hard-stopped on repeated or permanent failures. */
     get halted(): boolean;
-    /**
-     * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
-     * primary turns arrived after the current batch's transcript window was fixed
-     * but before the advisor model finished processing it. The delivery path uses
-     * this to annotate advice that was generated without seeing those newer turns.
-     * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
-     * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
-     */
-    get hasFreshBacklog(): boolean;
     /**
      * Called after each primary turn ends. Renders the incremental delta and
      * queues it for the advisor model.

package/dist/types/async/job-manager.d.ts

@@ -129,6 +129,17 @@ export declare class AsyncJobManager {
      * (used by `dispose()` to nuke the manager's state).
      */
     cancelAll(filter?: AsyncJobFilter): void;
+    /**
+     * Immediately evict completed and failed jobs matching the filter instead of
+     * waiting for retention expiry, dropping every queued delivery so a prior
+     * session's result can never be injected into a later transcript. Returns the
+     * number of jobs evicted.
+     *
+     * A delivery whose sink call is already in flight (or drained onto a caller's
+     * yield queue) is guarded by the owner's delivery generation, not the per-id
+     * suppression marker — that marker is cleared when the id is reused.
+     */
+    evictCompletedJobs(filter?: AsyncJobFilter): number;
     waitForAll(): Promise<void>;
     /**
      * Route completions for jobs owned by `ownerId` to `sink`. Sessions register

package/dist/types/cleanse/agent.d.ts

@@ -0,0 +1,19 @@
+import type { CleanseAgentOutcome, CleanseAssignment, CleanseDiagnosticReport, CleanseLoopResult } from "./types.js";
+/** Hooks used by the standalone command to render subagent lifecycle progress. */
+export interface CleanseAgentHooks {
+    onStart?(name: string, assignment: CleanseAssignment): void;
+    onFinish?(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): void;
+}
+/** Persisted parent session that dispatches file-disjoint cleanse workers. */
+export interface CleanseAgentRuntime {
+    readonly model: string;
+    readonly sessionFile: string;
+    dispatch(assignments: CleanseAssignment[], wave: number, report: CleanseDiagnosticReport, signal?: AbortSignal): Promise<CleanseAgentOutcome[]>;
+    close(result?: CleanseLoopResult): Promise<void>;
+}
+/** Resolve the requested model and create a fresh persisted cleanse session. */
+export declare function createCleanseAgentRuntime(options: {
+    cwd?: string;
+    model: string;
+    hooks?: CleanseAgentHooks;
+}): Promise<CleanseAgentRuntime>;

package/dist/types/cleanse/balance.d.ts

@@ -0,0 +1,7 @@
+import type { CleanseAssignment, CleanseDiagnostic, CleanseFileIssues } from "./types.js";
+/** Estimate repair burden from severity and available location/fix evidence. */
+export declare function diagnosticWeight(diagnostic: CleanseDiagnostic): number;
+/** Group diagnostics by file while keeping project-level failures together. */
+export declare function groupDiagnosticsByFile(diagnostics: readonly CleanseDiagnostic[]): CleanseFileIssues[];
+/** Balance whole-file workloads with longest-processing-time bin packing. */
+export declare function balanceDiagnostics(diagnostics: readonly CleanseDiagnostic[], maxAgents: number): CleanseAssignment[];

package/dist/types/cleanse/checkers.d.ts

@@ -0,0 +1,13 @@
+import type { CleanseDiagnosticReport, SkippedCleanseCheck } from "./types.js";
+/** Optional checker families enabled for a cleanse run. */
+export interface CleanseDiagnosticSuiteOptions {
+    includeTests?: boolean;
+}
+/** Re-runnable checker set discovered from one project snapshot. */
+export interface CleanseDiagnosticSuite {
+    readonly checkCount: number;
+    readonly skipped: readonly SkippedCleanseCheck[];
+    run(signal?: AbortSignal): Promise<CleanseDiagnosticReport>;
+}
+/** Discover configured language checkers without installing missing tools. */
+export declare function discoverCleanseDiagnosticSuite(projectCwd: string, options?: CleanseDiagnosticSuiteOptions): Promise<CleanseDiagnosticSuite>;

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

@@ -0,0 +1,16 @@
+import type { CleanseDiagnosticReport } from "./types.js";
+/** User-facing options for `omp cleanse`. */
+export interface CleanseCommandOptions {
+    maxAgents?: number;
+    model?: string;
+    includeTests?: boolean;
+}
+/** Observable completion state returned to the CLI adapter. */
+export interface CleanseCommandResult {
+    exitCode: number;
+    status: "clean" | "unresolved" | "unsupported" | "cancelled";
+    report: CleanseDiagnosticReport;
+    sessionFile?: string;
+}
+/** Detect project diagnostics, dispatch one bounded repair batch, and verify it. */
+export declare function runCleanseCommand(options?: CleanseCommandOptions): Promise<CleanseCommandResult>;

package/dist/types/cleanse/loop.d.ts

@@ -0,0 +1,16 @@
+import type { CleanseAgentOutcome, CleanseAssignment, CleanseDiagnosticReport, CleanseLoopResult } from "./types.js";
+/** Runtime seams for one bounded diagnose, dispatch, and verify pass. */
+export interface CleanseLoopDependencies {
+    collect(signal?: AbortSignal): Promise<CleanseDiagnosticReport>;
+    dispatch(assignments: CleanseAssignment[], wave: number, report: CleanseDiagnosticReport, signal?: AbortSignal): Promise<CleanseAgentOutcome[]>;
+    onWave?(wave: number, assignments: readonly CleanseAssignment[]): void;
+    onReport?(wave: number, report: CleanseDiagnosticReport): void;
+}
+/** Inputs controlling one complete cleanse loop. */
+export interface CleanseLoopOptions {
+    maxAgents: number;
+    initialReport: CleanseDiagnosticReport;
+    signal?: AbortSignal;
+}
+/** Dispatch at most `maxAgents` workers once, then verify their combined edits. */
+export declare function runCleanseLoop(options: CleanseLoopOptions, dependencies: CleanseLoopDependencies): Promise<CleanseLoopResult>;

package/dist/types/cleanse/parsers.d.ts

@@ -0,0 +1,13 @@
+import type { CleanseDiagnostic } from "./types.js";
+/** Machine and fallback output formats understood by cleanse. */
+export type CleanseParserKind = "rust" | "rust-test" | "go" | "go-test" | "ruff" | "pyright" | "eslint" | "biome" | "rubocop" | "phpstan" | "psalm" | "swiftlint" | "dart" | "credo" | "shellcheck" | "hlint" | "terraform" | "tflint" | "generic";
+/** Captured checker process output passed to a format parser. */
+export interface CleanseParserInput {
+    checker: string;
+    projectCwd: string;
+    checkerCwd: string;
+    stdout: string;
+    stderr: string;
+}
+/** Parse one checker invocation into normalized, project-relative diagnostics. */
+export declare function parseCleanseDiagnostics(kind: CleanseParserKind, input: CleanseParserInput): CleanseDiagnostic[];

package/dist/types/cleanse/progress.d.ts

@@ -0,0 +1,14 @@
+/** Minimal output contract used by the interactive cleanse progress reporter. */
+export interface CleanseProgressOutput {
+    isTTY?: boolean;
+    write(text: string): boolean;
+}
+/** Renders completed repair workers on one transient terminal line. */
+export interface CleanseProgressReporter {
+    readonly interactive: boolean;
+    start(total: number): void;
+    complete(): void;
+    finish(): void;
+}
+/** Create the TTY-only worker completion reporter used by `omp cleanse`. */
+export declare function createCleanseProgressReporter(output?: CleanseProgressOutput): CleanseProgressReporter;

package/dist/types/cleanse/types.d.ts

@@ -0,0 +1,64 @@
+/** Severity normalized across checker-specific output formats. */
+export type CleanseSeverity = "error" | "warning" | "info";
+/** One actionable problem reported by a project checker. */
+export interface CleanseDiagnostic {
+    checker: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    code?: string;
+    severity: CleanseSeverity;
+    message: string;
+    suggestion?: string;
+}
+/** Result metadata for one checker invocation. */
+export interface CleanseCheckResult {
+    id: string;
+    label: string;
+    language: string;
+    cwd: string;
+    command: string;
+    exitCode: number | null;
+    diagnostics: CleanseDiagnostic[];
+}
+/** Checker discovery result omitted because its required executable was unavailable. */
+export interface SkippedCleanseCheck {
+    label: string;
+    language: string;
+    reason: string;
+}
+/** Aggregate diagnostics from every checker selected for a project. */
+export interface CleanseDiagnosticReport {
+    checks: CleanseCheckResult[];
+    diagnostics: CleanseDiagnostic[];
+    skipped: SkippedCleanseCheck[];
+}
+/** All diagnostics attached to one file, which scheduling never splits across agents. */
+export interface CleanseFileIssues {
+    file?: string;
+    diagnostics: CleanseDiagnostic[];
+    weight: number;
+}
+/** One weighted, file-disjoint workload handed to a subagent. */
+export interface CleanseAssignment {
+    index: number;
+    groups: CleanseFileIssues[];
+    weight: number;
+}
+/** Settled result from one cleanse subagent. */
+export interface CleanseAgentOutcome {
+    name: string;
+    success: boolean;
+    output: string;
+    error?: string;
+    resolvedModel?: string;
+}
+/** Final state after one bounded repair wave and verification pass. */
+export interface CleanseLoopResult {
+    status: "clean" | "stalled" | "cancelled";
+    waves: number;
+    report: CleanseDiagnosticReport;
+    outcomes: CleanseAgentOutcome[];
+}

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

@@ -0,0 +1,23 @@
+import { Command } from "@oh-my-pi/pi-utils/cli";
+export default class Cleanse extends Command {
+    static description: string;
+    static flags: {
+        agents: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"integer"> & {
+            char: string;
+            description: string;
+            default: number;
+        };
+        model: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+            default: string;
+        };
+        tests: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

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

@@ -3941,11 +3941,26 @@ export declare const SETTINGS_SCHEMA: {
     readonly "inspect_image.enabled": {
         readonly type: "boolean";
         readonly default: false;
+    };
+    readonly "inspect_image.mode": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "on", "off"];
+        readonly default: "auto";
         readonly ui: {
             readonly tab: "tools";
             readonly group: "Available Tools";
             readonly label: "Inspect Image";
-            readonly description: "Enable the inspect_image tool, delegating image understanding to a vision-capable model";
+            readonly description: "Controls the inspect_image tool, which delegates image understanding to a vision-capable model. 'auto' exposes it only when the active model lacks native image input; 'on' always exposes it; 'off' never does.";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto (only for models without vision)";
+            }, {
+                readonly value: "on";
+                readonly label: "On";
+            }, {
+                readonly value: "off";
+                readonly label: "Off";
+            }];
         };
     };
     readonly "computer.enabled": {

package/dist/types/cursor.d.ts

@@ -5,7 +5,8 @@ interface CursorExecBridgeOptions {
     cwd: string;
     getCwd?: () => string;
     tools: Map<string, AgentTool>;
-    getTool?: (name: string) => AgentTool | undefined;
+    /** Resolves execution overrides (mounted-device permission wrappers) before the canonical map. */
+    getExecutableTool?: (name: string) => AgentTool | undefined;
     getToolContext?: () => AgentToolContext | undefined;
     emitEvent?: (event: AgentEvent) => void;
     /**

package/dist/types/export/html/index.d.ts

@@ -3,6 +3,8 @@ import type { SessionEntry, SessionHeader } from "../../session/session-entries.
 import { SessionManager } from "../../session/session-manager.js";
 import type { ExportThemeNames } from "./args.js";
 export { type ExportThemeNames, parseExportArgs } from "./args.js";
+/** Resolve a Bun file-loader value without parsing Windows drive letters as URL schemes. */
+export declare function resolveBundledHtmlAssetPath(assetPath: string, moduleDir?: string): string;
 /** Compose the standalone export template: minified CSS, tool renderers, and viewer JS inlined. */
 export declare function getTemplate(): string;
 export interface ExportOptions {

package/dist/types/extensibility/extensions/runner.d.ts

@@ -69,6 +69,10 @@ export declare class ExtensionRunner {
     private readonly modelRegistry;
     private readonly settings?;
     private readonly localProtocolOptions?;
+    /** Records that the loop already emitted `tool_call` for this dispatch. */
+    markToolCallEmitted(toolCallId: string, toolName: string): void;
+    /** Consumes a {@link markToolCallEmitted} marker; true when the loop already emitted. */
+    consumeToolCallEmitted(toolCallId: string, toolName: string): boolean;
     constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined);
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**

package/dist/types/extensibility/legacy-pi-ai-shim.d.ts

@@ -19,7 +19,7 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { calculateCost, getBundledModel, getBundledModels, getBundledProviders, modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { type TSchema, Type } from "./typebox.js";
@@ -32,6 +32,15 @@ export interface StringEnumOptions<T extends string> {
 export declare function StringEnum<T extends string | number>(values: readonly T[] | Record<string, T>, options?: StringEnumOptions<any>): TSchema;
 /** Clamp a historical Pi thinking level against OMP's model metadata. */
 export declare function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: Effort | "off"): Effort | "off";
+/**
+ * Compatibility implementation of historical pi-ai's `isRetryableAssistantError`.
+ *
+ * Classifies whether a failed assistant message looks like a transient provider
+ * or transport error so legacy extensions can decide if the last assistant turn
+ * should be restarted. Account/quota limits are treated as non-retryable. This
+ * does not implement any retry policy; callers own budget, backoff, and reporting.
+ */
+export declare function isRetryableAssistantError(message: AssistantMessage): boolean;
 export * from "@oh-my-pi/pi-ai";
 /**
  * Compatibility re-exports for catalog symbols that pi-ai historically exposed
@@ -45,3 +54,20 @@ export * from "@oh-my-pi/pi-ai";
 export { calculateCost, getBundledModel, getBundledModels, getBundledProviders, modelsAreEqual, Type };
 export declare const getModel: typeof getBundledModel;
 export declare const getModels: typeof getBundledModels;
+/**
+ * Compatibility re-exports for runtime helpers that upstream
+ * `@earendil-works/pi-ai` exposed from its package root but omp's
+ * `@oh-my-pi/pi-ai` barrel no longer forwards. Each symbol still exists in the
+ * host graph — only its root re-export was dropped — so bridging it here keeps
+ * legacy extensions importing it from the pi-ai root resolving through Bun's
+ * static named-export check (e.g. `omp plugin install pi-blackhole`).
+ *
+ * This is the full set derived from an audit of the upstream root surface: the
+ * error-classification predicate `isContextOverflow` (now under
+ * `@oh-my-pi/pi-ai/error`) and the JSON-repair helpers that omp relocated to
+ * `@oh-my-pi/pi-utils`. Upstream root symbols with no omp equivalent are
+ * intentionally not shimmed — the package has diverged and there is nothing to
+ * forward.
+ */
+export { isContextOverflow } from "@oh-my-pi/pi-ai/error";
+export { parseJsonWithRepair, parseStreamingJson, repairJson } from "@oh-my-pi/pi-utils";

package/dist/types/extensibility/shared-events.d.ts

@@ -228,13 +228,30 @@ export interface TodoReminderEvent {
 }
 /**
  * Return type for `tool_call` handlers.
- * Allows handlers to block tool execution.
+ * Allows handlers to block tool execution or revise the input the tool runs with.
  */
 export interface ToolCallEventResult {
     /** If true, block the tool from executing */
     block?: boolean;
     /** Reason for blocking (returned to LLM as error) */
     reason?: string;
+    /**
+     * Replacement input the tool executes with, instead of the original arguments. Ignored when
+     * `block` is true. This is the raw execution input passed to the tool's `execute` (the handler
+     * owns its correctness) — not the normalized `event.input` view, which may carry derived
+     * gate-only fields (e.g. hashline `edit` `path`/`paths`) that are not real parameters. When
+     * multiple handlers set `input`, the last one wins; handlers do not observe each other's
+     * revisions (each sees the original `event.input`). Not applied to `computer` tool calls.
+     *
+     * For model-issued tool calls the event fires at arg-prep time in the agent loop, before
+     * concurrency scheduling, `tool_execution_start`, and the approval gate: the revision is
+     * revalidated against the tool schema and becomes what the loop schedules, displays, persists,
+     * and executes — the user always approves what actually runs. For dispatches the loop never
+     * sees (nested `write xd://` device calls, Cursor direct execution) the tool wrapper applies
+     * the revision before its own approval gate; a revised nested xd:// input forfeits the outer
+     * write gate's approval and faces the full prompt again.
+     */
+    input?: Record<string, unknown>;
 }
 /**
  * Return type for `tool_result` handlers.

package/dist/types/modes/components/custom-editor.d.ts

@@ -103,6 +103,11 @@ export declare class CustomEditor extends Editor {
      *  reset the editor text and all pending draft-image state. The shared tail of
      *  every "message submitted" path; pass no argument for a plain discard. */
     clearDraft(historyText?: string): void;
+    /** Replace the composer draft with a restored historical prompt: sets the text and
+     *  re-attaches the message's images so positional `[Image #N]` markers resolve on
+     *  resubmit instead of degrading to literal text (esc-esc branch, `/tree`). Source
+     *  links are unknown for restored drafts, so every link slot is `undefined`. */
+    setDraft(text: string, images?: readonly ImageContent[]): void;
     /** Treat image/paste markers as indivisible: a stray backspace deletes the whole token
      *  instead of corrupting `[Paste #1, +30 lines]` into plain text. */
     atomicTokenPattern: RegExp;

package/dist/types/modes/interactive-mode.d.ts

@@ -257,9 +257,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     /**
      * `/vibe` toggle. Entering installs the ephemeral vibe tools, strips the
-     * active toolset down to `read` plus those tools, and injects the director
-     * context. Exiting unregisters them, restores the previous toolset, and kills
-     * every worker session so workers cannot outlive the mode that directs them.
+     * active toolset down to `read`, optional parent-owned `todo`, plus those
+     * tools, and injects the director context. Exiting unregisters them, restores
+     * the previous toolset, and kills every worker session so workers cannot
+     * outlive the mode that directs them.
      */
     handleVibeModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;

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

@@ -15,7 +15,7 @@ import type { Skill, SkillWarning } from "../extensibility/skills.js";
 import type { FileSlashCommand } from "../extensibility/slash-commands.js";
 import type { SecretObfuscator } from "../secrets/obfuscator.js";
 import type { ConfiguredThinkingLevel } from "../thinking.js";
-import type { XdevRegistry } from "../tools/xdev.js";
+import type { XdevState } from "../tools/xdev.js";
 import type { SessionManager } from "./session-manager.js";
 /** Maximum time the interactive shutdown path waits for Mnemopi consolidation. */
 export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1500;
@@ -121,6 +121,8 @@ export interface AgentSessionConfig {
     createMemoryTools?: () => Promise<AgentTool[]>;
     /** Creates the built-in `computer` tool for session-scoped runtime enablement (see {@link AgentSession.setComputerToolEnabled}). */
     createComputerTool?: () => Promise<AgentTool | null>;
+    /** Creates the built-in `inspect_image` tool for session-scoped runtime enablement (see {@link AgentSession.setInspectImageMode}). */
+    createInspectImageTool?: () => Promise<AgentTool | null>;
     /** Model registry for API key resolution and model discovery. */
     modelRegistry: ModelRegistry;
     /** Tool registry for LSP and settings. */
@@ -164,10 +166,8 @@ export interface AgentSessionConfig {
         name: string;
         summary: string;
     }>;
-    /** Session-owned `xd://` registry. */
-    xdevRegistry?: XdevRegistry;
-    /** Discoverable tools mounted under `xd://` in the initial enabled set. */
-    initialMountedXdevToolNames?: string[];
+    /** `xd://` presentation state backed by the canonical tool map. */
+    xdev?: XdevState;
     /** Names pinned top-level during runtime repartitioning. */
     presentationPinnedToolNames?: ReadonlySet<string>;
     /** Accessor for live MCP server instructions. */

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

@@ -46,6 +46,7 @@ import { type AskToolDetails, type AskToolInput } from "../tools/ask.js";
 import type { CheckpointState, CompletedRewindState } from "../tools/checkpoint.js";
 import { type PlanProposalHandler } from "../tools/resolve.js";
 import type { TodoPhase } from "../tools/todo.js";
+import type { InspectImageMode } from "../utils/inspect-image-mode.js";
 import type { VibeModeState } from "../vibe/state.js";
 import type { AgentSessionEventListener } from "./agent-session-events.js";
 import type { AgentSessionConfig, AgentSessionDisposeOptions, AsyncJobSnapshot, CommandMetadataChangedListener, ContextUsageBreakdown, FollowUpOptions, FreshSessionResult, HandoffResult, ModelCycleResult, Prewalk, PromptOptions, ResolvedRoleModel, RestoredQueuedMessage, RoleModelCycle, RoleModelCycleResult, SessionHandoffOptions, SessionOAuthAccountList, SessionStats, UsageFallbackConfirmation } from "./agent-session-types.js";
@@ -283,6 +284,26 @@ export declare class AgentSession {
      * tool (e.g. restricted child sessions have no factory).
      */
     setComputerToolEnabled(enabled: boolean): Promise<boolean>;
+    /**
+     * Session-scoped inspect_image mode (`/vision`). `auto` clears the override
+     * and returns to the persisted `inspect_image.mode` setting; `on`/`off`
+     * force the tool for this session only. See {@link SessionTools.setInspectImageMode}.
+     */
+    setInspectImageMode(mode: InspectImageMode): Promise<boolean>;
+    /** Effective inspect_image state for `/vision status`. */
+    inspectImageState(): {
+        mode: InspectImageMode;
+        active: boolean;
+        model: string | undefined;
+    };
+    /** Session-scoped `/vision` override; undefined means "follow the persisted setting". */
+    getInspectImageModeOverride(): InspectImageMode | undefined;
+    /**
+     * Reconciles the inspect_image tool set after the persisted
+     * `inspect_image.mode` setting changed (e.g. via the settings selector), so
+     * the new value takes effect immediately instead of on the next model switch.
+     */
+    applyInspectImageModeChange(): Promise<boolean>;
     /** Cancels the local rollout-memory startup owned by this session. */
     cancelLocalMemoryStartup(): void;
     /** Starts a new local rollout-memory generation and cancels its predecessor. */
@@ -766,10 +787,12 @@ export declare class AgentSession {
      * @param entryId ID of the entry to branch from
      * @returns Object with:
      *   - selectedText: The text of the selected user message (for editor pre-fill)
+     *   - selectedImages: Image attachments of the selected user message (for editor draft restore)
      *   - cancelled: True if a hook cancelled the branch
      */
     branch(entryId: string): Promise<{
         selectedText: string;
+        selectedImages: ImageContent[];
         cancelled: boolean;
     }>;
     branchFromBtw(question: string, assistantMessage: AssistantMessage): Promise<{
@@ -783,7 +806,7 @@ export declare class AgentSession {
      * @param targetId The entry ID to navigate to
      * @param options.summarize Whether user wants to summarize abandoned branch
      * @param options.customInstructions Custom instructions for summarizer
-     * @returns Result with editorText (if user message) and cancelled status
+     * @returns Result with editorText/editorImages (if user message) and cancelled status
      */
     navigateTree(targetId: string, options?: {
         summarize?: boolean;
@@ -810,6 +833,8 @@ export declare class AgentSession {
         reanswerAskResult?: AgentToolResult<AskToolDetails>;
     }): Promise<{
         editorText?: string;
+        /** Image attachments of the target user message, parallel to the positional `[Image #N]` markers in {@link editorText}. */
+        editorImages?: ImageContent[];
         cancelled: boolean;
         aborted?: boolean;
         summaryEntry?: BranchSummaryEntry;

package/dist/types/session/async-job-delivery.d.ts

@@ -14,6 +14,14 @@ export interface AsyncResultEntry {
     result: string;
     job: AsyncJob | undefined;
     durationMs: number | undefined;
+    /**
+     * Owning session's async-delivery generation at enqueue time. A session
+     * transition (`/new`, switch, handoff) bumps the generation, so an entry
+     * whose generation no longer matches belongs to a replaced transcript and
+     * is dropped at flush — even after its job id has been reused, which clears
+     * the manager's per-id suppression marker.
+     */
+    epoch: number;
 }
 type AsyncResultJobDetails = {
     jobId: string;

package/dist/types/session/model-controls.d.ts

@@ -21,7 +21,7 @@ export interface ModelControlsHost {
     promptGeneration(): number;
     resolveActiveEditMode(): EditMode;
     syncAfterModelChange(previousEditMode: EditMode): Promise<void>;
-    setModelWithProviderSessionReset(model: Model): void;
+    setModelWithProviderSessionReset(model: Model): Promise<void>;
     clearActiveRetryFallback(): void;
     clearInheritedProviderPromptCacheKey(): void;
     magicKeywordEnabled(keyword: "orchestrate" | "ultrathink" | "workflow"): boolean;
@@ -134,9 +134,9 @@ export declare class ModelControls {
     cycleThinkingLevel(): ConfiguredThinkingLevel | undefined;
     /**
      * Classify the current user turn and set the effective thinking level for it.
-     * Bounded by a timeout + abort; on any failure (no smol model, timeout, parse
-     * error) it falls back to the provisional concrete level and continues. Never
-     * throws into the turn, and never clears `#autoThinking` (auto stays active).
+     * Bounded by a timeout + abort; on failure it preserves the last classified
+     * level, or uses the provisional concrete level before the first resolution.
+     * Never throws into the turn, and never clears `#autoThinking`.
      */
     applyAutoThinkingLevel(promptText: string, generation: number): Promise<void>;
     /**