@oh-my-pi/pi-coding-agent 16.0.4 → 16.0.6

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

@@ -11,13 +11,21 @@
  * bare package root. Subpath imports (`@oh-my-pi/pi-ai/oauth`, etc.)
  * continue to resolve directly against the bundled pi-ai package.
  *
- * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that
- * already serves bare `@sinclair/typebox` imports for the same extension
- * class, keeping the legacy-compat surface internally consistent.
+ * The `Type` runtime and legacy `StringEnum()` helper are borrowed from the
+ * Zod-backed TypeBox shim that already serves TypeBox imports for the same
+ * extension class, keeping the legacy-compat surface internally consistent.
  *
  * Type-level `Static` and `TSchema` continue to come from pi-ai's own
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
- * only the runtime `Type` builder was removed.
+ * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
+import { type TSchema, Type } from "./typebox";
+export interface StringEnumOptions<T extends string> {
+    description?: string;
+    default?: T;
+    examples?: T[];
+    [key: string]: unknown;
+}
+export declare function StringEnum<T extends string>(values: readonly T[], options?: StringEnumOptions<T>): TSchema;
 export * from "@oh-my-pi/pi-ai";
-export { Type } from "./typebox";
+export { Type };

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

@@ -11,4 +11,21 @@
  * entry, while still re-exporting the canonical surface so plugins observe
  * the same module identity as a direct `@oh-my-pi/pi-coding-agent` import.
  */
+import type { TSchema } from "@oh-my-pi/pi-ai";
+import { Settings } from "../config/settings";
+import type { ToolDefinition } from "./extensions/types";
+import { Type } from "./typebox";
+export interface ParsedFrontmatter<T extends Record<string, unknown> = Record<string, unknown>> {
+    frontmatter: T;
+    body: string;
+}
+export declare function parseFrontmatter<T extends Record<string, unknown> = Record<string, unknown>>(content: string): ParsedFrontmatter<T>;
+export declare function stripFrontmatter(content: string): string;
+export declare function defineTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): ToolDefinition<TParams, TDetails>;
+export declare function createCodingTools(cwd: string): ToolDefinition[];
+export declare const SettingsManager: {
+    readonly create: (cwd: string, agentDir?: string) => Promise<Settings>;
+    readonly inMemory: () => Settings;
+};
 export * from "../index";
+export { Type };

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

