@oh-my-pi/pi-coding-agent 17.0.9 → 17.1.0

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

@@ -0,0 +1,28 @@
+import type { AsyncJob } from "../async/index.js";
+import type { CustomMessage } from "./messages.js";
+/**
+ * `customType` of the injected async-result follow-up message. The task
+ * executor's run monitor matches on it to invalidate a previously recorded
+ * yield: a result injected after the yield supersedes that yield's payload.
+ */
+export declare const ASYNC_RESULT_MESSAGE_TYPE = "async-result";
+/** Result payloads longer than this spill to an artifact with an inline preview. */
+export declare const ASYNC_INLINE_RESULT_MAX_CHARS = 12000;
+export declare const ASYNC_PREVIEW_MAX_CHARS = 4000;
+export interface AsyncResultEntry {
+    jobId: string;
+    result: string;
+    job: AsyncJob | undefined;
+    durationMs: number | undefined;
+}
+type AsyncResultJobDetails = {
+    jobId: string;
+    type?: "bash" | "task";
+    label?: string;
+    durationMs?: number;
+};
+export type AsyncResultDetails = {
+    jobs: AsyncResultJobDetails[];
+};
+export declare function buildAsyncResultBatchMessage(entries: AsyncResultEntry[]): CustomMessage<AsyncResultDetails> | null;
+export {};

package/dist/types/session/bash-runner.d.ts

@@ -0,0 +1,75 @@
+import type { Agent } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "../config/settings.js";
+import { type BashResult } from "../exec/bash-executor.js";
+import type { ExtensionRunner } from "../extensibility/extensions/index.js";
+import type { SessionManager } from "./session-manager.js";
+/** Destination that owns a bash result after a session or branch transition. */
+export type BashAppendDestination = {
+    kind: "current";
+    manager: SessionManager;
+} | {
+    kind: "detached";
+    manager: SessionManager;
+} | {
+    kind: "branch";
+    manager: SessionManager;
+    parentId: string | null;
+};
+/** Reference-counted session target captured when a bash execution starts. */
+export interface BashSessionTarget {
+    sessionId: string;
+    refs: number;
+    destination?: BashAppendDestination;
+    pending?: Promise<BashAppendDestination>;
+}
+/** Ownership snapshot spanning a session or branch transition. */
+export interface BashSessionTransition {
+    oldTarget: BashSessionTarget;
+    newTarget: BashSessionTarget;
+    oldSessionId: string;
+    oldSessionFile: string | undefined;
+    oldLeafId: string | null;
+    detachedManager: SessionManager | undefined;
+    resolveOld: ((destination: BashAppendDestination) => void) | undefined;
+    resolveNew: (destination: BashAppendDestination) => void;
+}
+/** Capabilities the bash runner borrows from its owning session. */
+export interface BashRunnerHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    extensionRunner(): ExtensionRunner | undefined;
+    isStreaming(): boolean;
+}
+/** Owns bash execution and preserves result ownership across transcript transitions. */
+export declare class BashRunner {
+    #private;
+    constructor(host: BashRunnerHost);
+    /** Executes a bash command while retaining the session and branch that owned its start. */
+    executeBash(command: string, onChunk?: (chunk: string) => void, options?: {
+        excludeFromContext?: boolean;
+        useUserShell?: boolean;
+    }): Promise<BashResult>;
+    /** Records a bash result supplied outside executeBash in the current ownership scope. */
+    recordBashResult(command: string, result: BashResult, options?: {
+        excludeFromContext?: boolean;
+    }): void;
+    /** Cancels every running bash command. */
+    abort(): void;
+    /** Whether a bash command is currently running. */
+    get isRunning(): boolean;
+    /** Whether bash results are waiting for a safe persistence boundary. */
+    get hasPendingMessages(): boolean;
+    /** Flushes deferred bash results without changing their captured ownership. */
+    flushPending(): Promise<void>;
+    /** Runs a leaf rewrite while retaining in-flight bash on its originating branch. */
+    withBranchTransition<T>(mutate: () => T): T;
+    /** Snapshots the owner of in-flight bash before a session or branch transition. */
+    beginSessionTransition(options?: {
+        persistDetached?: boolean;
+    }): BashSessionTransition;
+    /** Adopts a transition's new target as the live bash owner. */
+    markSessionTransition(transition: BashSessionTransition): void;
+    /** Resolves destinations opened by beginSessionTransition. */
+    finishSessionTransition(transition: BashSessionTransition, success: boolean): void;
+}

