@oh-my-pi/pi-coding-agent 17.3.5 → 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/stats-cli.d.ts

@@ -5,13 +5,8 @@
  */
 export interface StatsCommandArgs {
     port: number;
+    host: string;
     json: boolean;
     summary: boolean;
 }
-/**
- * Parse stats subcommand arguments.
- * Returns undefined if not a stats command.
- */
-export declare function parseStatsArgs(args: string[]): StatsCommandArgs | undefined;
 export declare function runStatsCommand(cmd: StatsCommandArgs): Promise<void>;
-export declare function printStatsHelp(): void;

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/commands/stats.d.ts

@@ -10,6 +10,10 @@ export default class Stats extends Command {
             description: string;
             default: number;
         };
+        host: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            description: string;
+            default: string;
+        };
         json: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             char: string;
             description: string;

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

@@ -52,10 +52,12 @@ export type SwitchSessionHandler = (sessionPath: string) => Promise<{
 }>;
 export type ShutdownHandler = () => void;
 /**
- * Emit `session_shutdown` and clear timers owned by an extension runner.
+ * Emit `session_shutdown`, dispose file-write-fallback registrations, and clear
+ * timers owned by an extension runner.
  *
- * Returns whether any shutdown handlers were present. Timer cleanup runs even
- * when a handler fails so extension background work cannot outlive its host.
+ * Returns whether any shutdown handlers were present. Fallback disposal and timer
+ * cleanup run even when a handler fails so extension background work — and a
+ * fallback bound to this session's context — cannot outlive its host.
  */
 export declare function emitSessionShutdownEvent(extensionRunner: ExtensionRunner | undefined): Promise<boolean>;
 export declare class ExtensionRunner {
@@ -115,6 +117,15 @@ export declare class ExtensionRunner {
      * leak into another's `ctx.cwd` by reading a shared global.
      */
     get cwd(): string;
+    /**
+     * Stable id of the session this runner serves. Read through `sessionManager`
+     * for the same reason as {@link cwd}: it is this session's own, never a
+     * process-global, so a subagent runner reports itself and not its parent.
+     *
+     * Used to attribute a denied file write or delete to the session that issued
+     * it, since the fallback registry those handlers live in is process-wide.
+     */
+    get sessionId(): string;
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext, mode?: ExtensionMode): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
@@ -218,6 +229,13 @@ export declare class ExtensionRunner {
      * firing against a disposed session).
      */
     clearManagedTimers(): void;
+    /**
+     * Remove every file write and delete fallback this runner installed into the
+     * process-wide registries. Called on session shutdown (and before reinstalling
+     * on a re-{@link initialize}) so a handler bound to a torn-down session's
+     * context can never fire for another session sharing this process.
+     */
+    disposeFileFallbacks(): void;
     createCommandContext(): ExtensionCommandContext;
     emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>>;
     emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined>;
@@ -259,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/extensibility/extensions/types.d.ts

@@ -33,6 +33,7 @@ import type { CustomMessage, CustomMessagePayload } from "../../session/messages
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager.js";
 import type { BashToolDetails, BashToolInput, GlobToolDetails, GlobToolInput, GrepToolDetails, GrepToolInput, ReadToolDetails, ReadToolInput, WriteToolInput } from "../../tools/index.js";
 import type { ApprovalMode } from "../../tools/approval.js";
+import type { FileDeleteFallbackHandler, FileWriteFallbackHandler } from "../../tools/file-write-fallback.js";
 import type { EventBus } from "../../utils/event-bus.js";
 import type { AgentEndEvent, AgentStartEvent, AutoCompactionEndEvent, AutoCompactionStartEvent, AutoRetryEndEvent, AutoRetryStartEvent, ContextEvent, GoalUpdatedEvent, RetryFallbackAppliedEvent, RetryFallbackSucceededEvent, SessionBeforeBranchEvent, SessionBeforeBranchResult, SessionBeforeCompactEvent, SessionBeforeCompactResult, SessionBeforeSwitchEvent, SessionBeforeSwitchResult, SessionBeforeTreeEvent, SessionBeforeTreeResult, SessionBranchEvent, SessionCompactEvent, SessionCompactingEvent, SessionCompactingResult, SessionEvent, SessionShutdownEvent, SessionStartEvent, SessionStopEvent, SessionStopEventResult, SessionSwitchEvent, SessionTreeEvent, TodoReminderEvent, ToolCallEventResult, ToolResultEventResult, TtsrTriggeredEvent, TurnEndEvent, TurnStartEvent } from "../shared-events.js";
 import type { SlashCommandInfo } from "../slash-commands.js";
@@ -834,6 +835,61 @@ export interface ExtensionAPI {
     on(event: "mcp_notification", handler: ExtensionHandler<McpNotificationEvent>): void;
     /** Register a tool that the LLM can call. */
     registerTool<TParams extends TSchema = TSchema, TDetails = unknown>(tool: ToolDefinition<TParams, TDetails>): void;
+    /**
+     * Register a fallback writer consulted when a native `write`/`edit` byte-write is
+     * denied with a permission error (`EPERM`/`EACCES`/`EROFS`). Every other write
+     * error is unaffected. Handlers run in registration order; the first one to
+     * resolve `true` counts as the bytes being durably on disk, and the native tool
+     * continues as if its own write had succeeded — including recording its file
+     * snapshot under the real destination path, so a later hashline `edit` on that
+     * path keeps working. Intended for a host embedding the agent inside a sandbox
+     * that denies direct filesystem writes but exposes a privileged write channel.
+     *
+     * A denial that `Bun.write` masks as `ENOENT` — a write into a directory the host
+     * may not create — also diverts here, with `req.dst`'s parent absent and the
+     * handler responsible for creating it.
+     *
+     * `req.dst` is symlink-RESOLVED: the path the failed write itself acted on, not
+     * the one the tool was given. A link anywhere in a lexical path redirects the
+     * bytes while still passing a prefix allowlist, so treat `req.dst` as
+     * authoritative. A destination that cannot be resolved is never brokered.
+     *
+     * Call this during extension load, like the other `register*` methods: handlers
+     * are installed when the runner initializes, so an extension that has registered
+     * none by then is skipped and a first registration made later never takes effect.
+     *
+     * The underlying registry is process-wide, so a handler may be consulted for a
+     * denied write from any session in the process, not only its own.
+     * `req.sessionId` names the session that issued the write and
+     * `ctx.sessionManager.getSessionId()` names the handler's own; compare them
+     * before prompting, because `ctx.ui` belongs to the latter. See
+     * `docs/extensions.md`.
+     */
+    registerFileWriteFallback(handler: FileWriteFallbackHandler): void;
+    /**
+     * Register a fallback deleter consulted when a native `edit`/`apply_patch` unlink is
+     * denied with a permission error (`EPERM`/`EACCES`/`EROFS`). Covers `edit`'s `REM`,
+     * the source side of a hashline `MV`, and `apply_patch`'s delete op. Return `true`
+     * once `dst` is gone from disk.
+     *
+     * A handler MUST remove `dst` with a plain unlink and MUST NOT fall back to a
+     * recursive removal. `unlink` on a directory reports `EPERM` on Darwin, so the seam
+     * checks the target before diverting — but when the target's own metadata is behind
+     * the same boundary that denied the unlink, which is the common sandbox case, that
+     * check cannot be resolved and `dst` may be a directory. `req.confirmedFile` says
+     * which situation the handler is in.
+     *
+     * `req.dst` resolves every component ABOVE the last, for the same reason the
+     * write seam resolves all of them; the last is left alone because `unlink`
+     * removes a link rather than its target, so `req.dst` may name a link.
+     *
+     * Separate from {@link registerFileWriteFallback} on purpose. A write handler
+     * brokers `req.content` to `req.dst`, so a delete request reaching it with no
+     * content invites brokering an empty write and truncating the file instead of
+     * removing it. Registering for deletes is therefore an explicit opt-in, and the
+     * same load-time and process-wide notes above apply.
+     */
+    registerFileDeleteFallback(handler: FileDeleteFallbackHandler): void;
     /** Register a custom command. */
     registerCommand(name: string, options: {
         description?: string;
@@ -1142,6 +1198,8 @@ export interface Extension {
     tools: Map<string, RegisteredTool<any, any>>;
     toolRegistrationListeners?: Set<ToolRegistrationListener>;
     assistantThinkingRenderers: AssistantThinkingRenderer[];
+    fileWriteFallbackHandlers: FileWriteFallbackHandler[];
+    fileDeleteFallbackHandlers: FileDeleteFallbackHandler[];
     messageRenderers: Map<string, MessageRenderer>;
     commands: Map<string, RegisteredCommand>;
     flags: Map<string, ExtensionFlag>;

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/slash-commands/helpers/stats-dashboard.d.ts

@@ -1,6 +1,7 @@
 export declare const DEFAULT_STATS_DASHBOARD_PORT = 3847;
 export interface StatsDashboardArgs {
     port: number;
+    host: string;
 }
 export interface StatsDashboardLaunchResult {
     url: string;

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>;