@oh-my-pi/pi-coding-agent 17.0.1 → 17.0.2

package/dist/types/modes/controllers/selector-controller.d.ts

@@ -50,7 +50,9 @@ export declare class SelectorController {
     showCopySelector(): void;
     showTreeSelector(): void;
     showSessionSelector(): Promise<void>;
-    handleResumeSession(sessionPath: string): Promise<void>;
+    handleResumeSession(sessionPath: string, options?: {
+        settingsFlushed?: boolean;
+    }): Promise<boolean>;
     handleSessionDeleteCommand(): Promise<void>;
     showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void>;
     showResetUsageSelector(): Promise<void>;

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

@@ -1,5 +1,5 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session.js";
+import { type AgentSession, type AgentSessionEvent } from "../session/agent-session.js";
 /**
  * Options for print mode.
  */

package/dist/types/modes/warp-events.d.ts

@@ -0,0 +1,24 @@
+import type { ExtensionFactory } from "../extensibility/extensions/types.js";
+/** True when Warp has negotiated the structured CLI-agent OSC protocol. */
+export declare function isWarpCliAgentProtocolActive(): boolean;
+export type WarpEventValue = string | number | boolean | null | readonly WarpEventValue[] | {
+    readonly [key: string]: WarpEventValue | undefined;
+};
+/** Fields added to the Warp CLI-agent event envelope by the event bridge. */
+export type WarpEvent = Readonly<Record<string, WarpEventValue | undefined>>;
+export interface WarpEventEmitterOptions {
+    sessionId: string;
+    getCwd?: () => string;
+}
+export interface WarpEventEmitter {
+    emit(event: WarpEvent): void;
+}
+/**
+ * Creates the Warp event transport for a top-level interactive TUI session.
+ * The caller MUST enforce that install-site invariant; the sole production
+ * caller is gated by `isInteractive`, so ACP, RPC, print, headless, and
+ * subagent sessions never construct an emitter.
+ */
+export declare function createWarpEventEmitter(options: WarpEventEmitterOptions): WarpEventEmitter | undefined;
+/** Internal event bridge installed only by the top-level interactive TUI runner. */
+export declare function createWarpEventBridgeExtension(): ExtensionFactory;

package/dist/types/modes/warp-events.test.d.ts

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

package/dist/types/plan-mode/model-transition.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Plan-mode model transition policy.
+ *
+ * Plan mode drives the active session model from the `plan` role: it switches
+ * to the plan model on entry and restores the pre-plan model on exit. The same
+ * policy also runs when the `plan` role is reassigned mid-planning, so a
+ * correction to the wrong plan model takes effect at the next turn boundary
+ * (issue #5657).
+ *
+ * This module holds only the pure decision — what transition a given
+ * (current model, resolved role, streaming) triple implies — so the branching
+ * is testable without a live session or TUI. The interactive mode performs the
+ * resulting side effect.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ResolvedModelRoleValue } from "../config/model-resolver.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
+/** The action implied by resolving the `plan` role against the active model. */
+export type PlanModelTransition = 
+/** Already on the plan model with no thinking-level change to apply. */
+{
+    kind: "none";
+}
+/** Same model; only the plan role's explicit thinking level differs. */
+ | {
+    kind: "thinking";
+    thinkingLevel: ConfiguredThinkingLevel;
+}
+/**
+ * Switch to `model`. `deferred` is set when the session is mid-stream: the
+ * switch must wait for the current turn to end (a live `setModelTemporary`
+ * resets the provider session), so the caller queues it instead.
+ */
+ | {
+    kind: "apply";
+    model: Model;
+    thinkingLevel: ConfiguredThinkingLevel | undefined;
+    deferred: boolean;
+};
+/**
+ * Decide how to reconcile the active model with the resolved `plan` role.
+ *
+ * @param currentModel - The session's active model, or `undefined` before one is set.
+ * @param resolved - The `plan` role resolved against the available models.
+ * @param isStreaming - Whether the session is mid-turn (forces a deferred switch).
+ */
+export declare function resolvePlanModelTransition(currentModel: Model | undefined, resolved: ResolvedModelRoleValue, isStreaming: boolean): PlanModelTransition;

package/dist/types/plan-mode/model-transition.test.d.ts

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

package/dist/types/registry/agent-lifecycle.d.ts

@@ -8,6 +8,12 @@
  * sessionFile), and revives it on demand through
  * {@link AgentLifecycleManager.ensureLive}. Only this manager flips
  * `parked` ↔ `idle`.