package/dist/types/session/blob-store.d.ts

@@ -1,3 +1,5 @@
+/** Canonical blob hash shape: exactly 64 lowercase hex chars (a SHA-256 digest). */
+export declare const BLOB_HASH_RE: RegExp;
 export interface BlobPutOptions {
     /** Optional file extension for a sidecar hardlink/copy that OS openers can type-detect. */
     extension?: string;
@@ -34,7 +36,15 @@ export declare class BlobStore {
 }
 /** Check if a data string is a blob reference. */
 export declare function isBlobRef(data: string): boolean;
-/** Extract the SHA-256 hash from a blob reference string. */
+/**
+ * Extract the SHA-256 hash from a blob reference string.
+ *
+ * Returns null when the string is not a blob ref, or when the suffix is not a
+ * canonical 64-char lowercase hex hash. Rejecting non-hash suffixes here is the
+ * single choke point that keeps every resolution path confined to the blob dir:
+ * `get`/`getSync` feed this value into `path.join(this.dir, hash)`, so an
+ * unvalidated `../` suffix would otherwise escape the store and read arbitrary files.
+ */
 export declare function parseBlobRef(data: string): string | null;
 /** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */
 export declare function isImageDataUrl(data: string): boolean;

package/dist/types/session/blob-store.test.d.ts

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

package/dist/types/session/checkpoint-entries.d.ts

@@ -0,0 +1,28 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import type { CompletedRewindState } from "../tools/checkpoint.js";
+import type { SessionEntry } from "./session-entries.js";
+/** Extracts text from custom message content. */
+export declare function customMessageContentText(content: string | (TextContent | ImageContent)[]): string;
+/** Extracts the report body from persisted rewind-report content. */
+export declare function reportFromRewindReportContent(content: string): string;
+/** Checkpoint-domain tool names normalized from native and xdev calls. */
+export type SemanticCheckpointToolName = "checkpoint" | "rewind";
+/** Normalized checkpoint-domain tool result. */
+export interface SemanticToolResult {
+    toolName: SemanticCheckpointToolName;
+    details?: unknown;
+}
+/** Normalizes checkpoint and rewind results across native calls and xdev dispatches. */
+export declare function semanticToolResult(toolName: string | undefined, result: unknown): SemanticToolResult | undefined;
+/** Restores completed rewind state from a persisted session entry. */
+export declare function completedRewindFromEntry(entry: SessionEntry): CompletedRewindState | undefined;
+/** Whether an entry is a successful checkpoint tool result. */
+export declare function isSuccessfulCheckpointEntry(entry: SessionEntry): entry is SessionEntry & {
+    type: "message";
+    message: Extract<AgentMessage, {
+        role: "toolResult";
+    }>;
+};
+/** Returns the checkpoint start timestamp represented by an entry. */
+export declare function checkpointStartedAtFromEntry(entry: SessionEntry): string | undefined;

package/dist/types/session/eval-runner.d.ts

@@ -0,0 +1,49 @@
+import type { Agent } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "../config/settings.js";
+import { type PythonResult } from "../eval/py/executor.js";
+import type { ExtensionRunner } from "../extensibility/extensions/index.js";
+import type { PythonExecutionMessage } from "./messages.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities the eval runner borrows from its owning session. */
+export interface EvalRunnerHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    extensionRunner(): ExtensionRunner | undefined;
+    isStreaming(): boolean;
+    appendSessionMessage(message: PythonExecutionMessage): void;
+}
+/** Owns user-initiated Python execution and retained eval-kernel lifecycle. */
+export declare class EvalRunner {
+    #private;
+    constructor(host: EvalRunnerHost, options: {
+        kernelOwnerId: string;
+        parentSessionId: string | undefined;
+    });
+    /** Executes Python in the session's shared kernel. */
+    executePython(code: string, onChunk?: (chunk: string) => void, options?: {
+        excludeFromContext?: boolean;
+    }): Promise<PythonResult>;
+    /** Rejects new eval work once session disposal begins. */
+    assertExecutionAllowed(): void;
+    /** Tracks externally started Python work so disposal can await and abort it. */
+    trackExecution<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
+    /** Records a Python execution result in session history. */
+    recordPythonResult(code: string, result: PythonResult, options?: {
+        excludeFromContext?: boolean;
+    }): void;
+    /** Cancels every running Python execution. */
+    abort(): void;
+    /** Whether a Python execution is currently running. */
+    get isRunning(): boolean;
+    /** Whether Python results are waiting for a safe persistence boundary. */
+    get hasPendingMessages(): boolean;
+    /** Returns the eval session shared with the Python backend. */
+    getSessionId(): string | null;
+    /** Flushes deferred Python results into agent state and persistence. */
+    flushPending(): void;
+    /** Prevents new Python executions before asynchronous disposal starts. */
+    beginDispose(): void;
+    /** Waits for active work and disposes every retained eval kernel owned by the session. */
+    disposeKernels(): Promise<void>;
+}

