@oh-my-pi/pi-coding-agent 17.2.3 → 17.2.5

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

@@ -6,7 +6,7 @@ export declare const DAEMON_BROKER_WORKER_ARG = "__omp_worker_daemon_broker";
 /** Fixed dimensions negotiated with every supervised PTY. */
 export declare const DAEMON_PTY_COLUMNS = 120;
 export declare const DAEMON_PTY_ROWS = 40;
-/** Environment key carrying the broker's canonical project directory. */
+/** Environment key carrying the broker's canonical project or synthetic global scope directory. */
 export declare const DAEMON_PROJECT_DIR_ENV = "OMP_DAEMON_PROJECT_DIR";
 /** Environment key carrying the broker's private runtime directory. */
 export declare const DAEMON_RUNTIME_DIR_ENV = "OMP_DAEMON_RUNTIME_DIR";
@@ -36,7 +36,7 @@ export interface DaemonSpec {
     persist: boolean;
     detached: boolean;
 }
-/** Serializable daemon state visible to every client in one project directory. */
+/** Serializable daemon state visible to every client in one broker scope. */
 export interface DaemonSnapshot {
     name: string;
     id: string;

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

@@ -1,4 +1,6 @@
 import type { LspClient, ServerConfig } from "./types.js";
+/** Enable or disable attaching to broker-shared language servers. */
+export declare function setSharedLspEnabled(enabled: boolean): void;
 /**
  * Configure the idle timeout for LSP clients.
  * @param ms - Timeout in milliseconds, or null/undefined to disable

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

@@ -0,0 +1,15 @@
+import type { LspTransport } from "../types.js";
+/**
+ * Open a broker-shared transport for one language server, ensuring the mux
+ * daemon first. Returns null (after a debug log) when the shared path is
+ * unavailable so the caller falls back to a process-local spawn.
+ */
+export declare function connectSharedLspTransport(opts: {
+    command: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+}): Promise<LspTransport | null>;
+/** Exercise worker-host mux startup and the ping handshake for distribution smoke tests. */
+export declare function smokeTestLspMux(): Promise<void>;

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

@@ -0,0 +1,57 @@
+/** Hidden CLI selector used to re-enter the LSP mux worker. */
+export declare const LSP_MUX_WORKER_ARG = "__omp_worker_lsp_mux";
+/** Environment key carrying the socket endpoint the mux must listen on. */
+export declare const LSP_MUX_SOCKET_ENV = "OMP_LSP_MUX_SOCKET";
+/** Environment key carrying the canonical project directory the mux serves. */
+export declare const LSP_MUX_PROJECT_DIR_ENV = "OMP_LSP_MUX_PROJECT_DIR";
+/** Stable broker daemon name for the shared LSP mux. */
+export declare const LSP_MUX_DAEMON_NAME = "omp.lsp.mux";
+/** Broker readiness regex matched against the banner printed by the worker. */
+export declare const LSP_MUX_READY_PATTERN: string;
+/** Banner printed on stdout once the mux socket accepts connections. */
+export declare function lspMuxReadyBanner(endpoint: string): string;
+/** Resolve the Unix socket or Windows named pipe for one project scope. */
+export declare function lspMuxEndpoint(projectDir: string, runtimeDir: string): string;
+/**
+ * First (and only pre-LSP) request on a fresh connection: binds the link to
+ * one shared server instance, spawning it on first use. Params:
+ * {@link MuxConnectParams}, result: {@link MuxConnectResult}. After the
+ * response the link carries ordinary LSP traffic for that server.
+ */
+export declare const MUX_CONNECT_METHOD = "omp/muxConnect";
+/**
+ * Liveness probe answered with {@link MUX_PING_RESULT} without binding the
+ * link to a server. Used by the smoke probe and the ensure loop.
+ */
+export declare const MUX_PING_METHOD = "omp/muxPing";
+export declare const MUX_PING_RESULT = "pong";
+/**
+ * Notification on a bound link: kill the shared server process (all sessions
+ * on it are disconnected). Sent by `lsp reload` when the generic reload path
+ * decides the server is wedged — a plain per-session `shutdown`/`exit` is
+ * intercepted by the mux and would leave the wedged server running for
+ * every other instance.
+ */
+export declare const MUX_RESTART_METHOD = "omp/muxRestartServer";
+/** Handshake parameters identifying (and if needed spawning) a shared server. */
+export interface MuxConnectParams {
+    /** Executable to spawn (the client's `resolvedCommand ?? command`). */
+    command: string;
+    /** Arguments passed verbatim to the executable. */
+    args: string[];
+    /** Workspace root the server runs in; part of the server identity key. */
+    cwd: string;
+    /** Extra environment overlaid on the mux daemon's own env for the spawn. */
+    env?: Record<string, string>;
+}
+/** Handshake result. */
+export interface MuxConnectResult {
+    /** Server identity key inside the mux (`${command}:${cwd}`). */
+    key: string;
+    /** True when this handshake spawned the server process. */
+    spawned: boolean;
+    /** Pid of the shared server process. */
+    pid?: number;
+}
+/** Server identity key used by the mux registry. */
+export declare function muxServerKey(command: string, cwd: string): string;

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

@@ -0,0 +1,18 @@
+/**
+ * Broker-owned, in-process-testable multiplexer for shared language-server children.
+ */
+export declare class LspMuxServer {
+    #private;
+    /** Called after the mux has had no connected sessions for its idle grace period. */
+    onIdle?: () => void;
+    /** Number of currently connected mux links, including unbound ping links. */
+    get sessionCount(): number;
+    /** Keys of currently live shared language-server children. */
+    get serverKeys(): string[];
+    /** Listen for Content-Length framed mux links at a Unix socket or named pipe. */
+    listen(endpoint: string): Promise<void>;
+    /** Gracefully close all children, links, and the listening endpoint. */
+    shutdown(): Promise<void>;
+}
+/** Start the detached LSP mux selected by the CLI worker host environment. */
+export declare function startLspMuxFromEnvironment(): Promise<void>;

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

@@ -1,4 +1,3 @@
-import type { ptree } from "@oh-my-pi/pi-utils";
 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;
@@ -229,6 +228,27 @@ export interface ServerConfig {
      */
     createClient?: LinterClientFactory;
 }
+/** Minimal write sink for the server-bound byte stream (satisfied by `Bun.FileSink` and the mux socket adapter). */
+export interface LspWriteSink {
+    write(data: string | Uint8Array): number | Promise<number>;
+    flush(): number | void | Promise<number | void>;
+}
+/**
+ * Byte transport carrying one LSP JSON-RPC link. Structurally satisfied by
+ * `ptree.ChildProcess<"pipe">` (local server spawn) and by the socket adapter
+ * in `mux/daemon.ts` (broker-shared server). `exited` may reject (ptree kill).
+ */
+export interface LspTransport {
+    readonly stdin: LspWriteSink;
+    readonly stdout: ReadableStream<Uint8Array>;
+    readonly exited: Promise<number>;
+    readonly exitCode: number | null;
+    readonly pid?: number;
+    /** Present and true on broker-shared mux links; `lsp reload` uses it to request a shared-server restart. */
+    readonly sharedMux?: boolean;
+    kill(): void;
+    peekStderr(): string;
+}
 export interface OpenFile {
     version: number;
     languageId: string;
@@ -257,7 +277,7 @@ export interface LspClient {
     name: string;
     cwd: string;
     config: ServerConfig;
-    proc: ptree.ChildProcess<"pipe">;
+    proc: LspTransport;
     requestId: number;
     diagnostics: Map<string, PublishedDiagnostics>;
     diagnosticsVersion: number;

package/dist/types/main.d.ts

@@ -13,6 +13,8 @@ import { type SessionInfo } from "./session/session-listing.js";
 import { SessionManager } from "./session/session-manager.js";
 type RunAcpMode = (createSession: AcpSessionFactory) => Promise<never>;
 export declare function writeStartupNotice(parsedArgs: Pick<Args, "mode">, text: string): void;
+/** Reads a non-TTY stdin stream as prompt text. */
+export declare function readPipedInput(): Promise<string | undefined>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;

package/dist/types/mcp/request-id.d.ts

@@ -0,0 +1,19 @@
+import type { MCPRequestIdFormat } from "./types.js";
+/**
+ * Per-transport allocator for outgoing JSON-RPC request ids.
+ *
+ * JSON-RPC 2.0 permits String and Number ids equally, but the wider MCP
+ * ecosystem (reference SDKs included) issues incrementing integers, so servers
+ * are best tested against numbers — Apple's `xcrun mcpbridge` even logs
+ * `mcpbridge.DecodeError Code=1` and never answers a string id. Integers are
+ * therefore the default. `"string"` opts a server back into collision-resistant
+ * snowflake ids.
+ *
+ * The counter is per instance and never reset, so ids stay unique for the life
+ * of the transport even though a reconnect rejects and clears every pending
+ * request.
+ */
+export declare class RequestIdAllocator {
+    #private;
+    next(format: MCPRequestIdFormat | undefined): string | number;
+}

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

@@ -43,12 +43,26 @@ export interface MCPAuthConfig {
     /** MCP resource URI — persisted for OAuth resource indicators during refresh */
     resource?: string;
 }
+/** Encoding used for outgoing JSON-RPC request ids. */
+export type MCPRequestIdFormat = "string" | "number";
 /** Base server config with shared options */
 interface MCPServerConfigBase {
     /** Whether this server is enabled (default: true) */
     enabled?: boolean;
     /** MCP request timeout in milliseconds (default: 30000, 0 to disable) */
     timeout?: number;
+    /**
+     * Encoding for outgoing JSON-RPC request ids (default: `"number"`).
+     *
+     * Set `"string"` for servers that need collision-resistant snowflake string
+     * ids instead of per-transport integers. See `RequestIdAllocator` in
+     * `./request-id`.
+     *
+     * OMP-specific, so only the OMP-owned discovery providers parse it (native,
+     * standalone `mcp.json`, OMP plugins). Providers that translate another
+     * tool's config do not, since the key is not part of those formats.
+     */
+    requestIdFormat?: MCPRequestIdFormat;
     /** Authentication configuration (optional) */
     auth?: MCPAuthConfig;
     /** OAuth configuration for servers requiring explicit client credentials */

package/dist/types/memory-backend/index.d.ts

@@ -1,6 +1,7 @@
 export type { MnemopiBackendConfig, MnemopiLlmMode, MnemopiProviderOptions, MnemopiScoping, } from "../mnemopi/config.js";
 export type { MnemopiMemoryEditOperation, MnemopiMemoryEditOptions, MnemopiMemoryEditResult, MnemopiSessionState, MnemopiSessionStateOptions, } from "../mnemopi/state.js";
 export * from "./local-backend.js";
+export * from "./messages.js";
 export * from "./off-backend.js";
 export * from "./resolve.js";
 export * from "./runtime.js";

package/dist/types/memory-backend/messages.d.ts

@@ -0,0 +1,15 @@
+import type { MemoryBackendId } from "./types.js";
+/**
+ * Fallback text for `/memory stats` and `/memory diagnose` when the active
+ * backend's hook is missing or returns nothing.
+ *
+ * The `off` backend isn't a real backend a user picked among several
+ * stats-capable options — it's the no-op state memory falls back to by
+ * default — so it gets its own message instead of the generic
+ * "not available for the X backend" template, which would otherwise read as
+ * the self-contradictory "not available for the off backend".
+ *
+ * Shared by both the TUI (`CommandController.handleMemoryCommand`) and the
+ * ACP/RPC slash-command handler so the two surfaces stay consistent.
+ */
+export declare function memoryStatsUnavailableMessage(backendId: MemoryBackendId, action: "stats" | "diagnose"): string;

package/dist/types/mnemopi/embed-client.d.ts

@@ -34,7 +34,7 @@ export interface MnemopiSubprocessEmbeddingModel {
 }
 export declare class MnemopiEmbedClient {
     #private;
-    constructor(spawnWorker?: () => MnemopiEmbedWorkerHandle);
+    constructor(spawnWorker?: () => MnemopiEmbedWorkerHandle, requestTimeoutMs?: number);
     /**
      * Load the named fastembed model inside the subprocess. Resolves to a
      * thin wrapper whose `embed()` round-trips through the same worker, or

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

@@ -162,29 +162,6 @@ export declare class MnemopiSessionState {
         extract?: boolean;
         sleep?: boolean;
     }): Promise<void>;
-    /**
-     * Release the per-session resources. Defaults to running a lighter
-     * {@link consolidate} pass before closing handles: it retains the current
-     * transcript and flushes in-flight extractions, but skips the synchronous
-     * bank sleep so normal session shutdown returns promptly. Full promotion of
-     * working memory into long-term storage is still performed by the explicit
-     * `/memory enqueue` and backend enqueue paths. Callers that are about to
-     * delete the DB files — e.g. `mnemopiBackend.clear` — pass
-     * `{ consolidate: false }` to skip the retain/flush pass, since spending
-     * tokens on memories that will be wiped on the next line is wasted work
-     * (PR #2327 review).
-     *
-     * `timeoutMs` caps how long the consolidate await blocks the caller
-     * (the user-visible `/quit` / `/exit` shutdown path passes this so
-     * dispose returns within a UX budget — issue #3641). When the cap is
-     * hit, dispose returns immediately and detaches the still-in-flight
-     * consolidate; the SQLite handles are closed in the background once
-     * the consolidate settles so writes never race a closed handle, and
-     * any pending embeddings are SIGKILL'd along with the embed worker
-     * (a tolerable loss — working memory rows are durable; only the
-     * episodic promotion / embedding for the LAST few turns is skipped,
-     * and `maybeRetainOnAgentEnd` has already retained earlier turns).
-     */
     dispose(options?: {
         consolidate?: boolean;
         timeoutMs?: number;

package/dist/types/modes/components/assistant-message.d.ts

@@ -63,6 +63,8 @@ export declare class AssistantMessageComponent extends Container {
     messagePersistenceKey(): string | undefined;
     /** Toggle rendering for assistant-native and tool-result images. */
     setImagesVisible(visible: boolean): void;
+    /** Toggle only images produced by tool results; assistant-native images remain governed by setImagesVisible. */
+    setToolResultImagesVisible(visible: boolean): void;
     setToolResultImages(toolCallId: string, images: ImageContent[]): void;
     updateContent(message: AssistantMessage, opts?: {
         transient?: boolean;

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

@@ -1,7 +1,7 @@
 import type { ImageContent } from "@oh-my-pi/pi-ai";
 import { Editor, type KeyId, TUI } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings.js";
-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">;
+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.tools.toggleVisibility" | "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;
@@ -141,6 +141,7 @@ export declare class CustomEditor extends Editor {
     onCycleModelBackward?: () => void;
     onSelectModel?: () => void;
     onExpandTools?: () => void;
+    onToggleToolActivity?: () => void;
     onToggleThinking?: () => void;
     onExternalEditor?: () => void;
     onHistorySearch?: () => void;

package/dist/types/modes/components/model-browser.d.ts

@@ -58,10 +58,10 @@ export declare function formatRoleChip(role: string, assignment: RoleAssignment,
 export interface ModelBrowserOptions {
     /** Render the dim `provider/` prefix before model ids. Default true. */
     showProvider?: boolean;
-    /** Session token count used to disable models whose context window is exceeded. */
+    /** Session token count used to flag models whose context window is exceeded. */
     currentContextTokens?: number;
-    /** When true, rows over the current context are unselectable (session-switch mode). */
-    disableOverContext?: boolean;
+    /** When true, over-context rows render grayed; picking one compacts first (session-switch mode). */
+    markOverContext?: boolean;
     /** Host-provided empty-state text (e.g. provider discovery status). */
     emptyText?: () => string | undefined;
 }
@@ -91,8 +91,8 @@ export declare class ModelBrowser implements Component {
     setShowProvider(show: boolean): void;
     /** Keep the source order after fuzzy filtering instead of applying model-specific ranking. */
     setPreserveQueryOrder(preserve: boolean): void;
-    /** Allow hosts to toggle context-window eligibility between browser modes. */
-    setDisableOverContext(disable: boolean): void;
+    /** Allow hosts to toggle context-window flagging between browser modes. */
+    setMarkOverContext(mark: boolean): void;
     /** Focused: accent cursor + selected-row background band. Unfocused: dim cursor, no band. */
     setFocused(focused: boolean): void;
     /** Total rendered height for the current `maxVisible` (host layout budgeting). */
@@ -103,6 +103,8 @@ export declare class ModelBrowser implements Component {
     get visibleCount(): number;
     /** Move selection to `selector`; false when it is not in the current view. */
     selectSelector(selector: string): boolean;
+    /** True when `item`'s context window is smaller than the live session token count (grayed row; hosts compact before switching). */
+    isOverContext(item: ModelBrowserItem): boolean;
     /**
      * Move the selection by `delta` rows, skipping disabled rows. Single steps
      * wrap at the ends; `wrap: false` (page/home/end jumps) clamps instead.

package/dist/types/modes/components/model-picker.d.ts

@@ -11,15 +11,21 @@ import type { Settings } from "../../config/settings.js";
 import type { ResolvedRoleModel } from "../../session/agent-session.js";
 import type { ScopedModelItem } from "./model-hub.js";
 export interface ModelPickerCallbacks {
-    /** A model was chosen for a session-only switch. `selector` is `provider/id`. */
-    onPick: (model: Model, selector: string) => void;
+    /**
+     * A model was chosen for a session-only switch. `selector` is `provider/id`.
+     * `overContext` is true when the session transcript exceeds the model's
+     * context window — the host must compact before switching.
+     */
+    onPick: (model: Model, selector: string, meta: {
+        overContext: boolean;
+    }) => void;
     /** A configured ctrl+p quick role was chosen. */
     onPickRole?: (entry: ResolvedRoleModel) => void;
     /** The picker was dismissed. */
     onCancel: () => void;
 }
 export interface ModelPickerOptions {
-    /** Session token count; models with smaller context windows are disabled. */
+    /** Session token count; models with smaller context windows are grayed and compact-first on pick. */
     currentContextTokens?: number;
     /** `provider/id` of the session's active model; highlighted and preselected. */
     currentSelector?: string;

package/dist/types/modes/components/read-tool-group.d.ts

@@ -27,6 +27,7 @@ type ReadToolGroupOptions = {
 export declare class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
     #private;
     constructor(options?: ReadToolGroupOptions);
+    render(width: number): readonly string[];
     isTranscriptBlockFinalized(): boolean;
     finalize(): void;
     /**
@@ -36,6 +37,15 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
      */
     seal(): void;
     updateArgs(args: ReadRenderArgs, toolCallId?: string): void;
+    /**
+     * Re-key an entry whose streamed tool-call id changed mid-stream (a provider
+     * rewriting the id across deltas; see EventController's
+     * `#streamedToolCallIdByIndex`). Preserves row order so a sibling read run is
+     * not visibly reshuffled, and no-ops when the rename would collide.
+     */
+    renameEntry(oldId: string, newId: string): void;
+    /** Remove one call without discarding successful siblings in the shared group. */
+    removeEntry(toolCallId: string): boolean;
     updateResult(result: {
         content: Array<{
             type: string;
@@ -51,6 +61,7 @@ export declare class ReadToolGroupComponent extends Container implements ToolExe
     attachUsage(toolCallIds: readonly string[], usage: Usage, durationMs?: number, ttftMs?: number, timestamp?: number): boolean;
     setArgsComplete(_toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
+    setToolActivityVisible(visible: boolean): void;
     getComponent(): Component;
 }
 export {};

package/dist/types/modes/components/stripped-tool-calls-placeholder.d.ts

@@ -0,0 +1,12 @@
+import { Text } from "@oh-my-pi/pi-tui";
+/**
+ * Dim transcript marker for tool calls stripped from the resolved branch
+ * (failed/retried turns, results on sibling branches). It is tool activity,
+ * so it hides and reappears with the `display.hideToolActivity` toggle.
+ */
+export declare class StrippedToolCallsPlaceholder extends Text {
+    #private;
+    constructor(strippedToolCalls: number, toolActivityVisible: boolean);
+    setToolActivityVisible(visible: boolean): void;
+    render(width: number): readonly string[];
+}

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

@@ -48,6 +48,7 @@ export interface ToolExecutionHandle extends Component {
     }, isPartial?: boolean, toolCallId?: string): void;
     setArgsComplete(toolCallId?: string): void;
     setExpanded(expanded: boolean): void;
+    setToolActivityVisible(visible: boolean): void;
     /** Freeze the block as final history: stop spinners and let it commit to scrollback. */
     seal(): void;
 }
@@ -139,6 +140,7 @@ export declare class ToolExecutionComponent extends Container implements NativeS
      */
     stopAnimation(): void;
     setExpanded(expanded: boolean): void;
+    setToolActivityVisible(visible: boolean): void;
     setShowImages(show: boolean): void;
     invalidate(): void;
     render(width: number): readonly string[];

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

@@ -66,6 +66,7 @@ export declare class InputController {
     cycleThinkingLevel(): void;
     cycleRoleModel(direction?: "forward" | "backward"): Promise<void>;
     toggleToolOutputExpansion(): void;
+    toggleToolActivityVisibility(): void;
     setToolsExpanded(expanded: boolean): void;
     toggleThinkingBlockVisibility(): void;
     openExternalEditor(): Promise<void>;

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

@@ -103,6 +103,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     initialChatRendered: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
+    hideToolActivity: boolean;
     todoExpanded: boolean;
     planModeEnabled: boolean;
     planModePaused: boolean;

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

@@ -141,6 +141,7 @@ export interface InteractiveModeContext {
     initialChatRendered: boolean;
     isBashMode: boolean;
     toolOutputExpanded: boolean;
+    hideToolActivity: boolean;
     todoExpanded: boolean;
     planModeEnabled: boolean;
     vibeModeEnabled: boolean;
@@ -331,7 +332,7 @@ export interface InteractiveModeContext {
     handlePythonCommand(code: string, excludeFromContext?: boolean): Promise<void>;
     handleMCPCommand(text: string): Promise<void>;
     handleSSHCommand(text: string): Promise<void>;
-    handleCompactCommand(customInstructions?: string, mode?: CompactMode): Promise<CompactionOutcome>;
+    handleCompactCommand(customInstructions?: string, mode?: CompactMode, beforeFlush?: (outcome: CompactionOutcome) => void | Promise<void>): Promise<CompactionOutcome>;
     handleHandoffCommand(customInstructions?: string): Promise<void>;
     handleShakeCommand(mode: ShakeMode): Promise<void>;
     handleMoveCommand(targetPath?: string): Promise<void>;

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

@@ -2,8 +2,9 @@ import { type KeywordHighlighter } from "./gradient-highlight.js";
 /** WORKFLOW_NOTICE is the default hidden notice for sessions with batched task calls enabled. */
 export declare const WORKFLOW_NOTICE: string;
 /** renderWorkflowNotice renders the workflow notice for the active task schema. */
-export declare function renderWorkflowNotice({ taskBatch }: {
+export declare function renderWorkflowNotice({ taskBatch, scoutAvailable, }: {
     taskBatch: boolean;
+    scoutAvailable?: boolean;
 }): string;
 /**
  * Whether `text` contains the standalone keyword "workflowz"

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

@@ -92,12 +92,21 @@ export declare class AgentLifecycleManager {
      */
     ensureLive(id: string): Promise<AgentSession>;
     /**
-     * Hard removal: dispose if live, unregister from registry, drop timers.
-     * When `expected` is given, only a ref matching it is released; a stale
-     * release can never take down a newer same-id ref. Returns true when a
-     * matching ref was released.
+     * Dispose if live and drop timers. When `expected` is given, only a ref
+     * matching it is released; a stale release can never take down a newer
+     * same-id ref. Returns true when a matching ref was released.
+     *
+     * By default the ref is unregistered (teardown / one-shot removal). Pass
+     * `tombstone: true` for an explicit kill: the ref is kept registered as a
+     * terminal `aborted` row (session detached) instead of being removed, so a
+     * later persisted-subagent scan (e.g. Agent Hub reopen) skips it via its
+     * `if (!registry.get(id))` guard rather than re-adopting the surviving
+     * on-disk transcript as a fresh `parked` row. Mirrors
+     * `finalizeSubagentLifecycle`'s genuine-kill path.
      */
-    release(id: string, expected?: AgentRefExpectation): Promise<boolean>;
+    release(id: string, expected?: AgentRefExpectation, options?: {
+        tombstone?: boolean;
+    }): Promise<boolean>;
     /** Teardown everything (process exit / main session dispose). */
     dispose(): Promise<void>;
 }

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

@@ -67,9 +67,10 @@ export declare class AgentRegistry {
     static resetGlobalForTests(): void;
     register(input: RegisterInput): AgentRef;
     /**
-     * Register a new id only when it is absent, or reuse the exact ref a parked
-     * revival was authorized to revive. A missing expected ref is a failed CAS:
-     * callers must never claim an id after its prior generation disappeared.
+     * Register a new id only when it is absent, or reuse the exact detached
+     * `parked` ref a revival was authorized to revive. A missing, replaced, or
+     * terminal expected ref is a failed CAS: delayed revivers must never claim an
+     * id after its prior generation disappeared or was hard-killed.
      */
     registerIfAvailable(input: RegisterInput, expected: AgentRef | null): AgentRef | undefined;
     setStatus(id: string, status: AgentStatus, expected?: AgentRefExpectation): boolean;

package/dist/types/sdk.d.ts

@@ -1,5 +1,5 @@
 import { Agent, type AgentOptions, type AgentTelemetryConfig, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { Effort, Model, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
+import type { Effort, Model, ServiceTier, SimpleStreamOptions } from "@oh-my-pi/pi-ai";
 import type { Dialect } from "@oh-my-pi/pi-ai/dialect";
 import { type Rule } from "./capability/rule.js";
 import { ModelRegistry } from "./config/model-registry.js";
@@ -61,6 +61,8 @@ export interface CreateAgentSessionOptions {
     thinkingLevel?: ConfiguredThinkingLevel;
     /** Hard ceiling on the session's thinking effort (e.g. a task spawn's `task.maxEffort`-capped hint); retry-fallback recovery re-clamps to it. */
     thinkingLevelCeiling?: Effort;
+    /** OpenAI service-tier override for this session. `null` omits `service_tier`. */
+    openAIServiceTier?: ServiceTier | null;
     /** Models available for cycling (Ctrl+P in interactive mode) */
     scopedModels?: Array<{
         model: Model;
@@ -349,7 +351,7 @@ export declare function discoverSkills(cwd?: string, _agentDir?: string, setting
  * Discover context files (AGENTS.md) walking up from cwd.
  * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
  */
-export declare function discoverContextFiles(cwd?: string, _agentDir?: string): Promise<Array<{
+export declare function discoverContextFiles(cwd?: string, _agentDir?: string, disabledExtensions?: string[]): Promise<Array<{
     path: string;
     content: string;
     depth?: number;

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

@@ -1,13 +1,11 @@
 import { type SecretEntry } from "./obfuscator.js";
 /**
- * Per-install secret key for the placeholder digest. Persisted under the agent
- * config directory and never sent to a provider, so model-visible placeholders
- * cannot be reversed by dictionary-hashing candidate secrets. Stable across
- * sessions so persisted transcripts deobfuscate consistently. Defaults to
- * `getAgentDir()` — the same directory `createAgentSession()` passes as
- * `agentDir` — so a caller relying on the default reads/writes the identical
- * key file live sessions use, per `~/.omp/agent/secret-placeholder.key` in
- * docs/secrets.md.
+ * Per-install secret key for the placeholder digest. Persisted under XDG state
+ * and never sent to a provider, so model-visible placeholders cannot be reversed
+ * by dictionary-hashing candidate secrets. Stable across sessions so persisted
+ * transcripts deobfuscate consistently. Defaults to `getSecretPlaceholderKeyPath()`
+ * — `$XDG_STATE_HOME/omp/secret-placeholder.key` (or `~/.omp/agent/secret-placeholder.key`
+ * without XDG), per docs/secrets.md.
  */
 export declare function getSecretPlaceholderKey(keyDir?: string): Promise<string>;
 /** Return an existing placeholder key for redaction without creating a new key file. */
@@ -33,7 +31,7 @@ export declare function collectEnvSecrets(): SecretEntry[];
  * API keys) that are NOT configured via secrets.yml or the environment. Without
  * these, such a token in a tool result falls through to pi-ai's irreversible
  * provider-boundary redaction (`[openai_token_redacted]`); the model then echoes
- * that placeholder into edit-tool `old_text`, which can never match the real
+ * that placeholder into edit-tool `old_string`, which can never match the real
  * bytes on disk (issue #6968). Routing the same shapes through the obfuscator
  * mints reversible keyed placeholders that `deobfuscateToolArguments` restores
  * before tool execution, keeping exact-match edits working while the credential

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

@@ -81,6 +81,8 @@ export interface AgentSessionConfig {
     agent: Agent;
     sessionManager: SessionManager;
     settings: Settings;
+    /** Whether the session spawn policy permits the read-only `scout` subagent. Defaults to true. */
+    scoutAllowedBySpawnPolicy?: boolean;
     /** Whether the caller explicitly requested yolo/auto-approve behavior for this session. */
     autoApprove?: boolean;
     /** Models to cycle through with Ctrl+P (from --models flag). */
@@ -213,7 +215,7 @@ export interface AgentSessionConfig {
     /**
      * Build the `replace`-mode `edit` a Cursor `pi_edit` frame needs, against the
      * advisor-scoped tool session. The advisor's ordinary instance follows the
-     * configured `edit.mode` and rejects the frame's `old_text`/`new_text` pairs.
+     * configured `edit.mode` and rejects the frame's `old_string`/`new_string` args.
      */
     advisorCreateEditTool?(): AgentTool | undefined;
     /**

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

@@ -610,7 +610,6 @@ export declare class AgentSession {
         selector?: string;
         thinkingLevel?: ThinkingLevel;
         persist?: boolean;
-        currentContextTokens?: number;
     }): Promise<{
         switched: boolean;
     }>;
@@ -1009,6 +1008,12 @@ export declare class AgentSession {
      * @returns the number of advisors active after the rebuild.
      */
     applyAdvisorConfigs(advisors: AdvisorConfig[], sharedInstructions: string | undefined): number;
+    /**
+     * Refresh the project context prompt advisor sessions run against after
+     * context files change on `/reload-plugins`. Rebuilds live advisor runtimes so
+     * they stop evaluating turns against stale `AGENTS.md` instructions.
+     */
+    setAdvisorContextPrompt(contextPrompt: string | undefined): void;
     /**
      * Whether the advisor setting is enabled for this session.
      */