+ *
+ * Park/dispose is gated against concurrent ensureLive/hub-send:
+ * - A disposing session is never handed out.
+ * - ensureLive during an in-flight park either cancels the park (session still
+ *   live) or waits for detach+park and then revives.
+ * - Concurrent ensureLive/park operations coalesce per id.
  */
 import type { AgentSession } from "../session/agent-session.js";
 import { type AgentRef, AgentRegistry } from "./agent-registry.js";
@@ -46,17 +52,36 @@ export declare class AgentLifecycleManager {
     adopt(id: string, opts: AdoptOptions): void;
     /** True if the id is adopted (parked or live). */
     has(id: string): boolean;
-    /** True while {@link park} is disposing this agent's session (lets dispose hooks distinguish park from teardown). */
+    /**
+     * True when this manager owns `registry` — i.e. its adopt/park/revive state
+     * describes that registry's refs. Lets a caller holding a specific registry
+     * (e.g. a custom-registry {@link IrcBus} that fell back to the global
+     * manager) skip lifecycle gating that would consult unrelated park state.
+     */
+    manages(registry: AgentRegistry): boolean;
+    /**
+     * True while {@link park} is disposing this agent's session (lets dispose
+     * hooks distinguish park from teardown). False once the park is cancelled
+     * by ensureLive or after detach+dispose completes.
+     */
     isParking(id: string): boolean;
     /**
      * Dispose the live session, detach it from the registry, and mark the
      * agent `parked`. No-op unless the id is adopted and live.
+     *
+     * The session is detached (and status flipped to `parked`) *before*
+     * `session.dispose()` so concurrent {@link ensureLive}/hub-send never
+     * observe or inject into a disposing session. A concurrent ensureLive that
+     * arrives before detach cancels the park and keeps the live session.
      */
     park(id: string): Promise<void>;
     /**
      * Return the live session, reviving from the sessionFile if parked.
      * Throws a plain Error if the id is unknown or parked without a reviver.
      * Concurrent calls share one in-flight revive.
+     *
+     * Never returns a session that is mid-dispose: an in-flight park is either
+     * cancelled (session still live) or awaited to completion before revive.
      */
     ensureLive(id: string): Promise<AgentSession>;
     /** Hard removal: dispose if live, unregister from registry, drop timers. */

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
-import { type AgentTelemetryConfig, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Model } from "@oh-my-pi/pi-ai";
+import { Agent, type AgentOptions, type AgentTelemetryConfig, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule.js";
 import { ModelRegistry } from "./config/model-registry.js";
@@ -346,6 +346,17 @@ export interface BuildSystemPromptOptions {
  * as separate entries so providers can cache prompt prefixes without concatenating blocks.
  */
 export declare function buildSystemPrompt(options?: BuildSystemPromptOptions): Promise<BuildSystemPromptResult>;
+/** Dependencies used to construct an isolated auto-learn capture agent. */
+export interface AutoLearnCaptureRunnerOptions {
+    sourceAgent: Agent;
+    captureTools: AgentTool[];
+    createAgent: (options: AgentOptions) => Agent;
+    onPayload?: SimpleStreamOptions["onPayload"];
+    onResponse?: SimpleStreamOptions["onResponse"];
+    createSessionId?: () => string;
+}
+/** Build a private capture runner over a detached message snapshot and provider session. */
+export declare function createAutoLearnCaptureRunner(options: AutoLearnCaptureRunnerOptions): (content: string, signal?: AbortSignal) => Promise<void>;
 /**
  * Create an AgentSession with the specified options.
  *

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

@@ -18,7 +18,7 @@ import { type CompactionResult, type ShakeConfig } from "@oh-my-pi/pi-agent-core
 import type { AssistantMessage, Context, ImageContent, Message, MessageAttribution, Model, ProviderSessionState, ResetCreditAccountStatus, ResetCreditRedeemOutcome, ResetCreditTarget, ServiceTier, ServiceTierByFamily, ServiceTierFamily, SimpleStreamOptions, TextContent, ToolChoice, UsageReport } from "@oh-my-pi/pi-ai";
 import { Effort } from "@oh-my-pi/pi-ai";
 import { postmortem } from "@oh-my-pi/pi-utils";
-import { type AdvisorConfig } from "../advisor/index.js";
+import { type AdvisorConfig, type AdvisorRuntimeStatus } from "../advisor/index.js";
 import { type AsyncJob, type AsyncJobDeliveryState, AsyncJobManager } from "../async/index.js";
 import type { Rule } from "../capability/rule.js";
 import type { ModelRegistry } from "../config/model-registry.js";
@@ -224,6 +224,8 @@ export interface AgentSessionConfig {
     builtInToolNames?: Iterable<string>;
     /** Update tool-session predicates that render guidance from the live active tool set. */
     setActiveToolNames?: (names: Iterable<string>) => void;
+    /** Register the write transport lazily when runtime xdev mounts first need it. */
+    ensureWriteRegistered?: () => Promise<boolean>;
     /** Current session pre-LLM message transform pipeline */
     transformContext?: (messages: AgentMessage[], signal?: AbortSignal) => AgentMessage[] | Promise<AgentMessage[]>;
     /**
@@ -275,7 +277,8 @@ export interface AgentSessionConfig {
     xdevRegistry?: XdevRegistry;
     /** Discoverable tools mounted under `xd://` in the initial enabled set (startup partition in `sdk.ts`). */
     initialMountedXdevToolNames?: string[];
-    requestedToolNames?: ReadonlySet<string>;
+    /** Explicit/effective names pinned top-level during runtime repartitioning. */
+    presentationPinnedToolNames?: ReadonlySet<string>;
     /**
      * Optional accessor for live MCP server instructions. Read by the session's
      * `rebuildSystemPrompt`-skip optimization to detect server-side instruction
@@ -491,15 +494,20 @@ export interface AdvisorStats {
     /** Per-advisor breakdown; one entry per active advisor (single-advisor sessions have one). */
     advisors: PerAdvisorStat[];
 }
-/** One advisor's slice of {@link AdvisorStats}, surfaced for the multi-advisor status panel. */
+/** One advisor's slice of {@link AdvisorStats}. Active advisors carry full
+ *  token/cost data; disabled/no-model/quota-exhausted advisors appear with
+ *  just `name` + `status` so the status line can render a dot for every
+ *  configured advisor. */
 export interface PerAdvisorStat {
     name: string;
-    model: Model;
+    status: AdvisorRuntimeStatus;
+    model?: Model;
     contextWindow: number;
     contextTokens: number;
     tokens: AdvisorStats["tokens"];
     cost: number;
     messages: AdvisorStats["messages"];
+    sessionId?: string;
 }
 export interface FreshSessionResult {
     previousSessionId: string;
@@ -612,6 +620,8 @@ export declare class AgentSession {
      */
     subscribe(listener: AgentSessionEventListener): () => void;
     subscribeCommandMetadataChanged(listener: CommandMetadataChangedListener): () => void;
+    /** Run one abortable auto-learn capture outside the primary agent loop. */
+    runAutolearnCapture(capture: (signal: AbortSignal) => Promise<void>): Promise<void>;
     /** True once dispose() has begun; deferred background work (e.g. the deferred
      *  MCP discovery task in sdk.ts) must not touch the session past this point. */
     get isDisposed(): boolean;
@@ -915,6 +925,12 @@ export declare class AgentSession {
     get skillWarnings(): readonly SkillWarning[];
     getTodoPhases(): TodoPhase[];
     setTodoPhases(phases: TodoPhase[]): void;
+    /**
+     * Generate an automatic session title tied to this session's lifecycle.
+     * Input and replan callers share the signal so disposal cancels provider and
+     * local-worker requests instead of leaving background inference alive.
+     */
+    generateTitle(firstMessage: string): Promise<string | null>;
     /** Currently-applied {@link TITLE_SYSTEM.md} override, or undefined when the
      *  bundled prompt is in effect. Consumed by {@link InteractiveMode} so the
      *  first-input title path and the replan refresh share one source. */
@@ -1167,8 +1183,7 @@ export declare class AgentSession {
      */
     retry(): Promise<boolean>;
     /**
-     * Execute a bash command.
-     * Adds result to agent context and session.
+     * Execute a bash command and retain the session/branch that owned its start.
      * @param command The bash command to execute
      * @param onChunk Optional streaming callback for output
      * @param options.excludeFromContext If true, command output won't be sent to LLM (!! prefix)
@@ -1178,10 +1193,7 @@ export declare class AgentSession {
         excludeFromContext?: boolean;
         useUserShell?: boolean;
     }): Promise<BashResult>;
-    /**
-     * Record a bash execution result in session history.
-     * Used by executeBash and by extensions that handle bash execution themselves.
-     */
+    /** Record a bash result supplied outside executeBash in the current ownership scope. */
     recordBashResult(command: string, result: BashResult, options?: {
         excludeFromContext?: boolean;
     }): void;
@@ -1471,6 +1483,18 @@ export declare class AgentSession {
      * (`streamFn`, `promptCacheKey`, `providerSessionState`, ...).
      */
     getAdvisorAgent(): Agent | undefined;
+    /**
+     * Lightweight advisor status for the status line: returns just the configured
+     * flag and per-advisor name/status without computing token/cost breakdowns.
+     * Avoids re-tokenizing the advisor transcript on every render frame.
+     */
+    getAdvisorStatusOverview(): {
+        configured: boolean;
+        advisors: {
+            name: string;
+            status: AdvisorRuntimeStatus;
+        }[];
+    };
     /**
      * Return structured advisor stats for the status command and TUI panel.
      */

package/dist/types/session/session-history-format.d.ts

@@ -1,3 +1,4 @@
+import type { ToolResultMessage } from "@oh-my-pi/pi-ai";
 export interface HistoryFormatOptions {
     /** Optional H1 prepended to the transcript. */
     title?: string;
@@ -24,6 +25,15 @@ export interface HistoryFormatOptions {
      * this so it sees what changed without re-reading the file.
      */
     expandEditDiffs?: boolean;
+    /**
+     * Chunked rendering support: a caller formatting one logical transcript in
+     * several calls (the advisor's chunked delta render) passes a result index
+     * built over the WHOLE delta plus one shared consumed-id set, so a toolCall
+     * finds its toolResult across chunk boundaries and the result is never
+     * re-rendered as an orphan in a later chunk.
+     */
+    toolResultIndex?: ReadonlyMap<string, ToolResultMessage>;
+    consumedToolCallIds?: Set<string>;
 }
 /**
  * Hidden custom messages that inject the primary agent's operative *constraints*

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

@@ -48,6 +48,15 @@ export declare class SessionManager {
     /** Synchronous variant of {@link putBlob} for rebuild-only render paths. */
     putBlobSync(data: Buffer, options?: BlobPutOptions): BlobPutResult;
     captureState(): SessionManagerStateSnapshot;
+    /**
+     * Create an independent manager for the current logical session and branch.
+     * The clone shares the storage backend but owns its entry index and writer, so
+     * callers can finish session-owned work after this manager switches elsewhere.
+     * Set `persist` false when the original session is intentionally being dropped.
+     */
+    cloneCurrentSession(options?: {
+        persist?: boolean;
+    }): SessionManager;
     restoreState(snapshot: SessionManagerStateSnapshot): void;
     /** Switch to a different session file (resume / branch). */
     setSessionFile(sessionFile: string): Promise<void>;
@@ -140,6 +149,11 @@ export declare class SessionManager {
      * top-level entries via appendCompaction()/branchWithSummary().
      */
     appendMessage(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage): string;
+    /**
+     * Append to a non-active branch without changing the current leaf.
+     * Used by work that retains ownership of a branch across tree navigation.
+     */
+    appendMessageToBranch(message: Message | CustomMessage | HookMessage | BashExecutionMessage | PythonExecutionMessage | FileMentionMessage, parentId: string | null): string;
     /** Append a thinking level change as child of current leaf, then advance leaf. Returns entry id. */
     appendThinkingLevelChange(thinkingLevel?: string, configured?: string): string;
     appendServiceTierChange(serviceTier: ServiceTierByFamily | null): string;

package/dist/types/slash-commands/helpers/active-oauth-account.d.ts

@@ -1,5 +1,14 @@
 import type { UsageLimit, UsageReport } from "@oh-my-pi/pi-ai";
 import type { OAuthAccountIdentity } from "../../session/auth-storage.js";
+/**
+ * Session marker label for an active OAuth identity: the base identifier
+ * (email → accountId → projectId) suffixed with the organization when present
+ * and distinct. Same-email Anthropic multi-org accounts share the base, so the
+ * org suffix is the only field that tells the session's quota pool apart —
+ * mirrors the account-list rows (`formatUsageReportAccount`) and login success.
+ * Returns `undefined` when no identifier is recoverable.
+ */
+export declare function formatActiveAccountLabel(identity: OAuthAccountIdentity | undefined): string | undefined;
 /**
  * True when a single usage-limit column belongs to the given OAuth identity.
  *

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

@@ -1,4 +1,4 @@
 import type { ModelRegistry } from "../config/model-registry.js";
 import type { Settings } from "../config/settings.js";
 /** Compresses a delegated assignment into a one-sentence UI label via the tiny title model — fired by the executor spawn path because the task wire schema no longer carries a `description`; null on empty input or failure. */
-export declare function generateTaskLabel(assignment: string, registry: ModelRegistry, settings: Settings, sessionId?: string): Promise<string | null>;
+export declare function generateTaskLabel(assignment: string, registry: ModelRegistry, settings: Settings, sessionId?: string, signal?: AbortSignal): Promise<string | null>;

package/dist/types/telemetry-export.d.ts

@@ -1,19 +1,44 @@
 /**
- * Whether {@link initTelemetryExport} registered a real provider. The CLI uses
- * this to decide whether to switch on the agent loop's telemetry config — there
- * is no point emitting spans into a no-op tracer.
+ * OTLP telemetry export bootstrap.
+ *
+ * oh-my-pi's agent core (`@oh-my-pi/pi-agent-core`) emits OpenTelemetry GenAI
+ * spans through the global `@opentelemetry/api` tracer, and exposes run-level
+ * callbacks for metrics/log pipelines. This module registers the OTLP/proto
+ * trace, log, and metric SDK providers when the standard `OTEL_*` endpoint env
+ * vars are set so `omp` can be observed by any OTLP collector without vendor
+ * coupling.
+ *
+ * Only the `http/protobuf` transport is supported — an
+ * `OTEL_EXPORTER_OTLP*_PROTOCOL` of `grpc` or `http/json` declines rather than
+ * misrouting protobuf payloads. The exporter line is pinned to the 0.218/2.7
+ * family validated under Bun; the 1.x OTLP line deadlocks when its
+ * `req.on("close")` handler fires after a successful export.
+ */
+import type { AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
+/**
+ * Whether {@link initTelemetryExport} registered any real OTLP signal provider.
+ * The CLI uses this to decide whether to switch on the agent loop's telemetry
+ * hooks; metrics and structured logs need those callbacks even when traces are
+ * disabled.
  */
 export declare function isTelemetryExportEnabled(): boolean;
 /**
- * Register the global TracerProvider + OTLP exporter when an OTLP endpoint is
- * configured via env. Idempotent, and a no-op when no endpoint is set (or when
- * the OTEL kill-switches are engaged), so it is safe to call unconditionally at
- * startup.
+ * Merge OTLP metrics/log hooks into an existing agent telemetry config.
+ *
+ * The caller still owns content-capture policy, cost estimation, and custom
+ * attributes. This only appends host-level metrics/log forwarding for the
+ * providers registered by {@link initTelemetryExport}.
+ */
+export declare function createTelemetryExportConfig(config: AgentTelemetryConfig | undefined): AgentTelemetryConfig | undefined;
+/**
+ * Register global trace/log/meter providers when OTLP endpoints are configured
+ * through env. Idempotent, and a no-op when no signal has an endpoint (or when
+ * the OTEL kill-switches are engaged), so startup can call it unconditionally.
  */
 export declare function initTelemetryExport(): Promise<void>;
 /**
- * Flush any buffered spans to the exporter. No-op when export is disabled.
+ * Flush buffered spans, log records, and metrics. No-op when export is disabled.
  * Hosts embedding the agent can call this at natural boundaries (e.g. the end
- * of a turn) so traces surface promptly rather than on the batch interval.
+ * of a turn) so telemetry surfaces promptly rather than on the batch interval.
  */
 export declare function flushTelemetryExport(): Promise<void>;

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

@@ -17,6 +17,14 @@ export interface ResolvedApproval {
     reason?: string;
     override: boolean;
 }
+/**
+ * Evaluate a tool's own approval declaration against `args` and return the
+ * resulting capability tier, defaulting to `exec` when the tool omits an
+ * approval. Unlike reading `tool.approval` directly, this runs function-valued
+ * approvals — the write tool's `xd://` gate uses it to take a mounted device's
+ * argument-dependent tier instead of falling back to `exec`.
+ */
+export declare function resolveToolTier(tool: ApprovalSubject, args: unknown): ToolTier;
 /**
  * Resolve approval policy for a tool call.
  *

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

@@ -76,6 +76,8 @@ export interface BashToolDetails {
     wallTimeMs?: number;
     /** Exit code of a command that ran to completion but failed (non-zero). */
     exitCode?: number;
+    /** True when the command was killed by its timeout deadline (not a failure). */
+    timedOut?: boolean;
     terminalId?: string;
     async?: {
         state: "running" | "completed" | "failed";

package/dist/types/tools/essential-tools.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Canonical set of built-in tools that must stay top-level.
+ *
+ * These are the coding essentials the model always needs directly in its
+ * callable schema. `read`/`write` are additionally the `xd://` transport
+ * (`read xd://` lists devices, `write xd://<tool>` executes them), so demoting
+ * them under xdev makes every mounted device unreachable.
+ *
+ * Adapter boundaries (extension `registerTool`, SDK custom tools, RPC host
+ * tools) default an omitted `loadMode` to `"discoverable"`. A UI-only
+ * re-register of a built-in — e.g. wrapping `read`/`write`/`bash`/`edit`/`glob`
+ * to customize rendering — would then silently demote it to `discoverable` and,
+ * with `tools.xdev` on, unmount it from the top-level schema (issue #5764).
+ * {@link defaultLoadModeForToolName} pins these names to `"essential"` when the
+ * definition omits `loadMode`, so re-registering a built-in never demotes it.
+ */
+import type { ToolLoadMode } from "@oh-my-pi/pi-agent-core";
+/**
+ * Built-in tool names whose classes declare `loadMode = "essential"`. Kept in
+ * sync with the tool classes by `essential-tools.test.ts` (drift guard).
+ */
+export declare const ESSENTIAL_BUILTIN_TOOL_NAMES: Record<string, true>;
+/**
+ * Resolve a tool's presentation mode at an adapter boundary. An explicit
+ * `declared` mode always wins. When omitted, known essential built-in names
+ * default to `"essential"` (so a re-register never demotes them); everything
+ * else defaults to `"discoverable"`.
+ */
+export declare function defaultLoadModeForToolName(name: string, declared?: ToolLoadMode): ToolLoadMode;

package/dist/types/tools/image-gen.d.ts

@@ -2,7 +2,7 @@ import { type Model } from "@oh-my-pi/pi-ai";
 import { type ModelRegistry } from "../config/model-registry.js";
 import type { CustomTool } from "../extensibility/custom-tools/types.js";
 export type ImageProvider = "antigravity" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai";
-export type ImageProviderPreference = Exclude<ImageProvider, "openai-codex"> | "auto";
+export type ImageProviderPreference = ImageProvider | "auto";
 declare const responseModalitySchema: import("arktype/internal/variants/string.ts").StringType<"IMAGE" | "TEXT", {}>;
 export declare const imageGenSchema: import("arktype/internal/variants/object.ts").ObjectType<{
     subject: string;
@@ -20,6 +20,7 @@ export declare const imageGenSchema: import("arktype/internal/variants/object.ts
         data?: string | undefined;
         mime_type?: string | undefined;
     }[] | undefined;
+    provider?: "antigravity" | "auto" | "gemini" | "openai" | "openai-codex" | "openrouter" | "xai" | undefined;
 }, {}>;
 export type ImageGenParams = typeof imageGenSchema.infer;
 export type GeminiResponseModality = typeof responseModalitySchema.infer;

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

@@ -40,6 +40,7 @@ export * from "./bash.js";
 export * from "./browser.js";
 export * from "./checkpoint.js";
 export * from "./debug.js";
+export * from "./essential-tools.js";
 export * from "./eval.js";
 export * from "./eval-backends.js";
 export * from "./gh.js";

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

@@ -37,11 +37,20 @@ import type { ToolRenderer } from "./renderers.js";
  * behind dispatch.
  */
 export declare const XDEV_KEEP_TOP_LEVEL: Record<string, true>;
+/**
+ * Tools that carry the `xd://` transport itself and therefore can never be
+ * mounted as devices: `read xd://` lists/documents devices and
+ * `write xd://<tool>` executes them. Demoting either leaves every mounted
+ * device unreachable (issue #5764), so they stay top-level regardless of a
+ * declared `loadMode`.
+ */
+export declare const XDEV_TRANSPORT_TOOLS: Record<string, true>;
 /**
  * Whether an enabled tool is presented under `xd://` (rather than top-level)
  * while the `xd://` transport is active. Discoverable tools mount unless they
- * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL}; essential tools never do.
- * The caller gates this on the transport being active (a session-owned
+ * are pinned top-level by {@link XDEV_KEEP_TOP_LEVEL} or carry the transport
+ * itself ({@link XDEV_TRANSPORT_TOOLS}); essential tools never do. The caller
+ * gates this on the transport being active (a session-owned
  * {@link XdevRegistry} existing).
  */
 export declare function isMountableUnderXdev(tool: {

package/dist/types/utils/title-generator.d.ts

@@ -14,8 +14,9 @@ import type { Settings } from "../config/settings.js";
  *   resolver instead of a pre-evaluated value ensures the metadata's account_uuid
  *   reflects the credential actually selected for this request.
  * @param customSystemPrompt Optional title-specific system prompt override
+ * @param signal Session-lifecycle cancellation for background title requests
  */
-export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, customSystemPrompt?: string): Promise<string | null>;
+export declare function generateSessionTitle(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, customSystemPrompt?: string, signal?: AbortSignal): Promise<string | null>;
 export declare function generateTitleOnline(firstMessage: string, registry: ModelRegistry, settings: Settings, sessionId?: string, currentModel?: Model<Api>, metadataResolver?: (provider: string) => Record<string, unknown> | undefined, signal?: AbortSignal, customSystemPrompt?: string): Promise<string | null>;
 export declare function formatSessionTerminalTitle(sessionName: string | undefined, cwd?: string): string;
 /**

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

@@ -1,7 +1,10 @@
 /**
  * Kimi Web Search Provider
  *
- * Uses Moonshot Kimi Code search API to retrieve web results.
+ * Uses the Kimi Code search API to retrieve web results. This is the Kimi Code
+ * membership service, distinct from the Moonshot Open Platform — it requires a
+ * Kimi Code Console credential (`omp /login kimi-code` or an explicit
+ * `MOONSHOT_SEARCH_API_KEY` / `KIMI_SEARCH_API_KEY`), not `MOONSHOT_API_KEY`.
  * Endpoint: POST https://api.kimi.com/coding/v1/search
  */
 import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";

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

@@ -62,7 +62,7 @@ export declare const SEARCH_PROVIDER_OPTIONS: readonly [{
 }, {
     readonly value: "kimi";
     readonly label: "Kimi";
-    readonly description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY";
+    readonly description: "Kimi Code search (requires a Kimi Code Console key via KIMI_SEARCH_API_KEY/MOONSHOT_SEARCH_API_KEY or /login kimi-code; not MOONSHOT_API_KEY)";
 }, {
     readonly value: "parallel";
     readonly label: "Parallel";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.0.1",
+	"version": "17.0.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,23 +52,28 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.0.1",
-		"@oh-my-pi/omp-stats": "17.0.1",
-		"@oh-my-pi/pi-agent-core": "17.0.1",
-		"@oh-my-pi/pi-ai": "17.0.1",
-		"@oh-my-pi/pi-catalog": "17.0.1",
-		"@oh-my-pi/pi-mnemopi": "17.0.1",
-		"@oh-my-pi/pi-natives": "17.0.1",
-		"@oh-my-pi/pi-tui": "17.0.1",
-		"@oh-my-pi/pi-utils": "17.0.1",
-		"@oh-my-pi/pi-wire": "17.0.1",
-		"@oh-my-pi/snapcompact": "17.0.1",
+		"@oh-my-pi/hashline": "17.0.2",
+		"@oh-my-pi/omp-stats": "17.0.2",
+		"@oh-my-pi/pi-agent-core": "17.0.2",
+		"@oh-my-pi/pi-ai": "17.0.2",
+		"@oh-my-pi/pi-catalog": "17.0.2",
+		"@oh-my-pi/pi-mnemopi": "17.0.2",
+		"@oh-my-pi/pi-natives": "17.0.2",
+		"@oh-my-pi/pi-tui": "17.0.2",
+		"@oh-my-pi/pi-utils": "17.0.2",
+		"@oh-my-pi/pi-wire": "17.0.2",
+		"@oh-my-pi/snapcompact": "17.0.2",
 		"@opentelemetry/api": "^1.9.1",
-		"@opentelemetry/context-async-hooks": "^2.7.1",
+		"@opentelemetry/api-logs": "^0.220.0",
+		"@opentelemetry/context-async-hooks": "^2.9.0",
+		"@opentelemetry/exporter-logs-otlp-proto": "^0.220.0",
+		"@opentelemetry/exporter-metrics-otlp-proto": "^0.220.0",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.220.0",
-		"@opentelemetry/resources": "^2.7.1",
-		"@opentelemetry/sdk-trace-base": "^2.7.1",
-		"@opentelemetry/sdk-trace-node": "^2.7.1",
+		"@opentelemetry/resources": "^2.9.0",
+		"@opentelemetry/sdk-logs": "^0.220.0",
+		"@opentelemetry/sdk-metrics": "^2.9.0",
+		"@opentelemetry/sdk-trace-base": "^2.9.0",
+		"@opentelemetry/sdk-trace-node": "^2.9.0",
 		"@puppeteer/browsers": "^3.0.6",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",