package/dist/types/session/irc-bridge.d.ts

@@ -0,0 +1,46 @@
+import type { Agent } from "@oh-my-pi/pi-agent-core";
+import type { Settings } from "../config/settings.js";
+import { type IrcMessage } from "../irc/bus.js";
+import type { AgentSessionEvent } from "./agent-session-events.js";
+import type { CustomMessage } from "./messages.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities the IRC bridge borrows from its owning session. */
+export interface IrcBridgeHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    settings: Settings;
+    isDisposed(): boolean;
+    isStreaming(): boolean;
+    planModeEnabled(): boolean;
+    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    wakeForIrc(records: CustomMessage[]): void;
+    runEphemeralTurn(args: {
+        promptText: string;
+    }): Promise<{
+        replyText: string;
+    }>;
+}
+/** Owns incoming IRC queues, injection, and side-channel auto-replies. */
+export declare class IrcBridge {
+    #private;
+    constructor(host: IrcBridgeHost);
+    /** Whether an incoming peer message can interrupt a wait. */
+    hasInterrupts(): boolean;
+    /** Whether any undelivered IRC record remains queued. */
+    hasPending(): boolean;
+    /** Takes every queued IRC record in interrupt-before-aside order. */
+    drainPending(): CustomMessage[];
+    /** Surfaces and consumes queued incoming records before automatic injection. */
+    drainInboxMessages(agentId: string, opts?: {
+        from?: string;
+        limit?: number;
+    }): IrcMessage[];
+    /** Delivers an IRC message into the recipient session without awaiting any wake turn. */
+    deliver(msg: IrcMessage, opts?: {
+        expectsReply?: boolean;
+    }): Promise<"injected" | "woken">;
+    /** Emits an IRC relay observation for rendering without persisting it. */
+    emitRelayObservation(record: CustomMessage): void;
+    /** Persists queued IRC records that missed their step-boundary injection. */
+    flushPending(): void;
+}

package/dist/types/session/messages.d.ts

@@ -12,6 +12,28 @@ import type { OutputMeta } from "../tools/output-meta.js";
 export declare const SKILL_PROMPT_MESSAGE_TYPE = "skill-prompt";
 export declare const LSP_LATE_DIAGNOSTIC_MESSAGE_TYPE = "lsp-late-diagnostic";
 export declare const BACKGROUND_TAN_DISPATCH_MESSAGE_TYPE = "background-tan-dispatch";
