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

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

@@ -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,14 +229,21 @@ 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>;
     /**
      * 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 +254,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

@@ -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";
@@ -138,6 +139,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;
@@ -832,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;
@@ -1140,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/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/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;