@oh-my-pi/pi-coding-agent 17.3.3 → 17.3.5

package/dist/types/config/model-discovery.d.ts

@@ -93,6 +93,8 @@ export declare function discoverLiteLLMModels(providerConfig: DiscoveryProviderC
  * URL (which ends in `/v1`) round-trips correctly.
  */
 export declare function discoverProxyModels(providerConfig: DiscoveryProviderConfig, ctx: DiscoveryContext): Promise<Model<Api>[]>;
+export declare function normalizeLlamaCppBaseUrl(baseUrl?: string): string;
+export declare function ensureLlamaCppV1BaseUrl(baseUrl: string): string;
 export declare function normalizeLiteLLMDiscoveryBaseUrl(baseUrl?: string): string;
 export declare function normalizeOpenAIModelsListBaseUrl(baseUrl?: string): string;
 export {};

package/dist/types/config/model-registry.d.ts

@@ -106,10 +106,15 @@ export declare class ModelRegistry {
      *
      * Side-effect-free and synchronous: a command-backed key (`!cmd`) counts as
      * configured by its presence alone — the program is NOT executed — and OAuth
-     * tokens are NOT refreshed (`authStorage.hasAuth`). This is what keeps the
+     * tokens are NOT refreshed (`authStorage.hasResolvableAuth`). This is what keeps the
      * model-switch pre-flight off the event loop's hot path; the real key
      * (command execution + OAuth refresh) is resolved lazily per request via
      * {@link ModelRegistry.resolver}.
+     *
+     * Cross-provider env aliases count here (`xai-oauth` can borrow `XAI_API_KEY`)
+     * so an explicit `xai-oauth/…` selector does not fail with "No API key".
+     * Default-model availability still uses {@link AuthStorage.hasAuth}, which
+     * ignores that alias so SuperGrok is not auto-selected from a paid key.
      */
     hasConfiguredAuth(model: Model<Api>): boolean;
     /**

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

@@ -6061,6 +6061,16 @@ export declare const SETTINGS_SCHEMA: {
         readonly type: "number";
         readonly default: 120000;
     };
+    readonly "extensionHandlers.toolCallTimeoutMs": {
+        readonly type: "number";
+        readonly default: 30000;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly group: "Extensions";
+            readonly label: "Tool Call Handler Timeout (ms)";
+            readonly description: "Positive finite active-work timeout for extension tool_call handlers; invalid values use 30000ms, and time awaiting OMP-owned dialogs does not count";
+        };
+    };
     readonly "dev.autoqa": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/debug/report-bundle.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Debug report bundle creation.
+ *
+ * Creates a .tar.gz archive with session data, logs, system info, and optional profiling data.
+ */
 import type { WorkProfile } from "@oh-my-pi/pi-natives";
 import type { CpuProfile, HeapSnapshot } from "./profiler.js";
 export interface ReportBundleOptions {
@@ -28,8 +33,8 @@ export interface DebugLogSource {
  *
  * Bundle contents:
  * - session.jsonl: Current session transcript
- * - artifacts/: Session artifacts directory
- * - subagents/: Subagent sessions + artifacts
+ * - artifacts/: Current session's artifacts subtree (recursive), including any
+ *   subagent session transcripts nested under it
  * - logs.txt: Recent log entries
  * - system.json: OS, arch, CPU, memory, versions
  * - env.json: Sanitized environment variables

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

@@ -63,6 +63,8 @@ export declare function loadExtensions(paths: string[], cwd: string, eventBus?:
 export interface DiscoverExtensionPathOptions {
     /** Include ambient native extensions, hooks, and installed plugins. */
     ambient?: boolean;
+    /** Include ambient hook factories. Disable for read-only catalog commands. */
+    includeAmbientHooks?: boolean;
 }
 export declare function discoverExtensionPaths(configuredPaths: string[], cwd: string, disabledExtensionIds?: string[], options?: DiscoverExtensionPathOptions): Promise<string[]>;
 /**

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

@@ -224,8 +224,8 @@ export declare class ExtensionRunner {
     /**
      * Emit a `tool_call` event to every subscribed extension before the tool executes.
      *
-     * Each handler is bounded by `extensionHandlerTimeoutMs` (default 30s). This
-     * matches the timeout policy already applied to `emitToolResult` and every
+     * Each handler is bounded by `extensionHandlers.toolCallTimeoutMs` (default
+     * 30s). This matches the timeout policy already applied to `emitToolResult` and every
      * other handler routed through `#runHandlerWithTimeout`; without it a single
      * hung extension (unresolved `await`, network call with no timeout) would
      * park `ExtensionToolWrapper.execute` indefinitely and freeze tool
@@ -236,7 +236,7 @@ export declare class ExtensionRunner {
      * pre-execution gate — an unresponsive extension MUST NOT be treated as
      * silent consent to run the tool.
      */
-    emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined>;
+    emitToolCall(event: ToolCallEvent, signal?: AbortSignal): Promise<ToolCallEventResult | undefined>;
     emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined>;
     emitUserPython(event: UserPythonEvent): Promise<UserPythonEventResult | undefined>;
     private emitUserEvent;

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

@@ -138,6 +138,8 @@ export interface ExtensionCustomOptions {
     overlayOptions?: OverlayOptions | (() => OverlayOptions);
     /** Invoked with the overlay handle once the overlay is created (overlay mode only). */
     onHandle?: (handle: OverlayHandle) => void;
+    /** Abort the custom UI and reject its promise. */
+    signal?: AbortSignal;
 }
 /** Wrap the current autocomplete provider with additional behavior (pi-compatible). */
 export type AutocompleteProviderFactory = (current: AutocompleteProvider) => AutocompleteProvider;

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

@@ -59,6 +59,10 @@ export declare const getModels: typeof getBundledModels;
  *
  * Legacy `/compat` callers pass {@link SimpleStreamOptions}; routing through
  * `streamSimple` preserves option normalization before provider dispatch.
+ *
+ * Transient-failure retry (overload, rate-limit, 5xx) is the **caller's
+ * responsibility**. Oneshot callers that collect the full result before acting
+ * should wrap with `retryTransientCompletion` from `@oh-my-pi/pi-ai`.
  */
 export declare function streamSimpleOpenAIResponses(model: Model<"openai-responses">, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
 /**

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

@@ -6,3 +6,14 @@ export interface DaemonProjectPresence {
 export declare function registerDaemonProjectPresence(projectDir: string, runtimeOverride?: string): Promise<DaemonProjectPresence>;
 /** Return whether a registered omp process in this runtime directory is still alive. */
 export declare function hasLiveDaemonProjectPresence(runtimeDir: string): Promise<boolean>;
+/**
+ * Remove sibling project daemon runtime directories whose broker is dead and
+ * whose client-presence set is empty, reclaiming the disk that short-lived
+ * project directories leave behind (issue #8674).
+ *
+ * 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.
+ */
+export declare function pruneDeadDaemonRuntimeDirs(currentRuntimeDir: string): Promise<void>;

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

@@ -6,6 +6,21 @@ export declare function setSharedLspEnabled(enabled: boolean): void;
  * @param ms - Timeout in milliseconds, or null/undefined to disable
  */
 export declare function setIdleTimeout(ms: number | null | undefined): void;
+/**
+ * Whether a client may be reaped by the idle checker.
+ *
+ * A client with in-flight requests is *busy*, never idle. `lastActivity` is
+ * stamped when a request is written, not while it is outstanding, so a single
+ * request that runs longer than the idle timeout used to look like silence:
+ * the checker tore the client down mid-flight and `shutdownClientInstance`
+ * rejected the caller's still-pending promise with "LSP client shutdown"
+ * (issue #8390). Requests that settle refresh `lastActivity`, so a client
+ * becomes eligible again only after the final one lands and the full idle
+ * window then elapses.
+ *
+ * Exported for tests; the idle checker is the only production caller.
+ */
+export declare function isIdleClient(client: LspClient, now: number, timeoutMs: number): boolean;
 /** LSP `FileChangeType` values for workspace/didChangeWatchedFiles notifications. */
 export declare enum FileChangeType {
     Created = 1,
@@ -30,6 +45,13 @@ export declare function applyWorkspaceEditWithLsp(edit: WorkspaceEdit, cwd: stri
 export declare function supportsDocumentDiagnostics(client: LspClient): boolean;
 /** Timeout for warmup initialize requests (5 seconds) */
 export declare const WARMUP_TIMEOUT_MS = 5000;
+/**
+ * True when this client speaks the rust-analyzer protocol, detected by the
+ * command basename (`rust-analyzer[.exe]`) of the configured or resolved
+ * binary. Callers use it to gate rust-analyzer-only requests such as
+ * `rust-analyzer/reloadWorkspace` (see {@link reloadServer}).
+ */
+export declare function isRustAnalyzerClient(client: LspClient): boolean;
 /** Allow an explicit user reload to retry a matching initialization failure immediately. */
 export declare function clearInitializationFailure(config: ServerConfig, cwd: string): void;
 /**

package/dist/types/lsp/workspace-diagnostics.d.ts

@@ -4,6 +4,8 @@ interface ProjectType {
     command?: string[];
     description: string;
 }
+/** Interpret an empty checker result without mistaking a crash for a clean workspace. */
+export declare function interpretEmptyDiagnosticsResult(exitCode: number, signalCode: string | null, command: readonly string[]): string;
 /** Run workspace diagnostics command and parse output */
 export declare function runWorkspaceDiagnostics(cwd: string, signal?: AbortSignal): Promise<{
     output: string;

package/dist/types/markit/converters/pdf/index.d.ts

@@ -1,6 +1,7 @@
 import type { ConversionResult, Converter, StreamInfo } from "../../types.js";
+/** Converts PDF buffers to Markdown through the native `pdf-inspector` bridge. */
 export declare class PdfConverter implements Converter {
     name: string;
     accepts(streamInfo: StreamInfo): boolean;
-    convert(input: Buffer, streamInfo: StreamInfo): Promise<ConversionResult>;
+    convert(input: Buffer, _streamInfo: StreamInfo): Promise<ConversionResult>;
 }

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

@@ -50,7 +50,9 @@ export interface ExaFilterResult {
 }
 /**
  * Filter out Exa MCP servers and extract their API keys.
- * Since we have native Exa integration, we don't need the MCP server.
+ * Since we have native Exa integration, we don't need the MCP server —
+ * unless the config explicitly requests Exa tools the native integration
+ * does not provide (e.g. `web_fetch_exa`, `web_search_advanced_exa`).
  */
 export declare function filterExaMCPServers(configs: Record<string, MCPServerConfig>, sources: Record<string, SourceMeta>): ExaFilterResult;
 /**

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

@@ -119,8 +119,10 @@ export declare class ToolExecutionComponent extends Container implements NativeS
      * Reports `false` while it can still visually change so the
      * {@link TranscriptContainer} keeps it inside the repaintable live region:
      * a foreground tool awaiting its result, or one streaming partial output.
+     * Hidden blocks render no rows, so they cannot gate later streaming content.
+     * Visibility toggles reset and replay the transcript before revealing them.
      * A final (non-partial) result, a background-async tool the agent has moved
-     * past, or an explicit {@link seal} flips it to `true`.
+     * past, or an explicit {@link seal} also flips it to `true`.
      */
     isTranscriptBlockFinalized(): boolean;
     /**

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

@@ -58,6 +58,17 @@ export declare class AgentLifecycleManager {
     adopt(id: string, opts: AdoptOptions, expected?: AgentRefExpectation): void;
     /** True if the id is adopted (parked or live) — and, when `expected` is given, still bound to that ref. */
     has(id: string, expected?: AgentRefExpectation): boolean;
+    /**
+     * Reclaim a provably-dead parked corpse so a fresh spawn can reuse its id.
+     * Refuses live, adopted, in-flight, or cold-revivable refs. For a parked ref
+     * restored from disk, the persisted factory is consulted before removal
+     * because cold revivers are created lazily by {@link ensureLive}.
+     *
+     * Only refs in the registry this manager owns are touched; the transcript
+     * stays readable at `history://<id>`. Returns true when the corpse was
+     * unregistered.
+     */
+    reclaimDeadCorpse(id: string, expected: AgentRef): Promise<boolean>;
     /**
      * True when this manager owns `registry` — i.e. its adopt/park/revive state
      * describes that registry's refs. Lets a caller holding a specific registry

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

@@ -145,6 +145,10 @@ export declare class AgentRegistry {
      * Flat namespace: every other agent is visible.
      */
     listVisibleTo(id: string): AgentRef[];
+    /** Whether a ref's claimed running state is corroborated by its attached live session. */
+    isRunning(ref: AgentRef): boolean;
+    /** Mirror a session's authoritative run-state notifications into its owned registry ref. */
+    syncSessionStatus(id: string, session: AgentSession): () => void;
     onChange(listener: RegistryListener): () => void;
 }
 export {};

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

@@ -185,8 +185,6 @@ export interface AgentSessionConfig {
         systemPrompt: string[];
         xdevCatalogNames?: readonly string[];
     }>;
-    /** Local calendar date provider used by prompt-cache invalidation. */
-    getLocalCalendarDate?: () => string;
     /** Tools mounted under `xd://`, for `/tools` display. */
     getXdevToolEntries?: () => Array<{
         name: string;

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

@@ -182,6 +182,11 @@ export declare class AgentSession {
      * Multiple listeners can be added. Returns unsubscribe function for this listener.
      */
     subscribe(listener: AgentSessionEventListener): () => void;
+    /**
+     * Observe authoritative run-state transitions before public `agent_end`
+     * deferral, for lifecycle owners that must not remain stale while prompts unwind.
+     */
+    subscribeRunState(listener: (state: "running" | "idle") => void): () => void;
     /** Register cleanup that runs when this AgentSession adopts a different session ID. */
     registerSessionChangeCallback(callback: () => void): () => void;
     subscribeCommandMetadataChanged(listener: CommandMetadataChangedListener): () => void;
@@ -522,6 +527,21 @@ export declare class AgentSession {
      * flipping advisor auto-resume.
      */
     followUp(text: string, images?: ImageContent[], options?: FollowUpOptions): Promise<void>;
+    /**
+     * Run a mode-exit `teardown` (abort the active turn, swap the toolset, clear
+     * mode state) with queued-message auto-resume suppressed, then re-arm the
+     * drain so a queued user turn resumes cleanly once the previous toolset is
+     * back.
+     *
+     * `abort()`'s stranded-queue drain runs from its own `finally`; without this
+     * guard a queued steer/follow-up behind the aborted turn would start a fresh
+     * `agent.continue()` during the teardown's `await`s — while the exiting mode's
+     * tools/context are still live — and then have those tools removed underneath
+     * it, reintroducing the mode's stale-tool failure on the restarted turn
+     * (issue #8326). Suppressing the drain across teardown guarantees the queued
+     * turn resumes only after teardown, so it runs as a clean non-mode turn.
+     */
+    runModeExitTeardown(teardown: () => Promise<void>): Promise<void>;
     queueDeferredMessage(message: CustomMessage): void;
     queueLaunchCompletion(notification: DaemonCompletionNotification): Promise<void>;
     /**

package/dist/types/session/date-cwd-reminder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Date/cwd reminder injection.
+ *
+ * The system prompt must stay byte-stable so open-weight chat templates that
+ * render tool schemas *after* the system content keep their prefix cache
+ * (#7404). The per-request date/cwd line used to live at the tail of the
+ * system prompt (`project-prompt.md`), which invalidated the whole tool array
+ * on every directory change or day rollover. It now rides on the first user
+ * turn of each provider request instead: built at request time (never stored
+ * in the session), deterministic per `(date, cwd)`, so the bytes are stable
+ * for the lifetime of a session/day and refresh automatically at midnight.
+ */
+import type { Context, Message } from "@oh-my-pi/pi-ai";
+/** Renders the reminder text for the given local calendar date and cwd. */
+export declare function renderDateCwdReminder(date: string, cwd: string): string;
+export declare function injectDateCwdReminder(messages: Message[], reminder: string): Message[];
+/**
+ * Applies the date/cwd reminder to a provider `Context`, keeping the system
+ * prompt byte-stable for prompt caching. Skips NULL_PROMPT-style contexts
+ * (empty system prompt) so a no-prompt session stays byte-for-byte unchanged.
+ */
+export declare function withDateCwdReminder(context: Context, date: string, cwd: string): Context;

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

@@ -30,6 +30,8 @@ export declare class IrcBridge {
     hasPending(): boolean;
     /** Takes every queued IRC record in interrupt-before-aside order. */
     drainPending(): CustomMessage[];
+    /** Queues records whose idle wake must wait for a session transition to finish. */
+    deferWake(records: CustomMessage[]): void;
     /** Surfaces and consumes queued incoming records before automatic injection. */
     drainInboxMessages(agentId: string, opts?: {
         from?: string;

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

@@ -47,6 +47,8 @@ export type CustomMessagePayload<T = unknown> = string | Partial<Pick<CustomMess
 export type NormalizedCustomMessagePayload<T = unknown> = Pick<CustomMessage<T>, "customType" | "content" | "display" | "details" | "attribution">;
 /** Custom message type for hidden interrupted-thinking continuity context. */
 export declare const INTERRUPTED_THINKING_MESSAGE_TYPE = "interrupted-thinking";
+/** Custom message type for the transient checkpoint-active reminder. */
+export declare const CHECKPOINT_ACTIVE_REMINDER_TYPE = "checkpoint-active-reminder";
 /** Metadata persisted with a hidden interrupted-thinking continuity message. */
 export interface InterruptedThinkingDetails {
     interruptedAt: number;
@@ -288,6 +290,8 @@ export declare function bashExecutionToText(msg: BashExecutionMessage): string;
  */
 export declare function pythonExecutionToText(msg: PythonExecutionMessage): string;
 export declare function sanitizeRehydratedOpenAIResponsesAssistantMessage(message: AssistantMessage): AssistantMessage;
+/** True for a `/skill:<name>` prompt the user invoked directly (attribution `user`), as opposed to an agent/autoload injection. */
+export declare function isUserInvokedSkillPrompt(message: CustomMessage): boolean;
 /**
  * Transform AgentMessages (including custom types) to LLM-compatible Messages.
  *

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

@@ -1,6 +1,6 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { BlobStore } from "./blob-store.js";
-import { type FileEntry, type SessionTitleSlotEntry } from "./session-entries.js";
+import type { FileEntry } from "./session-entries.js";
 import { type SessionStorage } from "./session-storage.js";
 import { type SessionTitleUpdate } from "./session-title-slot.js";
 export interface VisitEntriesFromFileStreamOptions {
@@ -12,25 +12,32 @@ export interface VisitEntriesFromFileStreamOptions {
     yieldEveryBytes?: number;
     /** Yield to the macrotask queue after this many entries have been visited. */
     yieldEveryEntries?: number;
+    /** Called once for every malformed JSONL record skipped by the stream. */
+    onMalformedRecord?: () => void;
 }
-/** Parse session JSONL while stripping and folding the optional fixed title slot. */
-export declare function parseSessionContent(content: string): {
+/** Parsed session entries plus corruption metadata needed by writable loaders. */
+export interface SessionLoadResult {
     entries: FileEntry[];
     titleSlot: SessionTitleUpdate | undefined;
-};
+    malformedRecords: number;
+}
+/** Parse session JSONL while stripping and folding the optional fixed title slot. */
+export declare function parseSessionContent(content: string): SessionLoadResult;
 /** Parse session JSONL and visit each entry without retaining prior entries. */
 export declare function visitEntriesFromFileStream(filePath: string, visit: (entry: FileEntry) => void | boolean, options?: VisitEntriesFromFileStreamOptions): Promise<SessionTitleUpdate | undefined>;
 /** Exported for testing — the ≥8MiB streaming path (works on any file size). */
-export declare function loadEntriesFromFileStream(filePath: string): Promise<{
-    entries: FileEntry[];
-    titleSlot: SessionTitleUpdate | undefined;
-}>;
-/** Read only the fixed-size head window to detect a physical title slot. */
-export declare function readTitleSlotFromFile(filePath: string, storage?: SessionStorage): Promise<SessionTitleSlotEntry | undefined>;
+export declare function loadEntriesFromFileStream(filePath: string): Promise<SessionLoadResult>;
 /** Exported for compaction.test.ts */
 export declare function parseSessionEntries(content: string): FileEntry[];
-/** Exported for testing */
+/** Load and validate a session while retaining malformed-record diagnostics. */
+export declare function loadSessionFile(filePath: string, storage?: SessionStorage): Promise<SessionLoadResult>;
+/** Load the valid entries from a session file, skipping malformed records. */
 export declare function loadEntriesFromFile(filePath: string, storage?: SessionStorage): Promise<FileEntry[]>;
+/**
+ * Visit session entries, using bounded streaming for large file-backed journals.
+ * Small files and non-file backends keep the existing full-load path.
+ */
+export declare function visitEntriesFromFile(filePath: string, visit: (entry: FileEntry) => void | boolean, storage?: SessionStorage): Promise<void>;
 export declare function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void>;
 /**
  * Read-only transcript view of a session file: load entries, migrate to the

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

@@ -52,7 +52,9 @@ export interface SessionMaintenanceHost {
     planReferencePath(): string;
     nonMessageTokenSource(): NonMessageTokenSource;
     memoryBackendSession(): MemoryBackendOperationContext["session"];
-    emitSessionEvent(event: AgentSessionEvent): Promise<void>;
+    emitSessionEvent(event: AgentSessionEvent, options?: {
+        detachExtensions?: boolean;
+    }): Promise<void>;
     emitNotice(level: "info" | "warning" | "error", message: string, source?: string): void;
     schedulePostPromptTask(task: (signal: AbortSignal) => Promise<void>, options?: {
         delayMs?: number;
@@ -104,7 +106,7 @@ export interface SessionMaintenanceHost {
     }>;
     runHandoff(customInstructions?: string, options?: SessionHandoffOptions): Promise<HandoffResult | undefined>;
     removeAssistantMessageFromActiveContext(message: AssistantMessage): void;
-    dropPersistedAssistantTurn(message: AssistantMessage): Promise<void>;
+    dropPersistedAssistantTurn(message: AssistantMessage): Promise<string | undefined>;
     runRecoveryCompactionWithRollback(reason: "overflow" | "incomplete", message: AssistantMessage, allowDefer: boolean, options: {
         autoContinue: boolean;
         triggerContextTokens?: number;
@@ -261,6 +263,8 @@ export declare class SessionMaintenance {
         suppressHandoff?: boolean;
         phase?: CodexCompactionContext["phase"];
         terminalTextAnswer?: boolean;
+        /** Mid-turn: splice history then return; do not await UI/extension fan-out. */
+        detachPostCommit?: boolean;
     }): Promise<CompactionCheckResult>;
     /**
      * Toggle auto-compaction setting.

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

@@ -7,6 +7,8 @@ import { type BuildSessionContextOptions, type SessionContext } from "./session-
 import { type NewSessionOptions, type SessionEntry, type SessionHeader, type SessionTitleSource, type SessionTreeNode, type UsageStatistics } from "./session-entries.js";
 import { type SessionInfo } from "./session-listing.js";
 import { type SessionStorage } from "./session-storage.js";
+/** Copy a session's artifact directory to another session, matching interactive `/fork`. */
+export declare function copySessionArtifacts(sourceSessionFile: string, destinationSessionFile: string): Promise<void>;
 export type ReadonlySessionManager = Pick<SessionManager, "getCwd" | "getSessionDir" | "getSessionId" | "getSessionFile" | "getSessionName" | "getArtifactsDir" | "getArtifactManager" | "allocateArtifactPath" | "saveArtifact" | "getArtifactPath" | "getLeafId" | "getLeafEntry" | "getEntry" | "getLabel" | "getBranch" | "getHeader" | "getEntries" | "getTree" | "getUsageStatistics" | "putBlob" | "putBlobSync">;
 interface SessionManagerStateSnapshot {
     cwd: string;
@@ -213,6 +215,8 @@ export declare class SessionManager {
     get titleSource(): SessionTitleSource | undefined;
     getSessionName(): string | undefined;
     onSessionNameChanged(cb: () => void): () => void;
+    /** Subscribe to persistence failures so hosts can surface lost-durability state. */
+    onPersistenceError(cb: (error: Error) => void): () => void;
     /**
      * Set the session display name.
      * @param source "user" for explicit renames; "auto" for generated titles.
@@ -355,6 +359,17 @@ export declare class SessionManager {
     branch(branchFromId: string): void;
     /** Reset the leaf to null so the next append creates a new root entry. */
     resetLeaf(): void;
+    /**
+     * Durably move the active branch past a discarded entry.
+     *
+     * The loader reconstructs the active branch from the last physical journal
+     * entry, so changing the in-memory leaf alone is lost on reload. Known
+     * metadata children are chained onto the discarded entry's parent before the
+     * entry is removed. If any child may carry content, the subtree is preserved
+     * off-branch instead. Both paths append a metadata-only branch marker and
+     * rewrite the journal, making the selected path durable.
+     */
+    discardEntryDurably(entryId: string): Promise<void>;
     /** Like branch(), but also records a branch_summary of the abandoned path. */
     branchWithSummary(branchFromId: string | null, summary: string, details?: unknown, fromExtension?: boolean): string;
     /**
@@ -382,11 +397,12 @@ export declare class SessionManager {
      * session file while creating a fresh session file in this sessionDir.
      *
      * `options.sessionFile` pins the new session's file path (default: an
-     * auto-named `<timestamp>_<id>.jsonl` in `sessionDir`). Callers that register
-     * the fork as a named agent (e.g. `/tan`) pass `<agentId>.jsonl` so the
-     * persisted-subagent scan keys the agent by the same id the live ref uses.
+     * auto-named `<timestamp>_<id>.jsonl` in `sessionDir`). Artifacts are copied
+     * recursively by default; nested agents that deliberately share their parent's
+     * artifact root may disable this with `copyArtifacts: false`.
      */
     static forkFrom(sourcePath: string, cwd: string, sessionDir?: string, storage?: SessionStorage, options?: {
+        copyArtifacts?: boolean;
         suppressBreadcrumb?: boolean;
         sessionFile?: string;
     }): Promise<SessionManager>;

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

@@ -56,7 +56,6 @@ interface SessionToolsOptions {
         systemPrompt: string[];
         xdevCatalogNames?: readonly string[];
     }>;
-    getLocalCalendarDate?: () => string;
     getMcpServerInstructions?: () => Map<string, string> | undefined;
     xdev?: XdevState;
     setActiveToolNames?: (names: Iterable<string>) => void;

package/dist/types/session/turn-recovery.d.ts

@@ -129,8 +129,8 @@ export declare class TurnRecovery {
     handleEmptyAssistantStop(message: AssistantMessage): Promise<"continue" | "terminal" | undefined>;
     /** Classifies suspicious terminal stops and schedules bounded recovery. */
     handleUnexpectedAssistantStop(message: AssistantMessage): Promise<boolean>;
-    /** Removes a persisted failed assistant turn after its persistence slot settles. */
-    dropPersistedAssistantTurn(message: AssistantMessage): Promise<void>;
+    /** Removes a persisted failed assistant turn after its persistence slot settles; returns the dropped branch entry id. */
+    dropPersistedAssistantTurn(message: AssistantMessage): Promise<string | undefined>;
     /** Runs recovery compaction and restores the failed turn when no rewrite occurs. */
     runRecoveryCompactionWithRollback(reason: "overflow" | "incomplete", message: AssistantMessage, allowDefer: boolean, options: {
         autoContinue: boolean;
@@ -174,7 +174,7 @@ export declare class TurnRecovery {
      * the Gemini header-runaway interrupt, which must not replay a partial,
      * loop-fueling thinking block.
      */
-    discardAssistantTurn(assistantMessage: AssistantMessage): void;
+    discardAssistantTurn(assistantMessage: AssistantMessage): string | undefined;
     /**
      * Retry an empty, reason-less provider abort: a turn with no content that
      * carries the generic sentinel (bare `abort()`), whether the provider
@@ -198,10 +198,10 @@ export declare class TurnRecovery {
      */
     isRetryableError(message: AssistantMessage): boolean;
     /**
-     * Classify a reasonless abort or stream stall whose emitted tool calls all
-     * have results. The failed assistant/tool-result pair stays in context so
-     * continuation cannot replay completed side effects; synthetic results tell
-     * the next turn that an unexecuted call must be reissued.
+     * Classify a reasonless abort, idle stream stall, or HTTP/2 stream reset whose
+     * emitted tool calls all have results. The failed assistant/tool-result pair
+     * stays in context so continuation cannot replay completed side effects;
+     * synthetic results tell the next turn that an unexecuted call must be reissued.
      */
     classifyResolvedInterruptedToolTurn(message: AssistantMessage): "reasonless-abort" | "stream-stall" | undefined;
     /** Checks whether a provider error represents a classifier refusal. */

package/dist/types/tools/browser/attach.d.ts

@@ -5,6 +5,22 @@ import type { Browser, Page } from "puppeteer-core";
  * subsequent bind in the launched app, but Chromium's listener will retry.
  */
 export declare function findFreeCdpPort(): Promise<number>;
+/**
+ * Loopback HTTP/1.1 GET that never routes through a proxy, resolving to the
+ * response status code (or null when the endpoint is unreachable, aborted,
+ * malformed, or slow past `timeoutMs`).
+ *
+ * Chrome's DevTools endpoint listens on loopback and speaks plain HTTP/1.1.
+ * Both `fetch` and Bun's `node:http` honor `HTTP_PROXY`/`HTTPS_PROXY` and
+ * forward even `127.0.0.1` requests to the proxy unless `NO_PROXY` covers them,
+ * so a local proxy that 502s internal addresses makes a healthy daemon look
+ * dead and the CDP readiness checks tear it down (issue #8567). Talking to the
+ * socket over raw TCP sidesteps proxy env entirely.
+ */
+export declare function probeCdpStatus(url: string, opts: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<number | null>;
 /** Poll `${cdpUrl}/json/version` until it responds with 200, with abort + timeout support. */
 export declare function waitForCdp(cdpUrl: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 /**

package/dist/types/tools/browser/launch.d.ts

@@ -56,8 +56,8 @@ export interface SharedBrowserLaunchSpec {
  * Resolve the executable and complete argv for a shared Chromium the daemon
  * broker spawns directly (no puppeteer inside the broker). Mirrors
  * `launchHeadlessBrowser` flag assembly — puppeteer's default args minus the
- * stealth-suppressed set — plus `--remote-debugging-port=0` so every client
- * attaches over CDP. Returns null when no Chromium executable resolves;
+ * stealth-suppressed set — suppresses Puppeteer's unowned startup window, and
+ * exposes CDP on an ephemeral port. Returns null when no executable resolves;
  * callers fall back to a process-local launch.
  */
 export declare function resolveSharedBrowserLaunchSpec(opts: {

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

@@ -76,7 +76,7 @@ export interface BrowserToolDetails {
 /**
  * Browser tool: stateful, multi-tab. Three actions:
  * - `open`  → acquire/create a named tab on a browser kind (headless | spawned | connected) and optionally goto a url.
- * - `close` → release a named tab (or all tabs); dispose browser when refcount hits 0.
+ * - `close` → release a named tab handle (or all handles); attached/relay pages remain open, and spawned pages remain unless killed.
  * - `run`   → execute JS code against an existing tab with `page`/`browser`/`tab` helpers in scope.
  */
 export declare class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolDetails> {

package/dist/types/tools/builtin-names.d.ts

@@ -2,7 +2,7 @@ export declare const BUILTIN_TOOL_NAMES: readonly ["read", "bash", "edit", "ast_
 export type BuiltinToolName = (typeof BUILTIN_TOOL_NAMES)[number];
 export declare const HIDDEN_TOOL_NAMES: readonly ["yield", "goal", "think"];
 export type HiddenToolName = (typeof HIDDEN_TOOL_NAMES)[number];
-/** Return the canonical tool name for current and legacy built-in tool IDs. */
+/** Canonicalize built-in IDs and legacy aliases. Leave plugin names unchanged. */
 export declare function normalizeToolName(name: string): string;
 /** Normalize and deduplicate tool names while preserving first-seen order. */
 export declare function normalizeToolNames(names: Iterable<string>): string[];

package/dist/types/tools/hub/jobs.d.ts

@@ -36,6 +36,12 @@ export declare function visibleJobs(manager: AsyncJobManager, ids: string[], own
  * that activity instead of implying the system is quiet. Existence is
  * already public via the peer roster, so listing ids here leaks nothing new;
  * job *control* stays owner-scoped.
+ *
+ * Reporting deliberately uses the claimed `status`, not the session-corroborated
+ * `registry.isRunning` used by the wait-sustaining gates: a ref that claims
+ * `running` with no live turn is exactly the stale entry an operator must see
+ * here to cancel it (#8634). Hiding it would match the badge count to nothing
+ * and remove the only discovery path for the id.
  */
 export declare function runningAgentsOutsideJobs(session: ToolSession): AgentActivitySnapshot[];
 interface TrackedJobLike {

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

@@ -55,6 +55,12 @@ export interface AgentActivitySnapshot {
     activity?: string;
     /** Time since the agent was registered. */
     ageMs: number;
+    /**
+     * Whether an attached session corroborates the `running` claim. False marks
+     * a ref that says `running` with no turn in flight — either a spawn still
+     * wiring up or a stale registration that `hub cancel <id>` clears (#8634).
+     */
+    live: boolean;
 }
 /** Result details for messaging and job ops; fields are disjoint per op. */
 export interface CoordinationDetails {