+/**
+ * Logs provider-error turns so their actual cause is available outside the
+ * session transcript. No-op for non-error stop reasons.
+ */
+export declare function logProviderTurnError(msg: AssistantMessage): void;
+/**
+ * Removes replay-bound provider state before reparenting an assistant message
+ * under a different user turn.
+ */
+export declare function sanitizeAssistantForReparentedHistory(message: AssistantMessage): AssistantMessage;
+/**
+ * Collapses degenerate repeated lines and bounds an ephemeral side-channel
+ * reply to 4 KiB.
+ */
+export declare function dedupeEphemeralReply(text: string): string;
+/** Builds the recent user/assistant context supplied to title regeneration. */
+export declare function buildReplanTitleContext(messages: AgentMessage[]): string;
+/**
+ * Compares session messages by provider-replay semantics, ignoring runtime-only
+ * fields that do not change a restored request.
+ */
+export declare function didSessionMessagesChange(previousMessages: AgentMessage[], nextMessages: AgentMessage[]): boolean;
 /** Fallback type for extension-injected messages that omit a custom type. */
 export declare const DEFAULT_CUSTOM_MESSAGE_TYPE = "custom-message";
 /** Content shape accepted for extension-injected messages. */

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

@@ -0,0 +1,180 @@
+import { type Agent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model, ProviderSessionState, ServiceTier, ServiceTierByFamily, ServiceTierFamily } from "@oh-my-pi/pi-ai";
+import { Effort } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import { type ResolvedModelRoleValue } from "../config/model-resolver.js";
+import type { Settings } from "../config/settings.js";
+import { type ConfiguredThinkingLevel } from "../thinking.js";
+import type { EditMode } from "../utils/edit-mode.js";
+import type { AgentSessionEvent } from "./agent-session-events.js";
+import type { ModelCycleResult, ResolvedRoleModel, RoleModelCycle, RoleModelCycleResult } from "./agent-session-types.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities borrowed from the owning AgentSession. */
+export interface ModelControlsHost {
+    agent: Agent;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    sessionManager: SessionManager;
+    providerSessionState: Map<string, ProviderSessionState>;
+    model(): Model | undefined;
+    sessionId(): string;
+    promptGeneration(): number;
+    resolveActiveEditMode(): EditMode;
+    syncAfterModelChange(previousEditMode: EditMode): Promise<void>;
+    setModelWithProviderSessionReset(model: Model): void;
+    clearActiveRetryFallback(): void;
+    clearInheritedProviderPromptCacheKey(): void;
+    magicKeywordEnabled(keyword: "orchestrate" | "ultrathink" | "workflow"): boolean;
+    emit(event: AgentSessionEvent): void;
+    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+}
+/** Owns model selection, thinking effort, role cycling, and service tiers. */
+export declare class ModelControls {
+    #private;
+    constructor(host: ModelControlsHost, options: {
+        scopedModels?: Array<{
+            model: Model;
+            thinkingLevel?: ThinkingLevel;
+        }>;
+        thinkingLevel?: ConfiguredThinkingLevel;
+        serviceTierByFamily?: ServiceTierByFamily;
+    });
+    /** Effective metadata-clamped thinking level applied to the agent. */
+    get thinkingLevel(): ThinkingLevel | undefined;
+    /** Configured selector, preserving `auto` while classification is active. */
+    configuredThinkingLevel(): ConfiguredThinkingLevel | undefined;
+    /** Whether per-turn automatic thinking classification is enabled. */
+    get isAutoThinking(): boolean;
+    /** Last concrete effort selected by automatic classification. */
+    get autoResolvedThinkingLevel(): Effort | undefined;
+    /** Models explicitly scoped to the session's cycle command. */
+    get scopedModels(): ReadonlyArray<{
+        model: Model;
+        thinkingLevel?: ThinkingLevel;
+    }>;
+    /** Live per-provider-family service-tier selection. */
+    get serviceTierByFamily(): ServiceTierByFamily;
+    /** Restores thinking state from a transcript without persisting a new entry. */
+    restoreThinkingLevel(level: ConfiguredThinkingLevel | undefined): void;
+    /** Restores an exact thinking snapshot after a failed session switch. */
+    restoreThinkingSnapshot(level: ThinkingLevel | undefined, auto: boolean, resolved: Effort | undefined): void;
+    /** Restores service tiers without persisting a duplicate transcript entry. */
+    restoreServiceTiers(tiers: ServiceTierByFamily): void;
+    resolveRoleModel(role: string): Model | undefined;
+    resolveRoleModelWithThinking(role: string): ResolvedModelRoleValue;
+    resolveTemporaryModelThinkingLevel(model: Model): ConfiguredThinkingLevel | undefined;
+    setModel(model: Model, role?: string, options?: {
+        selector?: string;
+        thinkingLevel?: ThinkingLevel;
+        persist?: boolean;
+        currentContextTokens?: number;
+    }): Promise<{
+        switched: boolean;
+    }>;
+    /**
+     * Set model temporarily (for this session only).
+     * Validates that a credential source is configured (synchronously, without
+     * refreshing OAuth or running command-backed key programs), saves to session
+     * log but NOT to settings.
+     * @throws Error if no API key available for the model
+     */
+    setModelTemporary(model: Model, thinkingLevel?: ConfiguredThinkingLevel, options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    /**
+     * Cycle to next/previous model.
+     * Uses scoped models (from --models flag) if available, otherwise all available models.
+     * @param direction - "forward" (default) or "backward"
+     * @returns The new model info, or undefined if only one model available
+     */
+    cycleModel(direction?: "forward" | "backward"): Promise<ModelCycleResult | undefined>;
+    /**
+     * Resolve the configured role models in the given order plus the index of
+     * the currently active one. Roles that have no configured model, or whose
+     * configured model is not currently available, are skipped. The `default`
+     * role falls back to the active model when no explicit assignment exists.
+     *
+     * Returns `undefined` only when there is no current model or no available
+     * models at all; an empty `models` array is never returned (callers should
+     * still guard on `models.length`).
+     */
+    getRoleModelCycle(roleOrder: readonly string[]): RoleModelCycle | undefined;
+    /**
+     * Apply a resolved role model as the active model without changing global
+     * settings. Shared with role cycling and the plan-approval model slider.
+     */
+    applyRoleModel(entry: ResolvedRoleModel): Promise<void>;
+    /**
+     * Cycle through configured role models in a fixed order.
+     * Skips missing roles and changes only the active session model.
+     * @param roleOrder - Order of roles to cycle through (e.g., ["slow", "default", "smol"])
+     * @param direction - "forward" (default) or "backward"
+     */
+    cycleRoleModels(roleOrder: readonly string[], direction?: "forward" | "backward"): Promise<RoleModelCycleResult | undefined>;
+    /**
+     * Get all available models with valid API keys, filtered by `enabledModels` when configured.
+     * See {@link filterAvailableModelsByEnabledPatterns} for supported pattern forms and limitations.
+     */
+    getAvailableModels(): Model[];
+    /**
+     * Set the thinking level. `auto` enables per-turn classification. Entering
+     * auto writes its provisional level plus `configured: "auto"` immediately,
+     * giving external readers an authoritative selection receipt before the next
+     * user turn. Later classifications persist only changed concrete resolutions.
+     */
+    setThinkingLevel(level: ConfiguredThinkingLevel | undefined, persist?: boolean): void;
+    /**
+     * Cycle to next thinking level: off → auto → minimal..max → off.
+     * @returns New selector, or undefined if model doesn't support thinking
+     */
+    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).
+     */
+    applyAutoThinkingLevel(promptText: string, generation: number): Promise<void>;
+    /**
+     * True when the currently selected model's family is set to `priority` — the
+     * `/fast` on/off state for the active model. Returns false when no model is
+     * selected or the model exposes no service-tier family (e.g. Fireworks, which
+     * has its own Providers › Fireworks Tier toggle).
+     *
+     * For "is priority actually applied to the next request?" use
+     * {@link isFastModeActive} instead.
+     */
+    isFastModeEnabled(): boolean;
+    /**
+     * True when `priority` is actually realized on the wire for the currently
+     * selected model (OpenAI/Google `service_tier`, direct Anthropic fast mode,
+     * or Fireworks priority). Returns false for tiers the active model can't
+     * realize and when no model is selected.
+     */
+    isFastModeActive(): boolean;
+    /**
+     * Effective wire service-tier for a request to `model`. Fireworks models take
+     * the Priority serving path only when the Providers › Fireworks Tier setting
+     * is `"priority"` (and never for `-fast` variants, whose Fast serving path is
+     * mutually exclusive with Priority). Every other model resolves the live
+     * per-family tier map down to the entry for its family.
+     */
+    effectiveServiceTier(model?: Model | undefined): ServiceTier | undefined;
+    /** The live per-family tier map, or `null` when empty (for session persistence). */
+    serviceTierEntry(): ServiceTierByFamily | null;
+    /** Set one family's tier (or clear it with `undefined`); persists the change. */
+    setServiceTierFamily(family: ServiceTierFamily, tier: ServiceTier | undefined): void;
+    /**
+     * `/fast on|off` targets the family of the currently selected model: it sets
+     * (or clears) that family's `priority` tier. Returns `false` when the model
+     * has no service-tier family, so callers can report that fast mode is
+     * unavailable instead of claiming success.
+     */
+    setFastMode(enabled: boolean): boolean;
+    toggleFastMode(): boolean;
+    /**
+     * Get available thinking levels for current model.
+     */
+    getAvailableThinkingLevels(): ReadonlyArray<Effort>;
+}