@@ -79,6 +79,16 @@ export interface SessionCompactEvent {
 export interface SessionShutdownEvent {
     type: "session_shutdown";
 }
+/** Fired when a main-agent turn is about to settle; handlers may request one continuation turn. */
+export interface SessionStopEvent {
+    type: "session_stop";
+    messages: AgentMessage[];
+    turn_id: number;
+    last_assistant_message?: AgentMessage;
+    session_id: string;
+    session_file?: string;
+    stop_hook_active: boolean;
+}
 /** Preparation data for tree navigation (used by session_before_tree event) */
 export interface TreePreparation {
     /** Node being switched to */
@@ -118,7 +128,7 @@ export interface GoalUpdatedEvent {
     goal: Goal | null;
     state?: GoalModeState;
 }
-export type SessionEvent = SessionStartEvent | SessionBeforeSwitchEvent | SessionSwitchEvent | SessionBeforeBranchEvent | SessionBranchEvent | SessionBeforeCompactEvent | SessionCompactingEvent | SessionCompactEvent | SessionShutdownEvent | SessionBeforeTreeEvent | SessionTreeEvent | GoalUpdatedEvent;
+export type SessionEvent = SessionStartEvent | SessionBeforeSwitchEvent | SessionSwitchEvent | SessionBeforeBranchEvent | SessionBranchEvent | SessionBeforeCompactEvent | SessionCompactingEvent | SessionCompactEvent | SessionStopEvent | SessionShutdownEvent | SessionBeforeTreeEvent | SessionTreeEvent | GoalUpdatedEvent;
 /**
  * Fired before each LLM call.
  *
@@ -264,6 +274,17 @@ export interface SessionCompactingResult {
     /** Custom data to store in compaction entry */
     preserveData?: Record<string, unknown>;
 }
+/** Return type for `session_stop` handlers */
+export interface SessionStopEventResult {
+    /** Continue the main session with additional context before settling */
+    continue?: boolean;
+    /** OMP-native model-visible context for the continuation */
+    additionalContext?: string;
+    /** Claude/Codex-compatible block decision; maps to a continuation */
+    decision?: "block";
+    /** Claude/Codex-compatible model-visible continuation reason */
+    reason?: string;
+}
 /** Return type for `session_before_tree` handlers */
 export interface SessionBeforeTreeResult {
     /** If true, cancel the navigation entirely */

package/dist/types/extensibility/typebox.d.ts

@@ -1,45 +1,67 @@
 /**
- * Minimal `@sinclair/typebox` runtime compatibility shim, backed by Zod.
+ * Minimal `@sinclair/typebox` runtime compatibility shim.
  *
  * Historically the coding agent injected the real `@sinclair/typebox` (~5MB
  * dependency) into extensions, hooks, custom tools, and custom commands so
  * they could author parameter schemas as `Type.Object({ name: Type.String() })`.
- * Internally everything already runs through Zod (`wire.ts`, `validation.ts`);
- * the only reason TypeBox remained was extension-author compat.
  *
- * This module replaces that injection with a tiny façade whose `Type` builders
- * return Zod schemas. Output is indistinguishable from hand-written Zod inside
- * the agent pipeline:
+ * This module provides the subset those integrations depend on:
  *
- *   - `isZodSchema()` keys off the Zod `_zod` marker that every schema carries.
- *   - `zodToWireSchema()` emits the same draft 2020-12 JSON Schema providers expect
- *     from TypeBox-authored tools (defaulted fields treated as optional, etc.).
+ *   - TypeBox-style `Type.*` builders.
+ *   - Runtime validation through `schema.safeParse(input)` and `schema.__validator(input)`.
+ *   - Enumerable JSON Schema keywords so `{ ...schema }`, `JSON.stringify(schema)`,
+ *     and `toolWireSchema({ parameters: schema })` all see the same schema.
  *
- * The surface intentionally covers only the common TypeBox builders. Plugins
- * that reached for niche TypeBox-only APIs (`TypeCompiler`, the global
- * `TypeRegistry`, custom `Symbol(TypeBox.Kind)` introspection) must vendor
- * `@sinclair/typebox` directly in their own package.
+ * Internal validator fields and methods are intentionally non-enumerable. The
+ * object should look like JSON Schema at every serialization/wire boundary and
+ * like a small validator at runtime.
  */
-import { type ZodArray, type ZodEnum, type ZodObject, type ZodOptional, type ZodRawShape, type ZodType, z } from "zod/v4";
-export type TSchema = ZodType;
-export type Static<T extends ZodType> = z.infer<T>;
-export type TAny = ZodType;
-export type TUnknown = ZodType;
-export type TNever = ZodType;
-export type TNull = ZodType;
-export type TString = z.ZodString;
-export type TNumber = z.ZodNumber;
-export type TInteger = z.ZodNumber;
-export type TBoolean = z.ZodBoolean;
-export type TLiteral<V extends string | number | boolean> = z.ZodLiteral<V>;
-export type TArray<E extends ZodType> = ZodArray<E>;
-export type TObject<P extends ZodRawShape = ZodRawShape> = ZodObject<P>;
-export type TOptional<E extends ZodType> = ZodOptional<E>;
-export type TUnion<_T extends readonly ZodType[] = readonly ZodType[]> = ZodType;
-export type TEnum<T extends readonly (string | number)[] = readonly (string | number)[]> = ZodEnum<{
-    [K in T[number] as `${K}`]: K;
-}>;
-export type TRecord<_K extends ZodType, _V extends ZodType> = ZodType;
+export type TSchema = ArkSchema;
+export type Static<T extends ArkSchema> = T["__infer"];
+export type TAny = ArkSchema;
+export type TUnknown = ArkSchema;
+export type TNever = ArkSchema;
+export type TNull = ArkSchema;
+export type TString = ArkSchema;
+export type TNumber = ArkSchema;
+export type TInteger = ArkSchema;
+export type TBoolean = ArkSchema;
+export type TLiteral<_V extends string | number | boolean> = ArkSchema;
+export type TArray<_E extends ArkSchema> = ArkSchema;
+export type TObject<_P extends Record<string, ArkSchema> = Record<string, ArkSchema>> = ArkSchema;
+export type TOptional<_E extends ArkSchema> = ArkSchema;
+export type TUnion<_T extends readonly ArkSchema[] = readonly ArkSchema[]> = ArkSchema;
+export type TEnum<_T extends readonly (string | number)[] = readonly (string | number)[]> = ArkSchema;
+export type TRecord<_K extends ArkSchema, _V extends ArkSchema> = ArkSchema;
+declare const VALIDATION_FAILURE: unique symbol;
+interface ValidationFailure {
+    message: string;
+    readonly [VALIDATION_FAILURE]: true;
+}
+interface SafeParseSuccess {
+    success: true;
+    data: unknown;
+}
+interface SafeParseFailure {
+    success: false;
+    error: ValidationFailure;
+}
+/**
+ * JSON-Schema-shaped object with non-enumerable runtime helpers.
+ * Validators return the validated data or a marked `{ message }` failure.
+ */
+interface ArkSchema {
+    __validator: (data: unknown) => unknown;
+    __metadata?: Record<string, unknown>;
+    __optional?: true;
+    __properties?: Record<string, ArkSchema>;
+    __additionalProperties?: boolean | ArkSchema;
+    __infer?: unknown;
+    __inner?: ArkSchema;
+    safeParse(input: unknown): SafeParseSuccess | SafeParseFailure;
+    toJSON(): Record<string, unknown>;
+    [key: string]: unknown;
+}
 interface Meta {
     title?: string;
     description?: string;
@@ -70,32 +92,32 @@ interface ObjectOpts extends Meta {
      * TypeBox default: extra keys are preserved. Set `false` to reject unknowns,
      * `true` to allow any, or a schema to validate them.
      */
-    additionalProperties?: boolean | ZodType;
+    additionalProperties?: boolean | ArkSchema;
 }
-declare function tString(opts?: StringOpts): ZodType;
-declare function tNumber(opts?: NumberOpts): ZodType;
-declare function tInteger(opts?: NumberOpts): ZodType;
-declare function tBoolean(opts?: Meta): ZodType;
-declare function tNull(opts?: Meta): ZodType;
-declare function tAny(opts?: Meta): ZodType;
-declare function tUnknown(opts?: Meta): ZodType;
-declare function tNever(opts?: Meta): ZodType;
-declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ZodType;
-declare function tUnion<T extends readonly ZodType[]>(schemas: T, opts?: Meta): ZodType;
-declare function tIntersect(schemas: readonly ZodType[], opts?: Meta): ZodType;
-declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ZodType;
-declare function tArray<E extends ZodType>(item: E, opts?: ArrayOpts): ZodType;
-declare function tTuple(items: readonly ZodType[], opts?: Meta): ZodType;
-declare function tObject<P extends ZodRawShape>(properties: P, opts?: ObjectOpts): ZodObject<P>;
-declare function tRecord<V extends ZodType>(key: ZodType, value: V, opts?: Meta): ZodType;
-declare function tOptional<E extends ZodType>(schema: E, _opts?: Meta): ZodOptional<E>;
-declare function tNullable<E extends ZodType>(schema: E, opts?: Meta): ZodType;
-declare function tReadonly<E extends ZodType>(schema: E): E;
-declare function tPartial<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P>;
-declare function tRequired<P extends ZodRawShape>(obj: ZodObject<P>): ZodObject<P>;
-declare function tPick<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Pick<P, K>>;
-declare function tOmit<P extends ZodRawShape, K extends keyof P>(obj: ZodObject<P>, keys: readonly K[]): ZodObject<Omit<P, K>>;
-declare function tComposite(objects: readonly ZodObject<ZodRawShape>[], opts?: Meta): ZodObject<ZodRawShape>;
+declare function tString(opts?: StringOpts): ArkSchema;
+declare function tNumber(opts?: NumberOpts): ArkSchema;
+declare function tInteger(opts?: NumberOpts): ArkSchema;
+declare function tBoolean(opts?: Meta): ArkSchema;
+declare function tNull(opts?: Meta): ArkSchema;
+declare function tAny(opts?: Meta): ArkSchema;
+declare function tUnknown(opts?: Meta): ArkSchema;
+declare function tNever(opts?: Meta): ArkSchema;
+declare function tLiteral<V extends string | number | boolean>(value: V, opts?: Meta): ArkSchema;
+declare function tUnion<T extends readonly ArkSchema[]>(schemas: T, opts?: Meta): ArkSchema;
+declare function tIntersect(schemas: readonly ArkSchema[], opts?: Meta): ArkSchema;
+declare function tEnum<T extends Record<string, string | number> | readonly (string | number)[]>(values: T, opts?: Meta): ArkSchema;
+declare function tArray<E extends ArkSchema>(item: E, opts?: ArrayOpts): ArkSchema;
+declare function tTuple(items: readonly ArkSchema[], opts?: Meta): ArkSchema;
+declare function tObject<P extends Record<string, ArkSchema>>(properties: P, opts?: ObjectOpts): ArkSchema;
+declare function tRecord<K extends ArkSchema, V extends ArkSchema>(key: K, value: V, opts?: Meta): ArkSchema;
+declare function tOptional<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
+declare function tNullable<E extends ArkSchema>(schema: E, opts?: Meta): ArkSchema;
+declare function tReadonly<E extends ArkSchema>(schema: E): ArkSchema;
+declare function tPartial<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
+declare function tRequired<_P extends Record<string, ArkSchema>>(obj: ArkSchema): ArkSchema;
+declare function tPick<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
+declare function tOmit<P extends Record<string, ArkSchema>, K extends keyof P>(obj: ArkSchema, keys: readonly K[]): ArkSchema;
+declare function tComposite(objects: readonly ArkSchema[], opts?: Meta): ArkSchema;
 export declare const Type: {
     readonly String: typeof tString;
     readonly Number: typeof tNumber;

package/dist/types/goals/tools/goal-tool.d.ts

@@ -1,22 +1,15 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
-import { z } from "zod/v4";
 import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
 import type { Theme } from "../../modes/theme/theme";
 import type { ToolSession } from "../../tools";
 import type { Goal, GoalToolDetails } from "../state";
-declare const goalSchema: z.ZodObject<{
-    op: z.ZodEnum<{
-        complete: "complete";
-        create: "create";
-        drop: "drop";
-        get: "get";
-        resume: "resume";
-    }>;
-    objective: z.ZodOptional<z.ZodString>;
-    token_budget: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export type GoalToolInput = z.infer<typeof goalSchema>;
+declare const goalSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    op: "complete" | "create" | "drop" | "get" | "resume";
+    objective?: string | undefined;
+    token_budget?: number | undefined;
+}, {}>;
+export type GoalToolInput = typeof goalSchema.infer;
 export interface GoalToolResponse {
     goal: Goal | null;
     remainingTokens: number | null;
@@ -30,17 +23,11 @@ export declare class GoalTool implements AgentTool<typeof goalSchema, GoalToolDe
     readonly name = "goal";
     readonly label = "Goal";
     readonly description: string;
-    readonly parameters: z.ZodObject<{
-        op: z.ZodEnum<{
-            complete: "complete";
-            create: "create";
-            drop: "drop";
-            get: "get";
-            resume: "resume";
-        }>;
-        objective: z.ZodOptional<z.ZodString>;
-        token_budget: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        op: "complete" | "create" | "drop" | "get" | "resume";
+        objective?: string | undefined;
+        token_budget?: number | undefined;
+    }, {}>;
     readonly strict = true;
     readonly intent: "omit";
     constructor(session: ToolSession);

package/dist/types/index.d.ts

@@ -1,6 +1,8 @@
 import { HookEditorComponent, HookInputComponent, HookSelectorComponent } from "./modes/components";
 export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 export { getAgentDir, logger, VERSION } from "@oh-my-pi/pi-utils";
+export * as zod from "zod/v4";
+export { z } from "zod/v4";
 export * from "./config/keybindings";
 export * from "./config/model-registry";
 export type * from "./config/prompt-templates";

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

@@ -102,32 +102,17 @@ export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetai
     readonly loadMode = "discoverable";
     readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
     readonly description: string;
-    readonly parameters: import("zod/v4").ZodObject<{
-        action: import("zod/v4").ZodEnum<{
-            capabilities: "capabilities";
-            code_actions: "code_actions";
-            definition: "definition";
-            diagnostics: "diagnostics";
-            hover: "hover";
-            implementation: "implementation";
-            references: "references";
-            reload: "reload";
-            rename: "rename";
-            rename_file: "rename_file";
-            request: "request";
-            status: "status";
-            symbols: "symbols";
-            type_definition: "type_definition";
-        }>;
-        file: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        line: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        symbol: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        query: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        new_name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-        apply: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
-        timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
-        payload: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
-    }, import("zod/v4/core").$strip>;
+    readonly parameters: import("arktype/internal/variants/object.ts").ObjectType<{
+        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+        file?: string | undefined;
+        line?: number | undefined;
+        symbol?: string | undefined;
+        query?: string | undefined;
+        new_name?: string | undefined;
+        apply?: boolean | undefined;
+        timeout?: number | undefined;
+        payload?: string | undefined;
+    }, {}>;
     readonly strict = true;
     constructor(session: ToolSession);
     static createIf(session: ToolSession): LspTool | null;

package/dist/types/lsp/types.d.ts

@@ -1,32 +1,16 @@
 import type { ptree } from "@oh-my-pi/pi-utils";
-import { z } from "zod/v4";
-export declare const lspSchema: z.ZodObject<{
-    action: z.ZodEnum<{
-        capabilities: "capabilities";
-        code_actions: "code_actions";
-        definition: "definition";
-        diagnostics: "diagnostics";
-        hover: "hover";
-        implementation: "implementation";
-        references: "references";
-        reload: "reload";
-        rename: "rename";
-        rename_file: "rename_file";
-        request: "request";
-        status: "status";
-        symbols: "symbols";
-        type_definition: "type_definition";
-    }>;
-    file: z.ZodOptional<z.ZodString>;
-    line: z.ZodOptional<z.ZodNumber>;
-    symbol: z.ZodOptional<z.ZodString>;
-    query: z.ZodOptional<z.ZodString>;
-    new_name: z.ZodOptional<z.ZodString>;
-    apply: z.ZodOptional<z.ZodBoolean>;
-    timeout: z.ZodOptional<z.ZodNumber>;
-    payload: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type LspParams = z.infer<typeof lspSchema>;
+export declare const lspSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+    file?: string | undefined;
+    line?: number | undefined;
+    symbol?: string | undefined;
+    query?: string | undefined;
+    new_name?: string | undefined;
+    apply?: boolean | undefined;
+    timeout?: number | undefined;
+    payload?: string | undefined;
+}, {}>;
+export type LspParams = typeof lspSchema.infer;
 export interface LspToolDetails {
     serverName?: string;
     action: string;

package/dist/types/main.d.ts

@@ -10,6 +10,7 @@ import type { AuthStorage } from "./session/auth-storage";
 import { type SessionInfo } from "./session/session-listing";
 import { SessionManager } from "./session/session-manager";
 type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
+export declare function writeStartupNotice(parsedArgs: Pick<Args, "mode">, text: string): void;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;

package/dist/types/mcp/client.d.ts

@@ -35,6 +35,14 @@ export declare function listResources(connection: MCPServerConnection, options?:
 }): Promise<MCPResource[]>;
 /**
  * List resource templates from a connected server.
+ *
+ * A server MAY advertise the `resources` capability without implementing the
+ * optional `resources/templates/list` method (it is optional in the MCP spec).
+ * Such servers reject the request with JSON-RPC -32601 ("Method not found").
+ * Treat that as "no templates" and return `[]` rather than throwing — otherwise
+ * a caller that loads resources and templates together (see `MCPManager`'s
+ * `Promise.all([listResources, listResourceTemplates])`) would discard the
+ * server's concrete resources too. Any other error still propagates.
  */
 export declare function listResourceTemplates(connection: MCPServerConnection, options?: {
     signal?: AbortSignal;

package/dist/types/modes/components/btw-panel.d.ts

@@ -11,6 +11,7 @@ export declare class BtwPanelComponent extends Container {
     markComplete(): void;
     markAborted(): void;
     markError(message: string): void;
+    isBranchable(): boolean;
     close(): void;
 }
 export {};

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

@@ -1,6 +1,6 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
-type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
+type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.display.reset" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.retry" | "app.clipboard.pasteImage" | "app.clipboard.pasteTextRaw" | "app.clipboard.copyPrompt">;
 /** Max gap (ms) between two spaces for the later one to count as OS key auto-repeat rather than a
  *  deliberate press. OS auto-repeat is fast; a deliberate tap (even a fast one) is slower. */
 export declare const SPACE_REPEAT_MAX_GAP_MS = 120;
@@ -79,6 +79,8 @@ export declare class CustomEditor extends Editor {
     onPasteTextRaw?: () => void;
     /** Called when the configured dequeue shortcut is pressed. */
     onDequeue?: () => void;
+    /** Called when the configured retry shortcut is pressed. */
+    onRetry?: () => void;
     /** Called when Caps Lock is pressed. */
     onCapsLock?: () => void;
     /** Called when left-arrow is pressed while the editor is empty (cursor necessarily at start). */

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

@@ -50,7 +50,7 @@ export declare class StatusLineComponent implements Component {
      * for unit tests and the collab host's state broadcast.
      */
     getCachedContextBreakdown(): {
-        usedTokens: number | null;
+        usedTokens: number;
         contextWindow: number;
     };
     getTopBorder(width: number): {

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

@@ -4,7 +4,6 @@ export declare function getContextUsageLevel(contextPercent: number, contextWind
 /**
  * Format context usage as `<percent>%/<window>` (e.g. `5.1%/1M`), matching the
  * status line's context gauge so subagent and footer renderers stay in sync.
- * A `null`/`undefined` percent (unknown, e.g. right after compaction) renders as `?`.
  */
 export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number): string;
 export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

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

@@ -4,6 +4,8 @@ export declare class BtwController {
     private readonly ctx;
     constructor(ctx: InteractiveModeContext);
     hasActiveRequest(): boolean;
+    canBranch(): boolean;
+    handleBranch(): Promise<boolean>;
     handleEscape(): boolean;
     dispose(): void;
     start(question: string): Promise<void>;

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

@@ -18,6 +18,7 @@ export declare class InputController {
     handleCtrlD(): void;
     handleCtrlZ(): void;
     handleDequeue(): void;
+    handleRetry(): Promise<void>;
     /** Send editor text as a follow-up message (queued behind current stream). */
     handleFollowUp(): Promise<void>;
     restoreQueuedMessagesToEditor(options?: {

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

@@ -330,6 +330,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    canBranchBtw(): boolean;
+    handleBtwBranchKey(): Promise<boolean>;
+    handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
     handleOmfgCommand(complaint: string): Promise<void>;
     hasActiveOmfg(): boolean;
     handleOmfgEscape(): boolean;

package/dist/types/modes/rpc/rpc-types.d.ts

@@ -188,7 +188,7 @@ export interface RpcSessionState {
         parameters: unknown;
         examples?: readonly ToolExample[];
     }>;
-    /** Current context window usage. Null tokens/percent when unknown (e.g. right after compaction). */
+    /** Current context window usage. */
     contextUsage?: ContextUsage;
 }
 export interface RpcAvailableSlashCommand {

package/dist/types/modes/setup-wizard/index.d.ts

@@ -3,6 +3,7 @@ import { CURRENT_SETUP_VERSION } from "../setup-version";
 import type { InteractiveModeContext } from "../types";
 import type { SetupScene } from "./scenes/types";
 export type { SetupScene, SetupSceneController, SetupSceneHost, SetupSceneResult } from "./scenes/types";
+export { runStartupSplash } from "./startup-splash";
 export { CURRENT_SETUP_VERSION };
 export declare const ALL_SCENES: readonly [SetupScene, SetupScene, SetupScene];
 export interface SetupSceneSelectionOptions {

package/dist/types/modes/setup-wizard/startup-splash.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveModeContext } from "../types";
+export interface RunStartupSplashOptions {
+    readonly durationMs?: number;
+    readonly tickMs?: number;
+    readonly now?: () => number;
+}
+export declare function runStartupSplash(ctx: InteractiveModeContext, options?: RunStartupSplashOptions): Promise<void>;

package/dist/types/modes/theme/theme.d.ts

@@ -290,7 +290,7 @@ export declare function setColorBlindMode(enabled: boolean): Promise<void>;
  * Get the current color blind mode setting.
  */
 export declare function getColorBlindMode(): boolean;
-export declare function onThemeChange(callback: () => void): void;
+export declare function onThemeChange(callback: () => void): () => void;
 /**
  * Monotonic counter bumped on any theme-affecting change that should invalidate
  * cached renders: theme swaps and reloads (including the invalid-theme dark

package/dist/types/modes/types.d.ts

@@ -316,6 +316,9 @@ export interface InteractiveModeContext {
     handleTanCommand(work: string): Promise<void>;
     hasActiveBtw(): boolean;
     handleBtwEscape(): boolean;
+    handleBtwBranchKey(): Promise<boolean>;
+    canBranchBtw(): boolean;
+    handleBtwBranch(question: string, assistantMessage: AssistantMessage): Promise<void>;
     handleOmfgCommand(complaint: string): Promise<void>;
     hasActiveOmfg(): boolean;
     handleOmfgEscape(): boolean;

package/dist/types/modes/utils/context-usage.d.ts

@@ -37,6 +37,18 @@ export declare function estimateToolSchemaTokens(tools: ReadonlyArray<Pick<Tool,
  * messages walked incrementally as new entries append.
  */
 export declare function computeNonMessageTokens(session: AgentSession): number;
+/**
+ * Shared helper for the four non-message token totals used by
+ * `computeContextBreakdown` (/context panel). Keep this category split stable:
+ * the status-line fast path intentionally uses the equivalent collapsed total
+ * in `computeNonMessageTokens`.
+ */
+export declare function computeNonMessageBreakdown(session: AgentSession): {
+    skillsTokens: number;
+    toolsTokens: number;
+    systemContextTokens: number;
+    systemPromptTokens: number;
+};
 /**
  * Compute a breakdown of estimated context usage by category for the active
  * session and model.

package/dist/types/sdk.d.ts

@@ -55,6 +55,8 @@ export interface CreateAgentSessionOptions {
     providerSessionId?: string;
     /** Optional provider-facing prompt cache key, distinct from request lineage. */
     providerPromptCacheKey?: string;
+    /** Absolute wall-clock deadline in Unix epoch milliseconds. */
+    deadline?: number;
     /** Custom tools to register (in addition to built-in tools). Accepts both CustomTool and ToolDefinition. */
     customTools?: (CustomTool | ToolDefinition)[];
     /** Inline extensions (merged with discovery). */
@@ -160,6 +162,11 @@ export interface CreateAgentSessionOptions {
     localProtocolOptions?: LocalProtocolOptions;
     /** Settings instance. Default: Settings.init({ cwd, agentDir }) */
     settings?: Settings;
+    /**
+     * Legacy alias for `settings`. Older Pi extensions pass SettingsManager.create(...)
+     * through this field; accept it so their SDK calls keep the configured settings.
+     */
+    settingsManager?: Settings | Promise<Settings>;
     /** Whether UI is available (enables interactive tools like ask). Default: false */
     hasUI?: boolean;
     /**
@@ -193,7 +200,7 @@ export interface CreateAgentSessionResult {
     eventBus: EventBus;
 }
 export type DialectFormat = "auto" | "native" | Dialect;
-export declare function resolveDialect(format: DialectFormat, model: Pick<Model, "supportsTools"> | undefined): Dialect | undefined;
+export declare function resolveDialect(format: DialectFormat, model: (Pick<Model, "supportsTools"> & Partial<Pick<Model, "id">>) | undefined): Dialect | undefined;
 export type { PromptTemplate } from "./config/prompt-templates";
 export { Settings, type SkillsSettings } from "./config/settings";
 export type { CustomCommand, CustomCommandFactory } from "./extensibility/custom-commands/types";