@oh-my-pi/pi-coding-agent 17.3.7 → 17.3.8

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

@@ -70,8 +70,10 @@ export declare function isAdvisorInterruptImmuneTurnActive(opts: {
  *   auto-resume anything, so it is delivered live. Parking it during an active
  *   run instead strands it (it never reaches the running agent) and the withheld
  *   notes dump as one burst at the next user prompt — the bug this guards.
- * - During the post-interrupt immune-turn window, further `concern`/`blocker`
- *   notes are downgraded to asides; preservation still wins.
+ * - During the post-interrupt immune-turn window, further `concern` notes are
+ *   downgraded to asides; preservation still wins. A `blocker` is exempt: it
+ *   means the agent handed off broken or unexercised work, so it still steers a
+ *   triggered turn even right after a prior interrupt (#5628).
  */
 export declare function resolveAdvisorDeliveryChannel(opts: {
     severity: AdvisorSeverity | undefined;

package/dist/types/cli/auth-broker-cli.d.ts

@@ -1,3 +1,5 @@
+import { type OAuthCredential } from "@oh-my-pi/pi-ai";
+import type { OAuthCredentials } from "@oh-my-pi/pi-ai/oauth/types";
 export type AuthBrokerAction = "serve" | "token" | "login" | "logout" | "status" | "import" | "migrate" | "list";
 export interface AuthBrokerCommandArgs {
     action: AuthBrokerAction;
@@ -21,5 +23,18 @@ export interface AuthBrokerCommandArgs {
     };
 }
 declare const ACTIONS: readonly AuthBrokerAction[];
+/**
+ * OAuth refresh handler for `omp auth-broker serve`'s {@link AuthStorage}.
+ *
+ * The vault holds provider OAuth rows AND OMP-managed `mcp_oauth:*` rows.
+ * Provider rows refresh through the per-provider registry. MCP rows are
+ * self-describing — the embedded token endpoint and client credentials are the
+ * only refresh material — so they refresh with a generic `refresh_token` grant.
+ * The serve process never loads the MCP manager, so this is the only place that
+ * teaches the broker to refresh MCP tokens; without it
+ * `POST /v1/credential/:id/refresh` fails with "Unknown OAuth provider" and the
+ * background refresher lets MCP access tokens expire (issue #8933).
+ */
+export declare function refreshBrokerOAuthCredential(provider: string, credential: OAuthCredential, signal?: AbortSignal): Promise<OAuthCredentials>;
 export declare function runAuthBrokerCommand(cmd: AuthBrokerCommandArgs): Promise<void>;
 export { ACTIONS as AUTH_BROKER_ACTIONS };

package/dist/types/cli/update-cli.d.ts

@@ -126,6 +126,14 @@ interface UpdateMethodResolutionOptions {
      * preserves a global package symlink instead of resolving into its checkout.
      */
     ompLinkTarget?: string;
+    /**
+     * Whether package-manager routing (bun/npm) is permitted. Binary-only
+     * releases pass `false`: a manager launcher then resolves to `"binary"` and
+     * is taken over in place rather than reinstalled through its manager. Defaults
+     * to `true` in {@link resolveUpdateMethod} so callers that only classify need
+     * not set it.
+     */
+    allowPackageManagers?: boolean;
 }
 type UpdateTarget = {
     method: "brew";

package/dist/types/cli-commands.d.ts

@@ -36,11 +36,19 @@ export type ResolvedCliArgv = {
 } | {
     error: string;
 };
+/**
+ * Subcommands that share the launch flag surface, so leading global flags
+ * (`--cwd`, `--model`, `--approval-mode`, …) placed before them are meaningful
+ * and must be forwarded ({@link resolveCliArgv}, #2970). Every other subcommand
+ * parses only its own flags.
+ */
+export declare const LAUNCH_FLAG_COMMANDS: Record<string, true>;
 /**
  * Decide what the CLI runner should do with raw argv: reject bare reserved
  * management words, pass help/version through untouched, route a recognized
  * subcommand (even behind leading global flags like `--approval-mode=yolo`) to
- * that command with the flags preserved, and forward everything else to
- * `launch` (#2970).
+ * that command, and forward everything else to `launch` (#2970). Leading
+ * launch-global flags are forwarded to launch-shaped commands but stripped for
+ * other subcommands that cannot parse them (#8891).
  */
 export declare function resolveCliArgv(argv: string[]): ResolvedCliArgv;

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

@@ -5775,6 +5775,34 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "providers.cacheRetention": {
+        readonly type: "enum";
+        readonly values: readonly ["auto", "short", "long", "none"];
+        readonly default: "auto";
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Protocol";
+            readonly label: "Prompt Cache Retention";
+            readonly description: "Prompt-cache retention forwarded to providers that support it (Anthropic, Bedrock, OpenRouter, OpenAI)";
+            readonly options: readonly [{
+                readonly value: "auto";
+                readonly label: "Auto";
+                readonly description: "Provider default — Anthropic uses 5m entries kept warm by idle keep-alive refreshes; PI_CACHE_RETENTION still applies";
+            }, {
+                readonly value: "short";
+                readonly label: "Short (5m)";
+                readonly description: "Cheapest cache writes; Anthropic keeps the entry warm with bounded keep-alive refreshes while idle";
+            }, {
+                readonly value: "long";
+                readonly label: "Long (1h)";
+                readonly description: "1h TTL where the provider supports it; pricier writes, no keep-alive refresh requests";
+            }, {
+                readonly value: "none";
+                readonly label: "Off";
+                readonly description: "Disable prompt caching and cache-affinity routing";
+            }];
+        };
+    };
     readonly "providers.streamFirstEventTimeoutSeconds": {
         readonly type: "number";
         readonly default: -1;

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

@@ -103,6 +103,15 @@ export declare class Settings {
      */
     flush(): Promise<void>;
     cloneForCwd(cwd: string): Promise<Settings>;
+    /**
+     * Re-read the current global, project, and explicit overlay layers from disk
+     * without replacing this instance or discarding runtime overrides.
+     *
+     * All sources are loaded before any live layer is replaced, so readers never
+     * observe a partially refreshed configuration. Concurrent callers share the
+     * same reload.
+     */
+    reloadFromDisk(): Promise<void>;
     /**
      * Re-scope this instance to a new working directory *in place*: reload the
      * project layer (`.claude/settings.yml` etc.) from `cwd`, re-resolve

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

@@ -277,6 +277,7 @@ export declare class ExtensionRunner {
     emitContext(messages: AgentMessage[]): Promise<AgentMessage[]>;
     /** Runs request payload hooks with the model used for that provider request. */
     emitBeforeProviderRequest(payload: unknown, model?: Model): Promise<BeforeProviderRequestEventResult>;
-    emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void>;
+    /** Runs response hooks with the model that produced that provider response. */
+    emitAfterProviderResponse(response: ProviderResponseMetadata, model?: Model): Promise<void>;
     emitBeforeAgentStart(prompt: string, images: ImageContent[] | undefined, systemPrompt: string[]): Promise<BeforeAgentStartCombinedResult | undefined>;
 }

package/dist/types/launch/presence.d.ts

@@ -14,6 +14,9 @@ export declare function hasLiveDaemonProjectPresence(runtimeDir: string): Promis
  * Best-effort and non-throwing: a scope is deleted only when its `broker.pid`
  * is absent/dead, no live client presence remains, and it has been untouched
  * for {@link DAEMON_RUNTIME_STALE_GRACE_MS}. The caller's own `currentRuntimeDir`
- * and the machine-global daemon container are always skipped.
+ * is always skipped, and the sweep runs only inside the {@link DAEMONS_DIR}
+ * container over entries named like a {@link DAEMON_SCOPE_KEY} — so a runtime
+ * dir relocated elsewhere (e.g. the smoke test under `os.tmpdir()`) never
+ * reclaims unrelated neighbours (issue #8721).
  */
 export declare function pruneDeadDaemonRuntimeDirs(currentRuntimeDir: string): Promise<void>;

package/dist/types/mcp/oauth-credentials.d.ts

@@ -1,3 +1,4 @@
+import type { OAuthCredentials } from "@oh-my-pi/pi-ai/oauth/types";
 import type { AuthStorage } from "../session/auth-storage.js";
 import { type MCPStoredOAuthCredential } from "./oauth-flow.js";
 import type { MCPAuthConfig, MCPServerConfig } from "./types.js";
@@ -13,5 +14,27 @@ export declare function lookupMcpOAuthCredentialForServer(authStorage: AuthStora
 }): MCPOAuthCredentialLookup | undefined;
 export declare function lookupMcpOAuthCredential(authStorage: AuthStorage | null | undefined, config: MCPServerConfig): MCPOAuthCredentialLookup | undefined;
 export declare function selectMcpOAuthRefreshMaterial(credential: MCPStoredOAuthCredential, auth: MCPAuthConfig | undefined): MCPOAuthRefreshMaterial;
+/**
+ * Refresh a stored MCP OAuth credential via the standard `refresh_token` grant.
+ *
+ * Refresh material is taken from the credential itself (self-contained modern
+ * credentials embed `tokenUrl`/`clientId`/`clientSecret`/`resource`) or, for
+ * legacy credentials that carry none, the server's `auth` block. Shared by the
+ * local MCP manager and the `omp auth-broker serve` refresh path so a broker
+ * with no access to the MCP config can still refresh `mcp_oauth:*` credentials
+ * from the vault.
+ *
+ * `serverUrl` supplies the RFC 8707 fallback resource indicator when neither
+ * the credential nor the auth block advertised one; the manager passes the
+ * configured server URL, the broker recovers it from the credential id via
+ * {@link mcpOAuthServerUrlFromCredentialId}.
+ *
+ * @throws when no usable refresh token or token endpoint is available.
+ */
+export declare function refreshManagedMcpOAuthCredential(credential: MCPStoredOAuthCredential, opts?: {
+    serverUrl?: string;
+    auth?: MCPAuthConfig;
+    signal?: AbortSignal;
+}): Promise<OAuthCredentials>;
 export declare function removeManagedMcpOAuthCredential(authStorage: AuthStorage, credentialId: string | undefined): Promise<boolean>;
 export declare function removeManagedMcpOAuthCredentials(authStorage: AuthStorage, credentialIds: readonly (string | undefined)[]): Promise<boolean>;

package/dist/types/mcp/oauth-flow.d.ts

@@ -29,6 +29,17 @@ export declare function isManagedMCPOAuthCredentialId(credentialId: string | und
  * is the profile; everything after it is the URL.
  */
 export declare function mcpOAuthCredentialProfile(credentialId: string): string | undefined;
+/**
+ * Server URL embedded in a managed MCP OAuth credential id, or `undefined`
+ * for legacy random ids (`mcp_oauth_<rand>`) minted before URL-keyed ids.
+ *
+ * Inverse of {@link mcpOAuthCredentialId}. Mirrors {@link mcpOAuthCredentialProfile}:
+ * the URL contains `:` and `/`, so for profile-scoped ids the URL is everything
+ * after the profile segment; for legacy url-keyed ids (`mcp_oauth:<url>`) it is
+ * everything after the prefix. Lets the auth-broker — which never sees the MCP
+ * config — recover the server URL for the RFC 8707 fallback resource on refresh.
+ */
+export declare function mcpOAuthServerUrlFromCredentialId(credentialId: string): string | undefined;
 /**
  * Stored MCP OAuth credential. Refresh material is embedded so token refresh
  * works without any `auth` block persisted in (possibly shared) config files.

package/dist/types/mnemopi/backend.d.ts

@@ -1,4 +1,16 @@
+import type { MnemopiLlmCompleteOptions } from "@oh-my-pi/pi-mnemopi/core/runtime-options";
 import type { MemoryBackend } from "../memory-backend/types.js";
 import type { AgentSession } from "../session/agent-session.js";
+/** Prompt turns for one Mnemopi completion. */
+export interface MemoryCompletionInput {
+    prompt: string;
+    systemPrompt?: string;
+}
+/** Maps a Mnemopi completion into instruction and input turns.
+ *
+ *  Extraction is the only task with its own instructions, and it always supplies
+ *  the raw text, so the instructions become the system turn and the text becomes
+ *  the user turn. Every other task keeps the prompt Mnemopi rendered. */
+export declare function resolveMemoryCompletionInput(prompt: string, options?: MnemopiLlmCompleteOptions): MemoryCompletionInput;
 export declare const mnemopiBackend: MemoryBackend;
 export declare function getMnemopiDbDirForTests(session: AgentSession): string | undefined;

package/dist/types/modes/components/tool-execution.d.ts

@@ -66,6 +66,12 @@ export declare const SPINNER_GLYPH_ADVANCE_MS = 80;
 /** Phase-locked spinner glyph index shared by every live tool block so parallel
  * spinners advance in lockstep instead of each tracking its own start time. */
 export declare function sharedSpinnerFrame(frameCount: number, now?: number): number;
+/** Stop the shared spinner ticker and drop every registered live block.
+ *  Called on interactive-mode teardown so a stray live block cannot keep the
+ *  process-wide 80ms interval alive past shutdown (lingering event-loop
+ *  handles pin the process; cf. `postmortem.quit`). Test files that assert on
+ *  ticker arming also use this to start from a clean slate. */
+export declare function stopSharedSpinnerTicker(): void;
 /**
  * Component that renders a tool call with its result (updateable)
  */
@@ -96,6 +102,12 @@ export declare class ToolExecutionComponent extends Container implements NativeS
         details?: any;
         isError?: boolean;
     }, isPartial?: boolean, _toolCallId?: string): void;
+    /**
+     * Advance to the shared spinner glyph and repaint just this block. Driven by
+     * the single shared spinner ticker (see `registerSpinnerBlock`); the tick is
+     * component-scoped so the TUI reuses every other root subtree (issue #4377).
+     */
+    tickSpinner(frame: number): void;
     /**
      * Standalone harnesses may mount a tool component directly under `TUI`
      * instead of inside `TranscriptContainer`. In that shape the component must

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

@@ -26,6 +26,8 @@ export declare class InputController {
         readText: typeof readTextFromClipboard;
         readMacFileUrls?: typeof readMacFileUrlsFromClipboard;
     });
+    /** Session-level title starts (user `/skill:` via promptCustomMessage) reuse this UI. */
+    notifyTitleGenerationStart(): void;
     setupKeyHandlers(): void;
     setupEditorSubmitHandler(): void;
     handleCtrlC(): void;

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

@@ -31,7 +31,7 @@ import type { HookInputComponent } from "./components/hook-input.js";
 import type { HookSelectorComponent, HookSelectorSlider } from "./components/hook-selector.js";
 import { type PlanReviewAnnotationState } from "./components/plan-review-overlay.js";
 import { StatusLineComponent } from "./components/status-line/index.js";
-import type { ToolExecutionHandle } from "./components/tool-execution.js";
+import { type ToolExecutionHandle } from "./components/tool-execution.js";
 import { TranscriptContainer } from "./components/transcript-container.js";
 import { EventController } from "./controllers/event-controller.js";
 import { type LoopLimitRuntime } from "./loop-limit.js";
@@ -67,8 +67,8 @@ export interface InteractiveModeOptions {
 }
 /**
  * Build the anchored subagent HUD block: a bold accent "Subagents" header plus
- * a bounded set of running-agent rows in the same `Id: description` shape the
- * inline task rows use (muted task preview when no description was given).
+ * a bounded set of running-agent rows in the same `Id ⟨role⟩: description` shape
+ * the inline task rows use (muted task preview when no description was given).
  * Layout mirrors the Todos HUD exactly: unindented header, then
  * `renderTreeList` rows (dim connectors) shifted right by one space.
  * Only detached background spawns are listed: a sync task call blocks the
@@ -150,6 +150,9 @@ export declare class InteractiveMode implements InteractiveModeContext {
     onInputCallback?: (input: SubmittedUserInput) => void;
     optimisticUserMessageSignature: string | undefined;
     locallySubmittedUserSignatures: Set<string>;
+    /** True while an optimistically-rendered `/skill:` row awaits its canonical
+     *  `message_start`. Read by the event controller to reconcile the row. */
+    optimisticSkillMessagePending: boolean;
     lastSigintTime: number;
     lastEscapeTime: number;
     lastLeftTapTime: number;
@@ -219,6 +222,25 @@ export declare class InteractiveMode implements InteractiveModeContext {
     replaceOptimisticUserMessage(message: AgentMessage, options?: {
         imageLinks?: readonly (string | undefined)[];
     }): void;
+    /**
+     * Optimistically render a user-invoked `/skill:` row before its awaited
+     * dispatch so a slow preflight (memory recall, `before_agent_start` hooks,
+     * auto-thinking classification, pre-prompt compaction) does not leave the
+     * submission invisible — normal prompts paint their row via
+     * {@link startPendingSubmission} the same way (issue #8895). The canonical
+     * skill `message_start` swaps this row in place via
+     * {@link reconcileOptimisticSkillMessage}; a failed or bailed dispatch drops
+     * it via {@link clearOptimisticSkillMessage}.
+     */
+    renderOptimisticSkillMessage(message: AgentMessage, options?: {
+        imageLinks?: readonly (string | undefined)[];
+    }): void;
+    /** Replace the optimistic `/skill:` row with the canonical message emitted by
+     *  the session, mirroring {@link replaceOptimisticUserMessage} for skills. */
+    reconcileOptimisticSkillMessage(message: AgentMessage): void;
+    /** Drop the optimistic `/skill:` row when dispatch fails or bails before the
+     *  message reaches the agent (aborted preflight, streaming-race requeue). */
+    clearOptimisticSkillMessage(): void;
     startPendingSubmission(input: {
         text: string;
         images?: ImageContent[];

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

@@ -290,6 +290,16 @@ export interface InteractiveModeContext {
     replaceOptimisticUserMessage(message: AgentMessage, options?: {
         imageLinks?: readonly (string | undefined)[];
     }): void;
+    /** True while an optimistically-rendered `/skill:` row awaits its canonical `message_start`. */
+    optimisticSkillMessagePending: boolean;
+    /** Optimistically renders a user-invoked `/skill:` row before its awaited dispatch (issue #8895). */
+    renderOptimisticSkillMessage(message: AgentMessage, options?: {
+        imageLinks?: readonly (string | undefined)[];
+    }): void;
+    /** Swaps the optimistic `/skill:` row for the canonical message emitted by the session. */
+    reconcileOptimisticSkillMessage(message: AgentMessage): void;
+    /** Drops the optimistic `/skill:` row when dispatch fails or bails before reaching the agent. */
+    clearOptimisticSkillMessage(): void;
     isKnownSlashCommand(text: string): boolean;
     addMessageToChat(message: AgentMessage, options?: {
         populateHistory?: boolean;

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

@@ -630,6 +630,9 @@ export declare class AgentSession {
      *  changes (e.g. `/move` relocation) so the next replan refresh resolves
      *  against the destination project's override. */
     setTitleSystemPrompt(prompt: string | undefined): void;
+    /** Install the interactive title-download UI hook. Used when `/skill:` starts
+     *  titling from {@link promptCustomMessage} without the input-controller callback. */
+    setTitleGenerationStart(handler: (() => void) | undefined): void;
     /**
      * Abort current operation and wait for agent to become idle.
      *

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

@@ -19,8 +19,12 @@ export interface PrewalkCoordinatorHost {
         ephemeral?: boolean;
     }): Promise<void>;
     setActiveToolsByName(names: string[]): Promise<void>;
+    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[]): Promise<void>;
+    runToolRegistryMutation<T>(mutation: () => Promise<T>): Promise<T>;
     getActiveToolNames(): string[];
     getEnabledToolNames(): string[];
+    getSelectedMCPToolNames(): string[];
+    getMountedXdevToolNames(): string[];
     hasBuiltInTool(name: string): boolean;
     getPlanModeState(): PlanModeState | undefined;
     setPlanModeState(state: PlanModeState | undefined): void;

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

@@ -150,7 +150,6 @@ declare module "@oh-my-pi/pi-agent-core/compaction/entries" {
     interface CustomCompactionSessionEntries {
         titleChange: TitleChangeEntry;
         credentialPin: CredentialPinEntry;
-        resetBoundary: ResetBoundaryEntry;
     }
 }
 /** TTSR injection entry - tracks which time-traveling rules have been injected this session. */

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

@@ -200,6 +200,18 @@ export declare class SessionManager {
     getSessionDir(): string;
     getSessionId(): string;
     getSessionFile(): string | undefined;
+    /**
+     * Whether the current session has actually been materialized to durable
+     * storage (the JSONL exists on disk / in the active storage backend).
+     *
+     * Session persistence is lazy: the file is only written once the history
+     * contains an assistant message (or an explicit {@link ensureOnDisk}
+     * caller forces it). Until then {@link getSessionFile} returns an allocated
+     * path that leads nowhere, so a `--resume <id>` hint built from it would
+     * always fail. Consumers that advertise a resume command must gate on this
+     * (issue #8860).
+     */
+    isSessionOnDisk(): boolean;
     getArtifactsDir(): string | null;
     adoptArtifactManager(manager: ArtifactManager): void;
     getArtifactManager(): ArtifactManager | null;

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

@@ -9,6 +9,12 @@ interface PendingContextSnapshot {
     promptTokens: number;
     nonMessageTokens: number;
     cutoffCount: number;
+    /**
+     * Compaction epoch at rebase time. Distinguishes a genuinely fresh in-turn
+     * anchor (same epoch) from a post-cutoff anchor that predates a mid-run
+     * compaction (older epoch) so the latter never out-ranks this snapshot.
+     */
+    epoch: number;
 }
 /** Capabilities the stats tracker borrows from its owning session. */
 export interface SessionStatsTrackerHost {
@@ -36,6 +42,12 @@ export declare class SessionStatsTracker {
     }): ContextUsage | undefined;
     /** Monotonic revision for in-flight context snapshot changes. */
     get revision(): number;
+    /**
+     * Monotonic compaction epoch, bumped whenever history is compacted. Stamped
+     * onto each assistant snapshot at record time so {@link getContextBreakdown}
+     * can reject a post-cutoff anchor whose usage predates the last compaction.
+     */
+    get compactionEpoch(): number;
     /** Non-message token count captured for the active provider request. */
     get pendingNonMessageTokens(): number | undefined;
     /**
@@ -49,7 +61,7 @@ export declare class SessionStatsTracker {
      */
     recordAnchoredHistoryRewrite(tokensRemoved: number): void;
     /** Sets or clears the in-flight context snapshot. */
-    setPendingSnapshot(snapshot: PendingContextSnapshot | undefined): void;
+    setPendingSnapshot(snapshot: Omit<PendingContextSnapshot, "epoch"> | undefined): void;
     /** Recomputes an in-flight snapshot after history is compacted or rewritten. */
     rebaseAfterCompaction(): void;
     /** Records provider usage headers against the active session account. */

package/dist/types/session/skill-title-input.d.ts

@@ -0,0 +1,13 @@
+/** Compact title-model input for a user-invoked `/skill:<name>` prompt. */
+export declare function skillPromptTitleInput(input: {
+    name?: string;
+    args?: string;
+    queueChipText?: string;
+}): string;
+/** Title text for a persisted skill-prompt custom message. Never the expanded SKILL.md body. */
+export declare function titleTextFromSkillPrompt(message: {
+    role: string;
+    customType?: string;
+    attribution?: string;
+    details?: unknown;
+}): string | undefined;

package/dist/types/subprocess/worker-client.d.ts

@@ -89,10 +89,13 @@ export declare const SMOKE_TEST_TIMEOUT_MS = 30000;
 /**
  * Resolve the command used to relaunch the agent CLI into worker mode. In a
  * compiled binary the entry point is the binary itself; otherwise re-enter the
- * declared worker-host entry with a cwd-relative script path (Bun's subprocess
- * IPC is more reliable that way under `bun test`), falling back to this
- * package's own `src/cli.ts` when no host entry is declared (bun test, SDK
- * embedding).
+ * declared worker-host entry by absolute path. Workers deliberately spawn
+ * without a pinned cwd there: they share the parent's foreground process
+ * group, and terminal cwd heuristics (kitty's new_tab_with_cwd) read the
+ * newest process in that group, so anchoring them to the install dir leaks
+ * into newly opened terminal tabs. With no declared host entry (bun test, SDK
+ * embedding) fall back to a cwd-relative `src/cli.ts`, which Bun subprocess
+ * IPC handles more reliably under `bun test`.
  */
 export declare function resolveWorkerSpawnCmd(workerArg: string): WorkerSpawnCommand;
 /**

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

@@ -1,4 +1,6 @@
 import type { ModelRegistry } from "../config/model-registry.js";
 import type { Settings } from "../config/settings.js";
+/** True when a generated label is just the spawn handle, including `Name-2`. */
+export declare function labelEchoesHandle(handle: string | undefined, label: string): boolean;
 /** 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, signal?: AbortSignal): Promise<string | null>;

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

@@ -23,6 +23,8 @@ type TaskRenderOptions = RenderResultOptions & {
     renderContext?: TaskRenderContext;
 };
 export declare function formatTaskId(id: string): string;
+/** Dim `⟨agent⟩` badge for a non-default agent type; empty for the generic worker. */
+export declare function agentTypeBadge(agent: string | undefined, theme: Theme): string;
 /**
  * Render the tool call arguments.
  */

package/dist/types/tiny/completion-prompt.d.ts

@@ -0,0 +1,2 @@
+import type { TextGenerationPipeline } from "@huggingface/transformers";
+export declare function buildCompletionPrompt(tokenizer: TextGenerationPipeline["tokenizer"], promptText: string, systemPrompt?: string): string;

package/dist/types/tiny/title-client.d.ts

@@ -18,6 +18,11 @@ export interface TinyTitleGenerateOptions {
     signal?: AbortSignal;
     systemPrompt?: string;
 }
+export interface TinyModelCompletionOptions {
+    maxTokens?: number;
+    signal?: AbortSignal;
+    systemPrompt?: string;
+}
 /**
  * Hidden subcommand on the main CLI that boots the tiny-model worker in the
  * spawned subprocess. Kept in sync with the dispatch in `cli.ts`.
@@ -62,10 +67,7 @@ export declare class TinyTitleClient {
     prewarm(modelKey: string): void;
     generate(modelKey: string, message: string, signal?: AbortSignal): Promise<string | null>;
     generate(modelKey: string, message: string, options?: TinyTitleGenerateOptions): Promise<string | null>;
-    complete(modelKey: string, prompt: string, options?: {
-        maxTokens?: number;
-        signal?: AbortSignal;
-    }): Promise<string | null>;
+    complete(modelKey: string, prompt: string, options?: TinyModelCompletionOptions): Promise<string | null>;
     downloadModel(modelKey: string, options?: TinyTitleDownloadOptions): Promise<TinyTitleDownloadResult>;
     terminate(): Promise<void>;
 }

package/dist/types/tiny/title-protocol.d.ts

@@ -31,6 +31,7 @@ export type TinyTitleWorkerInbound = {
     modelKey: TinyLocalModelKey;
     prompt: string;
     maxTokens?: number;
+    systemPrompt?: string;
 } | {
     type: "download";
     id: string;

package/dist/types/tiny/worker.d.ts

@@ -1,2 +1,29 @@
+import type { ProgressInfo, TextGenerationPipeline, StoppingCriteria as TransformersStoppingCriteria } from "@huggingface/transformers";
+import { type TransformersRuntimeMetadata } from "../subprocess/worker-runtime.js";
+import { type TinyModelDevice } from "./device.js";
+import { type TinyModelDtype } from "./dtype.js";
 import type { TinyTitleTransport } from "./title-protocol.js";
+export interface TransformersRuntime extends TransformersRuntimeMetadata {
+    env: {
+        cacheDir?: string;
+        allowLocalModels?: boolean;
+        logLevel?: unknown;
+    };
+    LogLevel: {
+        ERROR: unknown;
+    };
+    StoppingCriteria: new () => TransformersStoppingCriteria;
+    pipeline: (task: "text-generation", model: string, options: {
+        device: TinyModelDevice;
+        dtype: TinyModelDtype;
+        progress_callback: (info: ProgressInfo) => void;
+    }) => Promise<TextGenerationPipeline>;
+}
+/** Stops generation at the first occurrence of `text` in the *generated* tokens.
+ *
+ *  The window must be anchored to the generation boundary, not to the end of the
+ *  whole sequence: a prompt that itself contains the stop string (chat-level
+ *  few-shot examples ending in `</title>`, for instance) would otherwise match on
+ *  prompt tokens and stop before the model emits anything. */
+export declare function createStopOnTextCriteria(transformers: TransformersRuntime, tokenizer: TextGenerationPipeline["tokenizer"], text: string): TransformersStoppingCriteria;
 export declare function startTinyTitleWorker(transport: TinyTitleTransport): void;

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

@@ -40,7 +40,7 @@ export declare function wrapShellLineForClientTerminal(line: string, shellConfig
  * while false positives remain actionable through user policy control.
  * New patterns should target shapes that are virtually never legitimate in automation.
  */
-export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const CRITICAL_BASH_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
 declare const bashSchemaBase: import("@oh-my-pi/omptype").FluentType<{
     command: string;
     cwd?: string | undefined;

package/dist/types/tools/read-format.d.ts

@@ -10,6 +10,12 @@ export interface HashlineHeaderContext {
 }
 export declare function formatReadHashlineHeader(displayPath: string, tag: string): string;
 export declare function readHashlineHeaderContext(session: ToolSession, absolutePath: string, cwd: string): Promise<HashlineHeaderContext>;
+/**
+ * {@link readHashlineHeaderContext} for a caller that already holds the file's
+ * full text, so the file is not reopened just to hash it. Line endings are
+ * normalized here, exactly as the reading variant does.
+ */
+export declare function hashlineHeaderContextForText(session: ToolSession, absolutePath: string, cwd: string, fullText: string): HashlineHeaderContext;
 export declare function hashlineHeaderContext(displayPath: string, tag: string): HashlineHeaderContext;
 export declare function prependHashlineHeader(text: string, context: HashlineHeaderContext | undefined): string;
 export declare function formatTextWithMode(text: string, startNum: number, shouldAddHashLines: boolean, shouldAddLineNumbers: boolean): string;

package/dist/types/tools/read-summary.d.ts

@@ -10,7 +10,13 @@ export declare function routeReadThroughBridge(session: ToolSession, absolutePat
     line?: number;
     limit?: number;
 }): Promise<string> | undefined;
-export declare function trySummarize(session: ToolSession, absolutePath: string, fileSize: number, signal?: AbortSignal): Promise<SummaryResult | null>;
+/**
+ * Structural summary of `absolutePath`, or `null` when the file is too large,
+ * too short, or unparseable. `diskText` lets a caller that already read the file
+ * hand those bytes over instead of forcing a second read; an ACP bridge still
+ * wins, since the editor's buffer is the source of truth.
+ */
+export declare function trySummarize(session: ToolSession, absolutePath: string, fileSize: number, signal?: AbortSignal, diskText?: string): Promise<SummaryResult | null>;
 export declare function renderSummary(session: ToolSession, summary: SummaryResult): {
     text: string;
     displayText: string;

package/dist/types/utils/block-context.d.ts

@@ -6,6 +6,20 @@ export interface LineSpan {
 export interface BlockContextSource {
     path?: string;
     lang?: string;
+    /**
+     * The whole source `fullLines` was split from, when the caller still holds it.
+     * Supplying it skips re-joining every line into a fresh whole-file string on
+     * the way to the parser. It MUST be the same content as `fullLines`; a
+     * differing trailing newline is the only tolerated variation, since it moves
+     * no node's line number.
+     *
+     * Every current supplier derives both from one buffer in the same breath, so
+     * the two cannot drift. Do NOT set it on a source object that is reused
+     * across two different line arrays — a before/after diff pair, say — because
+     * the boundary lines tree-sitter reports would then be indexed into the wrong
+     * array and surface off-by-N context rows.
+     */
+    text?: string;
 }
 export type LineEntry = {
     kind: "line";

package/dist/types/utils/fetch-timeout.d.ts

@@ -2,3 +2,18 @@
 export declare function withTimeoutSignal(timeoutMs: number, signal?: AbortSignal): AbortSignal;
 /** Detect a timeout raised by an abortable fetch. */
 export declare function isTimeoutError(error: unknown): boolean;
+/**
+ * Detect Bun's `UnsupportedProxyProtocol` fetch rejection, raised when a proxy
+ * env var (`HTTPS_PROXY`, `ALL_PROXY`, …) points at a scheme it cannot drive —
+ * most commonly a SOCKS proxy (`socks5://`, `socks5h://`). The raw error tells
+ * the caller to "pass `verbose: true` in the second argument to fetch()", which
+ * is meaningless from a CLI, so callers translate it into
+ * {@link unsupportedProxyMessage}.
+ */
+export declare function isUnsupportedProxyError(error: unknown): boolean;
+/**
+ * Build an actionable CLI message for an {@link isUnsupportedProxyError} failure,
+ * naming any set proxy env var whose scheme is not `http(s)://` so the user can
+ * see exactly which variable to change.
+ */
+export declare function unsupportedProxyMessage(env?: Record<string, string | undefined>): string;