package/dist/types/session/prewalk.d.ts

@@ -0,0 +1,46 @@
+import type { Agent, AgentMessage, AgentTurnEndContext } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { LocalProtocolOptions } from "../internal-urls/index.js";
+import type { PlanModeState } from "../plan-mode/state.js";
+import type { ConfiguredThinkingLevel } from "../thinking.js";
+import type { PlanProposalHandler } from "../tools/resolve.js";
+import type { PlanYolo, Prewalk } from "./agent-session-types.js";
+import type { SessionManager } from "./session-manager.js";
+/** Capabilities the prewalk coordinator borrows from its owning session. */
+export interface PrewalkCoordinatorHost {
+    agent: Agent;
+    sessionManager: SessionManager;
+    model(): Model | undefined;
+    emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
+    setModelTemporary(model: Model, thinkingLevel?: ConfiguredThinkingLevel, options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    setActiveToolsByName(names: string[]): Promise<void>;
+    getActiveToolNames(): string[];
+    getEnabledToolNames(): string[];
+    hasBuiltInTool(name: string): boolean;
+    getPlanModeState(): PlanModeState | undefined;
+    setPlanModeState(state: PlanModeState | undefined): void;
+    getPlanReferencePath(): string;
+    setPlanProposalHandler(handler: PlanProposalHandler | null): void;
+    waitForSessionMessagePersistence(message: AgentMessage): Promise<void>;
+    localProtocolOptions(): LocalProtocolOptions;
+}
+/** Initial state for prewalk and plan-yolo startup flows. */
+export interface PrewalkCoordinatorOptions {
+    prewalk?: Prewalk;
+    planYolo?: PlanYolo;
+}
+/** Coordinates one-way model prewalks and automatic plan-yolo handoffs. */
+export declare class PrewalkCoordinator {
+    #private;
+    constructor(host: PrewalkCoordinatorHost, options?: PrewalkCoordinatorOptions);
+    /** Current prewalk target, if the one-way switch remains armed. */
+    get state(): Prewalk | undefined;
+    /** Advances the one-way prewalk switch at a completed assistant-turn boundary. */
+    advanceAtTurnEnd(liveMessages: AgentMessage[], context: AgentTurnEndContext | undefined): Promise<void>;
+    /** Arms a prewalk immediately for an explicit slash-command request. */
+    arm(target: Model, thinkingLevel?: ConfiguredThinkingLevel): void;
+    /** Lazily enables plan-yolo's plan phase before the first prompt is built. */
+    armPlanYoloIfNeeded(): Promise<void>;
+}

package/dist/types/session/queued-messages.d.ts

@@ -0,0 +1,22 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
+import type { RestoredQueuedMessage } from "./agent-session-types.js";
+import { type CustomMessage } from "./messages.js";
+/** Whether a queued message should render in the queue UI. */
+export declare function isDisplayableQueuedMessage(message: AgentMessage): boolean;
+/** Whether a queued message is an advisor card. */
+export declare function isAdvisorCard(message: AgentMessage): message is CustomMessage;
+/** Whether a message is a terminal assistant answer containing text and no tools. */
+export declare function isTerminalTextAssistantAnswer(message: AgentMessage | undefined): message is AssistantMessage;
+/** Whether queued content was authored by the user and can be restored to the editor. */
+export declare function isUserQueuedMessage(message: AgentMessage): boolean;
+/** Hidden magic-keyword notices queued alongside a user prompt. */
+export declare const MAGIC_KEYWORD_NOTICE_TYPES: Record<string, true>;
+/** Hidden companion carrying vision descriptions for a text-only model. */
+export declare const IMAGE_ATTACHMENT_DESCRIPTION_TYPE = "image-attachment-description";
+/** Whether a hidden queued message is a companion of an adjacent user prompt. */
+export declare function isHiddenUserCompanion(message: AgentMessage): boolean;
+/** Human-readable text shown for a queued-message chip. */
+export declare function queueChipText(message: AgentMessage): string;
+/** Converts a queued user message to editor-restorable content. */
+export declare function toRestoredQueuedMessage(message: AgentMessage): RestoredQueuedMessage;

package/dist/types/session/redis-session-storage.d.ts

@@ -6,6 +6,7 @@ import { IndexedSessionStorage } from "./indexed-session-storage.js";
  * without dragging the entire Bun typings into this module.
  */
 export interface RedisSessionStorageClient {
+    send(command: string, args: string[]): Promise<unknown>;
     get(key: string): Promise<string | null>;
     getrange(key: string, start: number, end: number): Promise<string>;
     strlen(key: string): Promise<number>;

package/dist/types/session/retry-fallback-chains.d.ts

@@ -0,0 +1,74 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import type { Settings } from "../config/settings.js";
+import { type ConfiguredThinkingLevel } from "../thinking.js";
+/** Configured fallback chains keyed by role or model selector. */
+export type RetryFallbackChains = Record<string, string[]>;
+/** Policy controlling restoration of a fallback chain's primary model. */
+export type RetryFallbackRevertPolicy = "never" | "cooldown-expiry";
+/** Parsed model selector used by retry fallback resolution. */
+export interface RetryFallbackSelector {
+    raw: string;
+    provider: string;
+    id: string;
+    thinkingLevel: ThinkingLevel | undefined;
+}
+/** Minimal model lookup needed by fallback-chain resolution. */
+export interface RetryFallbackModelLookup {
+    find(provider: string, id: string): Model | undefined;
+    hasProvider(provider: string): boolean;
+}
+/**
+ * Inputs shared by startup (sdk) and runtime (turn-recovery) fallback-chain
+ * resolution. `chains` is pre-expanded so callers can apply the default chain
+ * to roles beyond the configured model roles (e.g. a subagent fallback role).
+ */
+export interface RetryFallbackResolutionContext {
+    chains: RetryFallbackChains;
+    getModelRole(role: string): string | undefined;
+    modelLookup: RetryFallbackModelLookup;
+}
+/** Active retry fallback state retained until the primary can be restored. */
+export interface ActiveRetryFallbackState {
+    /** Chain key that produced this fallback: a model-role name or a model-selector key. */
+    role: string;
+    originalSelector: string;
+    originalThinkingLevel: ConfiguredThinkingLevel | undefined;
+    lastAppliedFallbackThinkingLevel: ConfiguredThinkingLevel | undefined;
+    pinned: boolean;
+}
+/** Calculates capped exponential retry delay with downward jitter. */
+export declare function calculateRetryBackoffDelayMs(baseDelayMs: number, attempt: number): number;
+/** Parses a configured retry fallback selector. */
+export declare function parseRetryFallbackSelector(selector: string, modelLookup?: Pick<RetryFallbackModelLookup, "find">): RetryFallbackSelector | undefined;
+/** Whether a fallback-chain key is a model selector rather than a role. */
+export declare function isRetryFallbackModelKey(key: string): boolean;
+/** Whether a fallback-chain key or entry is a provider wildcard. */
+export declare function isRetryFallbackWildcardKey(key: string): boolean;
+/** Splits a wildcard selector into provider and optional model-id prefix. */
+export declare function parseRetryFallbackWildcard(key: string, isKnownProvider: (provider: string) => boolean): {
+    provider: string;
+    idPrefix: string | undefined;
+};
+/** Formats a concrete model and thinking level as a fallback selector. */
+export declare function formatRetryFallbackSelector(model: Model, thinkingLevel: ThinkingLevel | undefined): string;
+/** Whether a provider is registered or configured for discovery. */
+export declare function isKnownProvider(modelRegistry: ModelRegistry, provider: string): boolean;
+/** Apply the configured default chain to roles without their own chain. */
+export declare function expandDefaultRetryFallbackChains(configuredChains: RetryFallbackChains, roleNames: readonly string[]): RetryFallbackChains;
+/** Resolves configured fallback chains, applying the default chain to named roles. */
+export declare function getRetryFallbackChains(settings: Settings): RetryFallbackChains;
+/** Validates configured fallback chains and reports each warning. */
+export declare function validateRetryFallbackChains(settings: Settings, modelRegistry: ModelRegistry, warn: (message: string) => void): void;
+/** Returns the configured fallback-primary restoration policy. */
+export declare function getRetryFallbackRevertPolicy(settings: Settings): RetryFallbackRevertPolicy;
+/**
+ * Resolve the chain key for a concrete selector by specificity: exact model,
+ * longest matching wildcard, hinted/configured role, then default.
+ */
+export declare function resolveRetryFallbackChainKey(context: RetryFallbackResolutionContext, currentSelector: string, currentModel?: Model | null, roleHint?: string): string | undefined;
+/** Return the candidates after the current selector in an effective chain. */
+export declare function findRetryFallbackCandidates(context: RetryFallbackResolutionContext, chainKey: string, currentSelector: string, currentModel?: Model | null, options?: {
+    allowMissingPrimary?: boolean;
+}): RetryFallbackSelector[];

package/dist/types/session/role-models.d.ts

@@ -0,0 +1,15 @@
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "../config/model-registry.js";
+import { type ResolvedModelRoleValue } from "../config/model-resolver.js";
+import type { Settings } from "../config/settings.js";
+/** Formats a role assignment while preserving its explicit thinking selector. */
+export declare function formatRoleModelValue(settings: Settings, modelRegistry: ModelRegistry, role: string, model: Model, selectorOverride?: string, thinkingLevelOverride?: ThinkingLevel): string;
+/** Resolves a configured model target relative to the current provider. */
+export declare function resolveConfiguredModelTarget(configuredTarget: string | undefined, currentModel: Model, availableModels: Model[]): Model | undefined;
+/** Resolves a model's configured context-promotion target. */
+export declare function resolveContextPromotionConfiguredTarget(currentModel: Model, availableModels: Model[]): Model | undefined;
+/** Resolves a model's configured compaction target. */
+export declare function resolveCompactionConfiguredTarget(currentModel: Model, availableModels: Model[]): Model | undefined;
+/** Resolves a model role and its explicit thinking selection. */
+export declare function resolveRoleModelFull(settings: Settings, role: string, availableModels: Model[], currentModel: Model | undefined): ResolvedModelRoleValue;