@oh-my-pi/pi-coding-agent 17.1.2 → 17.1.4

package/dist/types/cli/__tests__/auth-gateway-catalog.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/cli/auth-gateway-cli.d.ts

@@ -1,3 +1,4 @@
+import { type Api, type Model } from "@oh-my-pi/pi-ai";
 export type AuthGatewayAction = "serve" | "token" | "status" | "check";
 export interface AuthGatewayCommandArgs {
     action: AuthGatewayAction;
@@ -22,5 +23,12 @@ export interface AuthGatewayCommandArgs {
     };
 }
 declare const ACTIONS: readonly AuthGatewayAction[];
+/**
+ * Index resolvable models by the request ids clients may send: the
+ * provider-qualified `provider/id` (always) and the bare `id` (first-write-wins
+ * fallback for legacy clients). Scoped to providers the gateway holds broker
+ * credentials for, since only those are routable.
+ */
+export declare function indexModelsByRequestId(models: readonly Model<Api>[], providersWithCreds: ReadonlySet<string>): Map<string, Model<Api>>;
 export declare function runAuthGatewayCommand(cmd: AuthGatewayCommandArgs): Promise<void>;
 export { ACTIONS as AUTH_GATEWAY_ACTIONS };

package/dist/types/cli/update-cli.d.ts

