@oh-my-pi/pi-coding-agent 17.2.12 → 17.2.13

package/dist/types/session/retry-fallback-chains.d.ts

@@ -37,6 +37,19 @@ export interface ActiveRetryFallbackState {
     originalThinkingLevel: ConfiguredThinkingLevel | undefined;
     lastAppliedFallbackThinkingLevel: ConfiguredThinkingLevel | undefined;
     pinned: boolean;
+    /**
+     * Set once a turn on the fallback target settles successfully. Until then the
+     * switch is only a routing decision — nothing has been produced by the new
+     * model, so no observer may report the run as having used it.
+     */
+    served?: boolean;
+}
+/** Model a session's produced work is attributed to. */
+export interface ServingModel {
+    /** Full selector including routing and thinking level. */
+    selector: string;
+    /** Whether fallback routing, rather than the configured primary, owns it. */
+    isFallback: boolean;
 }
 /** Calculates capped exponential retry delay with downward jitter. */
 export declare function calculateRetryBackoffDelayMs(baseDelayMs: number, attempt: number): number;

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

@@ -180,7 +180,7 @@ export declare class SessionAdvisors {
      */
     refreshProviderIdentity(): void;
     /** Re-primes advisor transcript views after an in-conversation history rewrite. */
-    resetAllRuntimes(): void;
+    resetAllRuntimes(reason?: string): void;
     /** Whether live runtimes still match the resolved advisor configuration. */
     runtimeMatchesCurrentConfig(): boolean;
     /** Whether concern/blocker delivery is inside the post-interrupt immunity window. */

package/dist/types/session/session-history-format.d.ts

@@ -34,6 +34,16 @@ export interface HistoryFormatOptions {
      */
     toolResultIndex?: ReadonlyMap<string, ToolResultMessage>;
     consumedToolCallIds?: Set<string>;
+    /**
+     * Chunked rendering state: a mutable holder for the watched-role label
+     * (`**user**:` / `**agent**:`) that ended the previous chunk. Lets a caller
+     * formatting one logical transcript across several calls (advisor
+     * multi-message split) keep consecutive same-role collapsing byte-identical
+     * to the single-block render: pass one object across all chunk calls.
+     */
+    watchedRoleState?: {
+        lastLabel: string | undefined;
+    };
 }
 export declare function formatExecutionSourcePreview(source: string): string;
 /** Pick the most informative scalar argument of a tool call. */

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

@@ -85,7 +85,7 @@ export interface SessionMaintenanceHost {
     resetCodexProviderAfterCompaction(compaction: CodexCompactionContext): void;
     resetPlanReference(): void;
     syncTodoPhasesFromBranch(): void;
-    resetAdvisorRuntimes(): void;
+    resetAdvisorRuntimes(reason?: string): void;
     rebaseAfterCompaction(): void;
     recordAnchoredHistoryRewrite(tokensRemoved: number): void;
     getContextBreakdown(options?: {

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

@@ -47,6 +47,8 @@ interface SessionToolsOptions {
     createInspectImageTool?: () => Promise<AgentTool | null>;
     builtInToolNames?: Iterable<string>;
     presentationPinnedToolNames?: ReadonlySet<string>;
+    /** MCP tool names whose current registry entries came from the manager snapshot. */
+    mcpManagerToolNames?: Iterable<string>;
     ensureWriteRegistered?: () => Promise<boolean>;
     rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
         systemPrompt: string[];
@@ -138,6 +140,20 @@ export declare class SessionTools {
     getToolByName(name: string): AgentTool | undefined;
     /** Whether a registry entry came from a built-in factory. */
     hasBuiltInTool(name: string): boolean;
+    /** Updates source provenance when a live registry entry is replaced or restored. */
+    setToolBuiltIn(name: string, builtIn: boolean): void;
+    /** Whether the live registry entry is owned by the RPC host. */
+    hasRpcHostTool(name: string): boolean;
+    /** Whether the current MCP entry came from the manager snapshot. */
+    hasMCPManagerTool(name: string): boolean;
+    /** Restores manager ownership after a lifecycle registration rollback. */
+    setMCPManagerTool(name: string, managerOwned: boolean): void;
+    /** Current extension-owned MCP entry retained across manager refreshes. */
+    getExtensionMCPTool(name: string): AgentTool | undefined;
+    /** Updates extension ownership when a lifecycle registration commits or rolls back. */
+    setExtensionMCPTool(name: string, tool: AgentTool | undefined): void;
+    /** Serializes every registry and presentation mutation for this session. */
+    runToolRegistryMutation<T>(mutation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
     /** Names of every registered tool. */
     getAllToolNames(): string[];
     /**
@@ -162,7 +178,7 @@ export declare class SessionTools {
     /** Enabled MCP tools in their current presentation partition. */
     getSelectedMCPToolNames(): string[];
     /** Applies an enabled tool set and reconciles its `xd://` partition. */
-    applyActiveToolsByName(toolNames: string[]): Promise<void>;
+    applyActiveToolsByName(toolNames: string[], forcePromptRefresh?: boolean, signal?: AbortSignal): Promise<void>;
     /**
      * Forget the announced-mount baseline for a replaced transcript. Called when
      * session history is swapped wholesale (`/new`, `switchSession`, `branch`): the
@@ -192,11 +208,14 @@ export declare class SessionTools {
      * `xd://` remain mount-eligible, even when the live mount set has drifted.
      *
      * Names outside `mountedToolNames` are pinned top-level for this application;
-     * names in the mounted subset remain eligible for xdev mounting. Delegates the
-     * actual apply through {@link applyActiveToolsByName} and restores the prior runtime
-     * selection if that apply throws.
+     * names in the mounted subset remain eligible for xdev mounting. Set
+     * `forcePromptRefresh` when an enabled tool's schema or prompt-visible metadata
+     * changed without changing its name or presentation.
+     *
+     * Delegates the actual apply through {@link applyActiveToolsByName} and restores
+     * the prior runtime selection if that apply throws.
      */
-    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[]): Promise<void>;
+    setActiveToolPresentation(toolNames: string[], mountedToolNames: string[], forcePromptRefresh?: boolean, signal?: AbortSignal): Promise<void>;
     /** Replaces memory-backend tools while preserving unrelated selections. */
     replaceMemoryTools(tools: AgentTool[]): Promise<void>;
     /**

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

@@ -5,7 +5,7 @@ import type { Settings } from "../config/settings.js";
 import { type ConfiguredThinkingLevel } from "../thinking.js";
 import type { AgentSessionEvent } from "./agent-session-events.js";
 import type { InitialRetryFallbackState, UsageFallbackConfirmer } from "./agent-session-types.js";
-import { type RetryFallbackSelector } from "./retry-fallback-chains.js";
+import { type RetryFallbackSelector, type ServingModel } from "./retry-fallback-chains.js";
 import type { SessionManager } from "./session-manager.js";
 /** Result shape shared with automatic maintenance recovery. */
 export interface RecoveryCompactionResult {
@@ -77,13 +77,42 @@ export declare class TurnRecovery {
     get attempt(): number;
     /** Promise settled when the active retry saga finishes. */
     get retryPromise(): Promise<void> | undefined;
-    /** Resolved selector while fallback routing owns the current model. */
-    get retryFallbackModel(): string | undefined;
+    /**
+     * Model this session's produced work is attributed to.
+     *
+     * A model switch is a routing decision, not evidence the target can produce
+     * anything: a candidate that errors on its first request produced none of the
+     * turns already in this session. So attribution only ever names a model that
+     * has settled a turn here, and a switch — into a fallback, back to a restored
+     * primary, or anywhere else — moves it only once the new model answers.
+     *
+     * Before anything has served there is no earlier work to miscredit, so the
+     * configured model is both the only available answer and a safe one.
+     */
+    get servingModel(): ServingModel | undefined;
+    /**
+     * Carries attribution onto a new session id that continues this conversation.
+     *
+     * The session-id anchor assumes a new id means an unrelated transcript, which
+     * holds for `/new` and for resuming something else. A fork breaks that
+     * assumption on purpose: it clones the transcript and keeps running the same
+     * recovery state under a fresh id. Dropping attribution there would bootstrap
+     * an unproven fallback as the primary and re-credit it with the work the
+     * previous model did — the very bug the anchor exists to prevent.
+     *
+     * Only state belonging to `previousSessionId` moves, so an id left behind by
+     * an earlier switch stays expired.
+     */
+    reanchorServedAttribution(previousSessionId: string): void;
     /** Resets per-prompt recovery counters and terminal-stop acceptance. */
     resetForNewPrompt(): void;
     /** Sets whether one terminal empty stop is accepted for the current prompt. */
     setAcceptTerminalEmptyStop(accept: boolean): void;
-    /** Closes a successful retry saga and annotates recovered persisted errors. */
+    /**
+     * Records which model produced this turn, marks an active fallback as having
+     * served, then closes a successful retry saga and annotates recovered
+     * persisted errors.
+     */
     onAssistantSettledSuccessfully(message: AssistantMessage): Promise<void>;
     /** Closes a failed retry saga when no compaction continuation took ownership. */
     onErrorSettledWithoutRetry(message: AssistantMessage, compaction: RecoveryCompactionResult): Promise<void>;
@@ -170,7 +199,7 @@ export declare class TurnRecovery {
     classifyResolvedInterruptedToolTurn(message: AssistantMessage): "reasonless-abort" | "stream-stall" | undefined;
     /** Checks whether a provider error represents a classifier refusal. */
     isClassifierRefusal(message: AssistantMessage): boolean;
-    /** Clears fallback ownership after an explicit model change. */
+    /** Clears fallback ownership after an explicit model change or a restore. */
     clearActiveRetryFallback(): void;
     /** Checks whether a fallback selector remains in cooldown. */
     isRetryFallbackSelectorSuppressed(selector: RetryFallbackSelector): boolean;

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

@@ -1,5 +1,5 @@
 import type { Settings } from "../config/settings.js";
-import type { InteractiveModeContext } from "../modes/types.js";
+import type { InteractiveModeContext, SubmittedUserInput } from "../modes/types.js";
 import type { AgentSession } from "../session/agent-session.js";
 import type { SessionManager } from "../session/session-manager.js";
 /** Declarative subcommand definition for commands like /mcp. */
@@ -81,6 +81,10 @@ export interface SlashCommandRuntime {
  */
 export interface TuiSlashCommandRuntime {
     ctx: InteractiveModeContext;
+    /** Post-extension-hook attachments belonging to the submitted slash draft. */
+    input?: Pick<SubmittedUserInput, "images" | "imageLinks">;
+    /** The editor snapshot was cleared before asynchronous input hooks ran. */
+    draftDetached?: boolean;
 }
 /** Unified slash-command spec consumed by both TUI and ACP dispatchers. */
 export interface SlashCommandSpec extends BuiltinSlashCommand {

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

@@ -253,7 +253,7 @@ export declare function finalizeSubprocessOutput(args: FinalizeSubprocessOutputA
  */
 export declare function createMCPProxyTools(mcpManager: MCPManager): CustomTool[];
 export declare function createSubagentSettings(baseSettings: Settings, overrides?: Partial<Record<SettingPath, unknown>>, inheritedServiceTier?: ServiceTierByFamily | null): Settings;
-export type AbortReason = "signal" | "terminate" | "timeout" | "budget";
+export type AbortReason = "signal" | "shutdown" | "terminate" | "timeout" | "budget";
 /** Inputs for {@link attachIrcWakeTurnMonitor}. */
 export interface IrcWakeTurnMonitorOptions {
     /** Registry id of the kept-alive subagent whose autonomous IRC wake turns are monitored. */

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

@@ -17,6 +17,8 @@ export interface ResolvedApproval {
     reason?: string;
     override: boolean;
     source?: "tool" | "user" | "mode";
+    /** User-policy key that produced `source: "user"` (defaults to the tool name). */
+    policyKey?: string;
 }
 /**
  * Evaluate a tool's own approval declaration against `args` and return the
@@ -31,6 +33,11 @@ export declare function resolveToolTier(tool: ApprovalSubject, args: unknown): T
  *
  * Resolution order:
  *  1. Tool `approval(args)` decision, defaulting to tier "exec" when omitted.
+ *     A decision may carry a `policyKey` — `tools.approval.<policyKey>` is then
+ *     the user override consulted instead of `tools.approval.<tool.name>`, with
+ *     the invoking tool's own policy as the fallback when the user set none for
+ *     the keyed sub-tool (e.g. an `xd://` device dispatch without a device
+ *     policy still honors `tools.approval.write`).
  *  2. User per-tool override, if set and valid.
  *  3. Active mode tier comparison.
  *

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

@@ -74,6 +74,12 @@ export declare function getLatestTodoPhasesFromEntries(entries: SessionEntry[]):
  * the contained side.
  */
 export declare function todoMatchesAnyDescription(content: string, descriptions: readonly string[]): boolean;
+/** Whether a todo is settled: completed or deliberately abandoned. Shared so
+ *  the collapsed viewport, the HUD progress counters, and the HUD's closed-todo
+ *  auto-clear can never disagree about what "done" hides. */
+export declare function isClosedTodo<T extends {
+    status: TodoStatus;
+}>(task: T): boolean;
 /** Result of {@link selectCollapsedTodos}: the rows to render plus an optional
  *  summary line (empty string ⇒ no summary row). */
 export interface CollapsedTodoSelection<T> {
@@ -83,22 +89,15 @@ export interface CollapsedTodoSelection<T> {
 /**
  * Walking-viewport selection for a phase's collapsed todo preview (#5873).
  *
- * Policy, applied to `tasks` in todo order:
- * 1. While the phase has open work, completed/abandoned tasks are omitted. A
- *    phase with no open tasks left falls back to its closed tasks so the sticky
- *    HUD's closed-todo persistence still has something to render.
- * 2. Every active task (in-progress, or pending matched to a live subagent) is
- *    placed at the head in stable todo order — never dropped for lying outside
- *    an ordinary window.
- * 3. Remaining rows up to `cap` are filled with the pending tasks that follow
- *    the first active one, in todo order (falling back to leading pending tasks
- *    when no active task exists), so a freshly-promoted task leads the preview.
- * 4. When active tasks alone exceed `cap`, only the first `cap` active tasks are
- *    shown and the summary counts the hidden *active* todos, never replacing
- *    them with unrelated pending rows.
+ * Applied to `tasks` in todo order: the open tasks run through
+ * {@link selectWithinCap}, led by the last {@link COLLAPSED_CLOSED_CONTEXT}
+ * closed tasks in todo order so a checked row remains visible even when callers
+ * complete work out of sequence. The lead is additive — it never costs an open
+ * row — and a phase with no open work left falls back to its closed tasks so the
+ * sticky HUD's closed-todo persistence still has something to render.
  *
- * The summary otherwise counts the remaining tasks in the display base. Returns
- * the whole base with an empty summary when it already fits.
+ * `summary` counts the open tasks that did not fit; the closed lead is context,
+ * not part of the budget.
  */
 export declare function selectCollapsedTodos<T extends {
     status: TodoStatus;

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

@@ -1,4 +1,4 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolTier } from "@oh-my-pi/pi-agent-core";
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
 import { type Component } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types.js";
 import { type FileDiagnosticsResult } from "../lsp/index.js";
@@ -36,7 +36,7 @@ export declare class WriteTool implements AgentTool<typeof writeSchema, WriteToo
     #private;
     private readonly session;
     readonly name = "write";
-    readonly approval: (args: unknown) => ToolTier;
+    readonly approval: (args: unknown) => ToolApprovalDecision;
     readonly formatApprovalDetails: (args: unknown) => string[];
     readonly label = "Write";
     readonly description: string;

package/dist/types/utils/local-date.d.ts

@@ -1,2 +1,4 @@
 /** formatLocalCalendarDate formats a Date as YYYY-MM-DD in the host local timezone. */
 export declare function formatLocalCalendarDate(date?: Date): string;
+/** Format a local date and minute with a compact numeric UTC offset. */
+export declare function formatLocalDateTimeWithOffset(date: Date): string;

package/dist/types/vibe/runtime.d.ts

@@ -7,7 +7,7 @@ export type VibeCli = "fast" | "good";
  * CLI flavor → bundled agent type. This IS the model-tier mapping: `sonic`
  * carries `model: "@smol"` (the configured fast/low-latency role) and `task`
  * carries `model: "@task"` (inherits the session's strong model).
- * Resolution goes through {@link resolveAgentModelPatterns} exactly like a
+ * Resolution goes through {@link resolveAgentModelSelection} exactly like a
  * `task` spawn, so `task.agentModelOverrides` and model-role settings apply.
  */
 export declare const VIBE_CLI_AGENT: Record<VibeCli, string>;

package/dist/types/web/parallel.d.ts

@@ -58,6 +58,7 @@ export declare class ParallelApiError extends Error {
     constructor(message: string, statusCode?: number);
 }
 export declare function parseParallelErrorResponse(statusCode: number, responseText: string): ParallelApiError;
+export declare function parseParallelJsonResponse(response: Response, operation: "search" | "extract"): Promise<unknown>;
 export declare function parseParallelSearchPayload(payload: unknown, options?: {
     parseMetadata?: boolean;
 }): ParallelSearchResult;

package/dist/types/web/search/providers/brave.d.ts

@@ -14,18 +14,23 @@ export interface BraveSearchParams {
     num_results?: number;
     recency?: "day" | "week" | "month" | "year";
     parsedQuery?: StructuredQuery;
+    /** Two-letter market code, or `ALL`. */
+    country?: string;
+    /** Brave search language code, such as `en` or `zh-hans`. */
+    search_lang?: string;
+    safesearch?: "off" | "moderate" | "strict";
+    authStorage: AuthStorage;
+    sessionId?: string;
     signal?: AbortSignal;
     timeoutMs?: number;
     fetch?: FetchImpl;
 }
-/** Find BRAVE_API_KEY from environment or .env files. */
-export declare function findApiKey(): string | null;
 /** Execute Brave web search. */
 export declare function searchBrave(params: BraveSearchParams): Promise<SearchResponse>;
 /** Search provider for Brave web search. */
 export declare class BraveProvider extends SearchProvider {
     readonly id = "brave";
     readonly label = "Brave";
-    isAvailable(_authStorage: AuthStorage): boolean;
+    isAvailable(authStorage: AuthStorage): boolean;
     search(params: SearchParams): Promise<SearchResponse>;
 }

package/dist/types/web/search/providers/codex.d.ts

@@ -1,3 +1,9 @@
+/**
+ * OpenAI Codex Web Search Provider
+ *
+ * Uses the configured Codex Responses transport for proxy/API-key setups and
+ * the official ChatGPT backend for OAuth logins.
+ */
 import { type AuthStorage, type FetchImpl } from "@oh-my-pi/pi-ai";
 import type { SearchResponse } from "../../../web/search/types.js";
 import type { SearchParams } from "./base.js";

package/dist/types/web/search/providers/firecrawl.d.ts

@@ -27,8 +27,9 @@ export declare class FirecrawlProvider extends SearchProvider {
     readonly id = "firecrawl";
     readonly label = "Firecrawl";
     /**
-     * Auto-chain admission: requires a credential so an unconfigured Firecrawl
-     * doesn't displace other providers that the user has set up with API keys.
+     * Auto-chain admission requires either a credential or an explicitly
+     * configured self-hosted endpoint. Hosted keyless mode remains explicit-only
+     * so it does not displace providers the user configured.
      */
     isAvailable(authStorage: AuthStorage): boolean;
     /**

package/dist/types/web/search/providers/jina.d.ts

@@ -13,6 +13,8 @@ type SearchParamsWithFetch = SearchParams & {
 };
 export interface JinaSearchParams {
     query: string;
+    authStorage: AuthStorage;
+    sessionId?: string;
     num_results?: number;
     /** Single bare host for Jina's `X-Site` in-site search header. */
     site?: string;
@@ -20,15 +22,13 @@ export interface JinaSearchParams {
     timeoutMs?: number;
     fetch?: FetchImpl;
 }
-/** Find JINA_API_KEY from environment or .env files. */
-export declare function findApiKey(): string | null;
 /** Execute Jina web search. */
 export declare function searchJina(params: JinaSearchParams): Promise<SearchResponse>;
 /** Search provider for Jina Reader. */
 export declare class JinaProvider extends SearchProvider {
     readonly id = "jina";
     readonly label = "Jina";
-    isAvailable(_authStorage: AuthStorage): boolean;
+    isAvailable(authStorage: AuthStorage): boolean;
     search(params: SearchParamsWithFetch): Promise<SearchResponse>;
 }
 export {};

package/dist/types/web/search/providers/parallel.d.ts

@@ -6,6 +6,7 @@ import { SearchProvider } from "./base.js";
 export declare function searchParallel(params: {
     query: string;
     num_results?: number;
+    recency?: SearchParams["recency"];
     signal?: AbortSignal;
     timeoutMs?: number;
     fetch?: FetchImpl;

package/dist/types/web/search/providers/perplexity.d.ts

@@ -19,7 +19,11 @@ export interface PerplexitySearchParams {
     system_prompt?: string;
     /** Pre-parsed view of `query` from the search pipeline; parsed locally when absent. */
     parsedQuery?: StructuredQuery;
+    /** Direct API model. Defaults to `PI_PERPLEXITY_API_MODEL`, then `sonar-pro`. */
+    api_model?: string;
     search_recency_filter?: "hour" | "day" | "week" | "month" | "year";
+    /** Consumer subscription model preference. Defaults to `PI_PERPLEXITY_MODEL`, then Sonar (`experimental`). */
+    subscription_model?: string;
     num_results?: number;
     /** Maximum output tokens. Defaults to 8192. */
     max_tokens?: number;

package/dist/types/web/search/providers/tinyfish.d.ts

@@ -13,6 +13,8 @@ export interface TinyFishSearchParams {
     num_results?: number;
     recency?: SearchParams["recency"];
     page?: number;
+    include_domains?: string[];
+    exclude_domains?: string[];
     signal?: AbortSignal;
     timeoutMs?: number;
     fetch?: FetchImpl;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.2.12",
+	"version": "17.2.13",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -50,18 +50,18 @@
 	},
 	"dependencies": {
 		"@babel/parser": "^7.29.7",
-		"@oh-my-pi/hashline": "17.2.12",
-		"@oh-my-pi/omp-stats": "17.2.12",
-		"@oh-my-pi/omptype": "17.2.12",
-		"@oh-my-pi/pi-agent-core": "17.2.12",
-		"@oh-my-pi/pi-ai": "17.2.12",
-		"@oh-my-pi/pi-catalog": "17.2.12",
-		"@oh-my-pi/pi-mnemopi": "17.2.12",
-		"@oh-my-pi/pi-natives": "17.2.12",
-		"@oh-my-pi/pi-tui": "17.2.12",
-		"@oh-my-pi/pi-utils": "17.2.12",
-		"@oh-my-pi/pi-wire": "17.2.12",
-		"@oh-my-pi/snapcompact": "17.2.12",
+		"@oh-my-pi/hashline": "17.2.13",
+		"@oh-my-pi/omp-stats": "17.2.13",
+		"@oh-my-pi/omptype": "17.2.13",
+		"@oh-my-pi/pi-agent-core": "17.2.13",
+		"@oh-my-pi/pi-ai": "17.2.13",
+		"@oh-my-pi/pi-catalog": "17.2.13",
+		"@oh-my-pi/pi-mnemopi": "17.2.13",
+		"@oh-my-pi/pi-natives": "17.2.13",
+		"@oh-my-pi/pi-tui": "17.2.13",
+		"@oh-my-pi/pi-utils": "17.2.13",
+		"@oh-my-pi/pi-wire": "17.2.13",
+		"@oh-my-pi/snapcompact": "17.2.13",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",

package/src/advisor/delta-split.ts

@@ -0,0 +1,98 @@
+// Candidate 4 (multi-message split) pure renderer, extracted for direct unit
+// testing. Renders an advisor delta as MULTIPLE user messages — one per source
+// message — instead of one ever-growing user message, so the provider prompt
+// cache can incrementally hit each appended message. Provider caches are
+// prefix-based: a single user message whose text keeps growing invalidates the
+// whole message on every turn, pinning cache_read at the instructions/tools
+// boundary (observed 14491 in production, 11066 in tests). Splitting into
+// per-source user messages grows cache_read with the session (verified
+// experimentally: 11066 → 11091 → 11112).
+//
+// Each source message is rendered INDEPENDENTLY via formatSessionHistoryMarkdown
+// in chunked mode (shared toolResultIndex + consumedToolCallIds + watchedRoleState
+// over the WHOLE delta), so toolCall/toolResult pairings resolve across chunk
+// boundaries and consecutive same-role collapsing is byte-identical to the old
+// single-block render. Concatenating the chunk texts reproduces the old advisor
+// context exactly (equivalence-tested).
+//
+// The heading stays on the FIRST chunk; the WIP marker stays on the LAST chunk
+// (candidate 3) so a wip/final flip never changes the stable prefix.
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { TextContent, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import { formatSessionHistoryMarkdown } from "../session/session-history-format";
+
+/**
+ * Obfuscation surface the split renderer needs: a single text redaction pass.
+ * Narrowed from the full SecretObfuscator class to the method actually
+ * consumed, so tests can satisfy the contract with a typed helper instead of
+ * an `as any` escape. A SecretObfuscator instance is structurally assignable.
+ */
+export interface AdvisorObfuscator {
+	obfuscate(text: string, sharedRegexSecretValues?: ReadonlySet<string>): string;
+}
+
+/** Render options shared by the advisor single-block and multi-message paths. */
+export const ADVISOR_RENDER_OPTIONS = {
+	includeToolIntent: true,
+	watchedRoles: true,
+	expandPrimaryContext: true,
+	expandEditDiffs: true,
+} as const;
+
+export interface RenderAdvisorDeltaChunksOptions {
+	wip: boolean;
+	includeThinking: boolean;
+	obfuscator?: AdvisorObfuscator;
+	advisorRegexSecretValues: ReadonlySet<string>;
+}
+
+export function renderAdvisorDeltaChunks(
+	delta: AgentMessage[],
+	opts: RenderAdvisorDeltaChunksOptions,
+): AgentMessage[] | null {
+	if (delta.length === 0) return null;
+
+	const resultsByCallId = new Map<string, ToolResultMessage>();
+	for (const msg of delta) {
+		if (msg.role === "toolResult") resultsByCallId.set(msg.toolCallId, msg);
+	}
+	const consumed = new Set<string>();
+	const watchedRoleState = { lastLabel: undefined as string | undefined };
+
+	const renderChunk = (chunk: AgentMessage[]): string =>
+		formatSessionHistoryMarkdown(chunk, {
+			...ADVISOR_RENDER_OPTIONS,
+			includeThinking: opts.includeThinking,
+			toolResultIndex: resultsByCallId,
+			consumedToolCallIds: consumed,
+			watchedRoleState,
+		});
+
+	const heading = "### Session update";
+	// Concrete local chunk type: content blocks are minted here, so the WIP
+	// marker append below is a plain field access (no double-cast).
+	const chunks: { role: "user"; content: TextContent[]; timestamp: number }[] = [];
+	for (let i = 0; i < delta.length; i++) {
+		const text = renderChunk([delta[i]]);
+		if (!text.trim()) continue;
+		chunks.push({ role: "user", content: [{ type: "text", text }], timestamp: Date.now() });
+	}
+	if (chunks.length === 0) return null;
+	if (opts.obfuscator) {
+		const fullText = chunks.map(chunk => chunk.content[0].text).join("\n");
+		const individuallyObfuscated = chunks.map(chunk =>
+			opts.obfuscator!.obfuscate(chunk.content[0].text, opts.advisorRegexSecretValues),
+		);
+		if (opts.obfuscator.obfuscate(fullText, opts.advisorRegexSecretValues) !== individuallyObfuscated.join("\n")) {
+			return null;
+		}
+		for (let i = 0; i < chunks.length; i++) chunks[i].content[0].text = individuallyObfuscated[i];
+	}
+	chunks[0].content[0].text = `${heading}\n\n${chunks[0].content[0].text}`;
+	if (chunks.length === 0) return null;
+	if (opts.wip) {
+		const last = chunks[chunks.length - 1];
+		last.content[0].text += `\n\n---\n\n[in progress — more steps follow]`;
+	}
+	return chunks as AgentMessage[];
+}