@@ -1,3 +1,24 @@
+export interface ReleaseBinaryAsset {
+    url: string;
+    size: number;
+    digest: string;
+}
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/**
+ * Select and validate the binary asset from GitHub release metadata.
+ */
+export declare function resolveReleaseBinaryAsset(release: unknown, expectedTag: string, binaryName: string): ReleaseBinaryAsset;
+export interface VerifiedBinaryDownloadOptions {
+    url: string;
+    targetPath: string;
+    expectedSize: number;
+    expectedDigest: string;
+    fetchImpl?: Fetch;
+}
+/**
+ * Download a binary and verify its GitHub-reported size and SHA-256 digest.
+ */
+export declare function downloadVerifiedBinary(options: VerifiedBinaryDownloadOptions): Promise<void>;
 /** Result from running the installed binary and parsing its reported version. */
 export interface InstalledVersionVerification {
     ok: boolean;
@@ -27,6 +48,13 @@ interface UpdateMethodResolutionOptions {
     miseBinDirs?: readonly string[];
     miseDataDir?: string;
     npmBinDir?: string;
+    /**
+     * Whether the resolved omp path is a plain file (the standalone binary)
+     * rather than a package-manager symlink. Stops a binary install from being
+     * misrouted to npm/bun when the global bin dir overlaps the installer's
+     * target directory.
+     */
+    ompIsRegularFile?: boolean;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
 interface BunInstallCachePruneResult {
@@ -44,6 +72,10 @@ interface BunInstallCachePruneResult {
  */
 export declare function pruneBunInstallCache(cacheDir: string, packageNames?: Set<string>): Promise<BunInstallCachePruneResult>;
 export declare function resolveBunGlobalNodeModulesDirFromLocations(globalBinDir: string | undefined, cacheDir: string | undefined): string | undefined;
+/**
+ * Run the resolved omp binary and check if it reports the expected version.
+ */
+declare function verifyInstalledVersion(expectedVersion: string): Promise<InstalledVersionVerification>;
 /**
  * Best-effort removal of binary-update backups left by earlier runs.
  *
@@ -95,6 +127,15 @@ export declare function buildNpmInstallArgs(expectedVersion: string, nativeTag?:
 export declare function buildHomebrewUpdateArgs(force: boolean): string[];
 export declare function buildMiseUpgradeArgs(): string[];
 export declare function buildMiseForceInstallArgs(expectedVersion: string): string[];
+/**
+ * Download a release binary to a target path, replacing an existing file.
+ */
+export declare function updateViaBinaryAt(targetPath: string, expectedVersion: string, options?: {
+    binaryName?: string;
+    fetchImpl?: Fetch;
+    githubToken?: string;
+    verifyInstalledVersion?: typeof verifyInstalledVersion;
+}): Promise<void>;
 /**
  * Run the update command.
  */

package/dist/types/cli/usage-cli.d.ts

@@ -7,7 +7,7 @@
  * credentials produced no usage report are listed too, so the output
  * always covers the full credential pool.
  */
-import { type UsageHistoryEntry, type UsageReport } from "@oh-my-pi/pi-ai";
+import { type DisabledCredentialSummary, type UsageHistoryEntry, type UsageReport } from "@oh-my-pi/pi-ai";
 export interface UsageCommandArgs {
     action?: string;
     json?: boolean;
@@ -29,6 +29,8 @@ export interface UsageAccountIdentity {
     /** Organization/workspace the credential is scoped to (Anthropic multi-subscription). */
     orgId?: string;
     orgName?: string;
+    /** Epoch ms of the interactive login that minted the OAuth grant (see `OAuthCredentials.authorizedAt`). */
+    authorizedAt?: number;
 }
 /**
  * Minimal-reveal masks for identity strings (`--redact`).
@@ -76,7 +78,7 @@ export declare function computeProviderWindowStats(reports: UsageReport[]): Prov
  * with a bar, amounts, and reset times; unattributed credentials trail
  * each provider section as "no usage data" rows.
  */
-export declare function formatUsageBreakdown(reports: UsageReport[], accounts: UsageAccountIdentity[], nowMs: number, redaction?: Map<string, string>): string;
+export declare function formatUsageBreakdown(reports: UsageReport[], accounts: UsageAccountIdentity[], nowMs: number, redaction?: Map<string, string>, disabled?: DisabledCredentialSummary[]): string;
 /**
  * Render recorded usage-limit history: per provider, per account, one
  * peak-per-bucket sparkline per limit window plus latest/peak percentages.

package/dist/types/commands/update.d.ts

@@ -21,5 +21,6 @@ export default class Update extends Command {
             default: boolean;
         };
     };
+    static examples: string[];
     run(): Promise<void>;
 }

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

@@ -55,6 +55,16 @@ export interface ProviderDiscoveryState {
     models: string[];
     error?: string;
 }
+/** Authentication material returned to legacy extensions for one model request. */
+export type ResolvedRequestAuth = {
+    ok: true;
+    apiKey?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+} | {
+    ok: false;
+    error: string;
+};
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -71,6 +81,13 @@ export declare class ModelRegistry {
      * `tryLoad()` runs.
      */
     constructor(authStorage: AuthStorage, modelsPath?: string, options?: {
+        /**
+         * Gateway mode: ignore local `models.yml` entirely (provider overrides,
+         * config API keys, custom models, custom discovery). A broker-backed
+         * gateway serves only bundled + broker-discovered catalog metadata and
+         * must never apply client-side credential or routing overrides.
+         */
+        ignoreLocalModelConfig?: boolean;
         fetch?: FetchImpl;
     });
     /**
@@ -178,6 +195,8 @@ export declare class ModelRegistry {
     getApiKey(model: Model<Api>, sessionId?: string, options?: {
         signal?: AbortSignal;
     }): Promise<string | undefined>;
+    /** Resolve request authentication through the historical Pi extension facade. */
+    getApiKeyAndHeaders(model: Model<Api>): Promise<ResolvedRequestAuth>;
     /**
      * Get API key for a provider (e.g., "openai").
      *

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

@@ -85,33 +85,44 @@ export type AnyUiMetadata = UiBase & {
     secret?: boolean;
     ordered?: boolean;
 };
-interface BooleanDef {
+/**
+ * Marks a setting whose value is a credential.
+ *
+ * Lives at the top level rather than inside `ui` so it can also describe a
+ * setting the settings panel never shows and therefore cannot carry
+ * `ui.secret`. Read it through `isCredential`, which is the single accessor
+ * both the CLI and the settings panel consult.
+ */
+interface CredentialMarker {
+    credential?: true;
+}
+interface BooleanDef extends CredentialMarker {
     type: "boolean";
     default: boolean | undefined;
     ui?: UiBoolean;
 }
-interface StringDef {
+interface StringDef extends CredentialMarker {
     type: "string";
     default: string | undefined;
     ui?: UiString;
 }
-interface NumberDef {
+interface NumberDef extends CredentialMarker {
     type: "number";
     default: number | undefined;
     ui?: UiNumber;
 }
-interface EnumDef<T extends readonly string[]> {
+interface EnumDef<T extends readonly string[]> extends CredentialMarker {
     type: "enum";
     values: T;
     default: T[number];
     ui?: UiEnum<T>;
 }
-interface ArrayDef<T> {
+interface ArrayDef<T> extends CredentialMarker {
     type: "array";
     default: T[];
     ui?: UiArray;
 }
-interface RecordDef<T> {
+interface RecordDef<T> extends CredentialMarker {
     type: "record";
     default: Record<string, T>;
     ui?: UiBase;
@@ -139,6 +150,7 @@ export declare const SETTINGS_SCHEMA: {
     readonly "auth.broker.token": {
         readonly type: "string";
         readonly default: undefined;
+        readonly credential: true;
     };
     readonly autoResume: {
         readonly type: "boolean";
@@ -2843,6 +2855,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "mnemopi.embeddingApiKey": {
         readonly type: "string";
+        readonly credential: true;
         readonly default: undefined;
         readonly ui: {
             readonly tab: "memory";
@@ -2890,6 +2903,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "mnemopi.llmApiKey": {
         readonly type: "string";
+        readonly credential: true;
         readonly default: undefined;
         readonly ui: {
             readonly tab: "memory";
@@ -2947,6 +2961,7 @@ export declare const SETTINGS_SCHEMA: {
     };
     readonly "hindsight.apiToken": {
         readonly type: "string";
+        readonly credential: true;
         readonly default: undefined;
         readonly ui: {
             readonly tab: "memory";
@@ -2954,7 +2969,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly label: "Hindsight API Token";
             readonly description: "Bearer token for authenticated Hindsight servers";
             readonly condition: "hindsightActive";
-            readonly secret: true;
         };
     };
     readonly "hindsight.bankId": {
@@ -5798,6 +5812,7 @@ export declare const SETTINGS_SCHEMA: {
     readonly "searxng.token": {
         readonly type: "string";
         readonly default: undefined;
+        readonly credential: true;
     };
     readonly "searxng.basicUsername": {
         readonly type: "string";
@@ -5806,6 +5821,7 @@ export declare const SETTINGS_SCHEMA: {
     readonly "searxng.basicPassword": {
         readonly type: "string";
         readonly default: undefined;
+        readonly credential: true;
     };
     readonly "searxng.categories": {
         readonly type: "string";
@@ -5866,6 +5882,7 @@ export declare const SETTINGS_SCHEMA: {
     readonly "dev.autoqaPush.token": {
         readonly type: "string";
         readonly default: undefined;
+        readonly credential: true;
     };
     /**
      * User decision on sharing automatic `report_tool_issue` grievances.
@@ -5964,6 +5981,12 @@ export type SettingValue<P extends SettingPath> = Schema[P] extends {
 export declare function getDefault<P extends SettingPath>(path: P): SettingValue<P>;
 /** Check if a path has UI metadata (should appear in settings panel) */
 export declare function hasUi(path: SettingPath): boolean;
+/**
+ * Whether a setting holds a credential and must never be printed or exported
+ * without an explicit request. Drives both CLI redaction and settings-panel
+ * masking, so the two cannot disagree.
+ */
+export declare function isCredential(path: SettingPath): boolean;
 /** Get UI metadata for a path (undefined if no UI) */
 export declare function getUi(path: SettingPath): AnyUiMetadata | undefined;
 /** Get all paths for a specific tab */

package/dist/types/cursor.d.ts

@@ -1,5 +1,6 @@
 import type { AgentEvent, AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
-import type { CursorMcpCall, CursorShellStreamCallbacks, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type { CursorMcpCall, CursorShellStreamCallbacks, CursorTodoSnapshot, CursorExecHandlers as ICursorExecHandlers, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import type { TodoPhase } from "./tools/todo.js";
 interface CursorExecBridgeOptions {
     cwd: string;
     getCwd?: () => string;
@@ -16,6 +17,18 @@ interface CursorExecBridgeOptions {
      * callers with a restricted tool set (advisors) opt out.
      */
     allowNativeDelete?: boolean;
+    /**
+     * Mirror Cursor's server-owned todo list into local session state. Cursor
+     * resolves `update_todos` / `read_todos` remotely, so without this bridge
+     * the provider's list and the local `todo` state diverge silently.
+     */
+    setTodoPhases?: (phases: TodoPhase[]) => void;
+    getTodoPhases?: () => TodoPhase[];
+    /**
+     * Persist the mirrored list to the session branch so it survives reloads.
+     * Cursor emits no local `todo` toolResult, so nothing else records it.
+     */
+    persistTodoPhases?: (phases: TodoPhase[]) => void;
 }
 export declare class CursorExecHandlers implements ICursorExecHandlers {
     private options;
@@ -28,6 +41,39 @@ export declare class CursorExecHandlers implements ICursorExecHandlers {
     shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]): Promise<ToolResultMessage<unknown>>;
     shellStream(args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0], callbacks: CursorShellStreamCallbacks): Promise<ToolResultMessage<unknown>>;
     diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    /**
+     * Settle a completed native Cursor todo call, mirroring its list when the
+     * server supplied an authoritative one.
+     *
+     * Cursor's snapshot is a flat list, so tasks already known locally keep
+     * their phase and only their status is updated; unknown tasks land in a
+     * single fallback phase. Statuses come straight from the server snapshot —
+     * no local normalization, or an all-pending remote list would gain a
+     * phantom in-progress task the remote list does not have.
+     *
+     * The snapshot is also persisted to the session branch. Every other
+     * provider's todo state survives a reload because `todo` runs locally and
+     * its `toolResult` (carrying `details.phases`) lands in the branch, which
+     * `#syncTodoPhasesFromBranch` replays. Cursor resolves the tool remotely and
+     * emits no such result, so without an explicit entry the list is in-memory
+     * only and every reload, rewind, compaction, or session switch drops it.
+     *
+     * This ALWAYS settles the call and returns the result to persist, even when
+     * nothing is mirrored. Two reasons it cannot bail out early:
+     *
+     * - the interactive card leaves `pendingTools` only on a matching
+     *   `tool_execution_end`, so staying silent leaves it animating forever;
+     * - an unpaired `toolCall` is stripped as dangling by `buildSessionContext`,
+     *   erasing the interaction from every rebuilt transcript.
+     *
+     * A `null` snapshot means nothing may be mirrored — a server `error`, or a
+     * benign refusal: a filtered, truncated, or empty read, or a snapshot the
+     * local model cannot represent. Local state is left untouched, and the result
+     * carries no `details` (text `"Todo snapshot not mirrored"`): `event-controller`
+     * feeds `details.phases` straight into `setTodos`, so echoing the current list
+     * back would let a call that changed nothing overwrite live UI state.
+     */
+    todoSync(snapshot: CursorTodoSnapshot | null, toolCallId: string, error?: string | null): ToolResultMessage;
     mcp(call: CursorMcpCall): Promise<ToolResultMessage<unknown>>;
 }
 export {};

package/dist/types/eval/js/process-entry.d.ts

@@ -1,6 +1,7 @@
+import { type RejectionInterceptor } from "./worker-core.js";
 import type { WorkerInbound, WorkerOutbound } from "./worker-protocol.js";
 /** Start the JavaScript evaluator inside a subprocess IPC transport. */
 export declare function startJsEvalProcess(transport: {
     send(message: WorkerOutbound): void;
     onMessage(handler: (message: WorkerInbound) => void): () => void;
-}): void;
+}, interceptUnhandledRejections: RejectionInterceptor): void;

package/dist/types/eval/js/worker-core.d.ts

@@ -1,4 +1,5 @@
 import type { Transport } from "./worker-protocol.js";
+export type RejectionInterceptor = (handler: (reason: unknown) => boolean) => () => void;
 export type WorkerCoreOptions = {
     mode: "isolated";
     /**
@@ -9,9 +10,11 @@ export type WorkerCoreOptions = {
      * mutate the host's own cwd on the inline fallback.
      */
     chdir?: (cwd: string) => void;
+    /** Share the subprocess host's fatal-rejection guard when one is installed. */
+    interceptUnhandledRejections?: RejectionInterceptor;
 } | {
     mode: "inline";
-    interceptUnhandledRejections(handler: (reason: unknown) => boolean): () => void;
+    interceptUnhandledRejections: RejectionInterceptor;
 };
 export declare class WorkerCore {
     #private;

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

@@ -86,6 +86,7 @@ export declare class ExtensionRunner {
      * {@link onError} via {@link emit}'s normal isolation.
      */
     emitCredentialDisabled(event: CredentialDisabledEvent): Promise<void>;
+    /** Emits a session stop pass that can be cancelled with the active settle signal. */
     emitSessionStop(event: Omit<SessionStopEvent, "type">): Promise<SessionStopEventResult | undefined>;
     getUIContext(): ExtensionUIContext;
     hasUI(): boolean;

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

@@ -19,6 +19,8 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { calculateCost, getBundledModel, getBundledModels, getBundledProviders, modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { type TSchema, Type } from "./typebox.js";
 export interface StringEnumOptions<T extends string> {
@@ -28,6 +30,8 @@ export interface StringEnumOptions<T extends string> {
     [key: string]: unknown;
 }
 export declare function StringEnum<T extends string | number>(values: readonly T[] | Record<string, T>, options?: StringEnumOptions<any>): TSchema;
+/** Clamp a historical Pi thinking level against OMP's model metadata. */
+export declare function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: Effort | "off"): Effort | "off";
 export * from "@oh-my-pi/pi-ai";
 /**
  * Compatibility re-exports for catalog symbols that pi-ai historically exposed

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

@@ -17,6 +17,7 @@ import type { PromptTemplate } from "../config/prompt-templates.js";
 import { Settings } from "../config/settings.js";
 import type { CreateAgentSessionOptions, CreateAgentSessionResult, LoadExtensionsResult } from "../sdk.js";
 import { EventBus } from "../utils/event-bus.js";
+import { ExtensionRuntime } from "./extensions/loader.js";
 import type { ExtensionFactory, ToolDefinition } from "./extensions/types.js";
 import type { Skill } from "./skills.js";
 export interface BashSpawnContext {
@@ -272,6 +273,8 @@ export interface ResourceLoader {
     /** @internal — used by the shim's createAgentSession to detect its own loaders. */
     readonly __ompLegacyPiLoader?: true;
 }
+/** Create a pre-initialization runtime for legacy extension resource loaders. */
+export declare function createExtensionRuntime(): ExtensionRuntime;
 export declare class DefaultResourceLoader implements ResourceLoader {
     #private;
     readonly __ompLegacyPiLoader: true;
@@ -372,6 +375,7 @@ export { getProjectDir } from "@oh-my-pi/pi-utils";
  * canonical helper.
  */
 export declare function getPackageDir(): string;
+export { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
 export * from "../index.js";
 export { formatBytes as formatSize } from "../tools/render-utils.js";
 export { copyToClipboard } from "../utils/clipboard.js";

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

@@ -1,10 +1,18 @@
+export * from "@oh-my-pi/pi-tui";
+export { decodePrintableKey as decodeKittyPrintable } from "@oh-my-pi/pi-tui";
+/** Report canonical terminal capabilities through the legacy Pi TUI shape. */
+export declare function getCapabilities(): {
+    images: "kitty" | "iterm2" | null;
+    trueColor: boolean;
+    hyperlinks: boolean;
+};
 /**
- * Compatibility shim for legacy extensions importing the package root of
- * `@earendil-works/pi-tui` or `@mariozechner/pi-tui`.
+ * Delete one Kitty graphics image by id, matching the legacy Pi TUI helper.
  *
- * The historical root exported `decodeKittyPrintable`; the canonical TUI now
- * exposes the equivalent, broader `decodePrintableKey` helper. Keep the legacy
- * name available without reintroducing it into the canonical package surface.
+ * Returns the bare control sequence exactly like upstream Pi: legacy callers
+ * (e.g. pi-sprite) apply their own tmux passthrough wrapping, so wrapping here
+ * would double-wrap under tmux and the outer terminal would drop the command.
  */
-export * from "@oh-my-pi/pi-tui";
-export { decodePrintableKey as decodeKittyPrintable } from "@oh-my-pi/pi-tui";
+export declare function deleteKittyImage(imageId: number): string;
+/** Delete every Kitty graphics image using the legacy Pi TUI bare sequence. */
+export declare function deleteAllKittyImages(): string;

package/dist/types/extensibility/shared-events.d.ts

@@ -88,6 +88,8 @@ export interface SessionStopEvent {
     session_id: string;
     session_file?: string;
     stop_hook_active: boolean;
+    /** Cancels handler waiting when the active settle pass is aborted. */
+    signal: AbortSignal;
 }
 /** Preparation data for tree navigation (used by session_before_tree event) */
 export interface TreePreparation {

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

@@ -33,6 +33,15 @@ export declare class AssistantMessageComponent extends Container {
      * pinned in the banner above the editor. Re-renders so the change is visible.
      */
     setErrorPinned(pinned: boolean): void;
+    /**
+     * Expand or collapse the inline turn-ending error block so Ctrl+O
+     * (tool-output expansion) can reveal a long provider error's hidden tail.
+     * Only re-renders when the current message carries a truncatable error, so
+     * toggling expansion across the transcript skips ordinary turns. Works even
+     * while the error is pinned in the banner: the inline block is drawn (in full)
+     * when expanded so the complete body is reachable without sending a message.
+     */
+    setExpanded(expanded: boolean): void;
     isTranscriptBlockFinalized(): boolean;
     /**
      * Settled leading rows for mid-stream native-scrollback commits (see

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

@@ -26,15 +26,21 @@ export declare const SPACE_HOLD_RELEASE_MS = 250;
  * read directly via `pbpaste`/PowerShell).
  */
 export declare function extractPastePathsFromText(text: string): string[] | undefined;
-export declare function extractBracketedPastePaths(data: string): string[] | undefined;
-export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
 /**
  * Same shape as {@link extractBracketedImagePastePaths} but operates on a
  * payload that has already been stripped of the `\x1b[200~` / `\x1b[201~`
  * markers — used by the assembled-paste router in {@link CustomEditor.handleInput}
  * so split bracketed pastes get the same image-path detection as single-chunk ones.
+ *
+ * When the segment splitter fails (an unescaped space in a real path breaks
+ * its every-segment-is-a-path invariant), falls back to
+ * {@link extractWholeTextImagePath}, so a dropped macOS screenshot
+ * (`Screenshot 2026-06-25 at 1.23.45 PM.png`) attaches as an image instead of
+ * degrading to literal text (#6578).
  */
 export declare function extractImagePastePathsFromText(text: string): string[] | undefined;
+export declare function extractBracketedPastePaths(data: string): string[] | undefined;
+export declare function extractBracketedImagePastePaths(data: string): string[] | undefined;
 export declare function extractBracketedImagePastePath(data: string): string | undefined;
 /**
  * Return a single image file path when `text` is exactly one explicit path
@@ -52,12 +58,10 @@ export declare function extractBracketedImagePastePath(data: string): string | u
  *    ambiguous multi-path clipboard text like `/tmp/a.png /tmp/b.png`
  *    still falls through to the text fallback instead of being mis-loaded
  *    as one giant path).
- * 2. Whole-text-as-path pass — only reached when the splitter failed
- *    (every segment must look like an explicit path; an unescaped space in
- *    a real path breaks that). Restricted to inputs anchored by
- *    {@link ABSOLUTE_PATH_PREFIX_REGEX} so prose containing a path-shaped
- *    fragment ("see /tmp/x.png") never hijacks the smart fallback. This
- *    is what recovers macOS screenshot filenames like
+ * 2. {@link extractWholeTextImagePath} — only reached when the splitter
+ *    failed (every segment must look like an explicit path; an unescaped
+ *    space in a real path breaks that). This is what recovers macOS
+ *    screenshot filenames like
  *    `/Users/me/Desktop/Screenshot 2026-06-25 at 1.23.45 PM.png`.
  */
 export declare function extractImagePathFromText(text: string): string | undefined;

package/dist/types/plan-mode/approved-plan.d.ts

@@ -63,6 +63,7 @@ export interface ResolvedApprovedPlan {
 }
 /** Locate the plan file the agent wrote and finalize its title — without
  *  renaming anything. Tries, in order: the slug derived from `extra.title`
- *  (`local://<slug>-plan.md`), the plan path from plan-mode state, then a scan
- *  of recent plan files. Throws a `ToolError` guiding the agent when none exist. */
+ *  (`local://<slug>-plan.md`), a state plan that the artifact scan can't see,
+ *  scanned plan files newest-to-oldest, then the state plan path as a final
+ *  fallback. Throws a `ToolError` guiding the agent when none exist. */
 export declare function resolveApprovedPlan(input: ResolveApprovedPlanInput): Promise<ResolvedApprovedPlan>;

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

@@ -88,28 +88,12 @@ export declare class SecretObfuscator {
     #private;
     constructor(entries: SecretEntry[], key?: string);
     hasSecrets(): boolean;
-    /** Whether stored-session restoration can resolve keyed or legacy placeholders. */
-    hasStoredSecrets(): boolean;
     /** Obfuscate all secrets in text. Bidirectional placeholders for obfuscate mode, one-way for replace. */
     obfuscate(text: string, sharedRegexSecretValues?: ReadonlySet<string>): string;
-    /**
-     * Deobfuscate keyed placeholders back to original secrets for LIVE paths
-     * (provider output, tool-call arguments). Replace-mode is NOT reversed, and
-     * legacy index-derived aliases are intentionally ignored so a prompt-injected
-     * model cannot synthesize one to recover a secret.
-     */
+    /** Deobfuscate keyed placeholders for provider output, tool-call arguments, replay, and display. */
     deobfuscate(text: string): string;
-    /**
-     * Deobfuscate stored session content for replay/display. Identical to
-     * {@link deobfuscate} but additionally honors legacy index-derived aliases so
-     * sessions persisted before keyed placeholders still resume correctly. Use
-     * only for trusted on-disk session content, never for live model output.
-     */
-    deobfuscateStored(text: string): string;
     /** Deep-walk an object, deobfuscating string values for LIVE paths (keyed placeholders only). */
     deobfuscateObject<T>(obj: T): T;
-    /** Deep-walk stored session content, deobfuscating string values incl. legacy aliases. */
-    deobfuscateStoredObject<T>(obj: T): T;
     /** Deep-walk an object, obfuscating all string values. */
     obfuscateObject<T>(obj: T): T;
     collectRegexSecretValuesForObfuscation(text: string): Set<string>;
@@ -119,31 +103,23 @@ export declare class SecretObfuscator {
  * Restore secret placeholders for local display. Only message kinds the model
  * itself authored from obfuscated context carry placeholders — assistant
  * content and the LLM-written branch/compaction summaries. User, developer, and
- * tool-result messages are persisted with their literal text, so a literal
- * `#ABCD#` the operator typed must survive untouched; those roles are never
- * walked.
- *
- * Legacy index-derived aliases (`#XXXX#`) are unkeyed and trivially guessable,
- * so a prompt-injected model can plant one in any record it influences. Every
- * agent-feeding path (resume, history rewrite, branch switch) therefore restores
- * keyed placeholders ONLY (`allowLegacyAliases` false), leaving legacy tokens
- * inert; display-only transcripts that are never re-obfuscated opt in via
- * `allowLegacyAliases`.
+ * tool-result messages are persisted with their literal text, so operator-authored
+ * placeholder-shaped text must survive untouched; those roles are never walked.
  */
-export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined, allowLegacyAliases?: boolean): SessionContext;
-export declare function deobfuscateAgentMessages(obfuscator: SecretObfuscator, messages: AgentMessage[], allowLegacyAliases?: boolean): AgentMessage[];
+export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
+export declare function deobfuscateAgentMessages(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[];
 /**
  * Restore placeholders in assistant content: visible text and tool-call
  * arguments/intent/rawBlock. Thinking and signatures are opaque
  * provider-replay/hidden-reasoning data and pass through byte-identical.
  */
-export declare function deobfuscateAssistantContent(obfuscator: SecretObfuscator, content: AssistantMessage["content"], allowLegacyAliases?: boolean): AssistantMessage["content"];
+export declare function deobfuscateAssistantContent(obfuscator: SecretObfuscator, content: AssistantMessage["content"]): AssistantMessage["content"];
 /**
  * Restore placeholders inside a tool call's arguments. Arguments are arbitrary
  * model-authored JSON, so tool-call arguments are the ONLY place a recursive
  * JSON walk runs.
  */
-export declare function deobfuscateToolArguments(obfuscator: SecretObfuscator, args: Record<string, unknown>, allowLegacyAliases?: boolean): Record<string, unknown>;
+export declare function deobfuscateToolArguments(obfuscator: SecretObfuscator, args: Record<string, unknown>): Record<string, unknown>;
 /** Redact secrets inside a tool call's arguments (same JSON-walk exception as {@link deobfuscateToolArguments}). */
 export declare function obfuscateToolArguments(obfuscator: SecretObfuscator, args: Record<string, unknown>, sharedRegexSecretValues?: ReadonlySet<string>): Record<string, unknown>;
 /**