@oh-my-pi/pi-coding-agent 17.2.1 → 17.2.2

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

@@ -40,6 +40,7 @@ interface AppKeybindings {
     "app.plan.toggle": true;
     "app.history.search": true;
     "app.stt.toggle": true;
+    "app.live.toggle": true;
 }
 export type AppKeybinding = keyof AppKeybindings;
 declare module "@oh-my-pi/pi-tui" {
@@ -195,7 +196,7 @@ export declare const KEYBINDINGS: {
         readonly description: "Suspend application";
     };
     readonly "app.display.reset": {
-        readonly defaultKeys: "ctrl+l";
+        readonly defaultKeys: "alt+l";
         readonly description: "Reset terminal display";
     };
     readonly "app.thinking.cycle": {
@@ -322,6 +323,10 @@ export declare const KEYBINDINGS: {
         readonly defaultKeys: [];
         readonly description: "Toggle speech-to-text (default gesture: hold Space)";
     };
+    readonly "app.live.toggle": {
+        readonly defaultKeys: "ctrl+l";
+        readonly description: "Start or stop live voice mode (/live)";
+    };
 };
 /** Controls inherited keybinding lookup when creating a manager for a named profile. */
 export interface KeybindingsCreateOptions {

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

@@ -5006,7 +5006,7 @@ export declare const SETTINGS_SCHEMA: {
             } | {
                 readonly value: "xai";
                 readonly label: "xAI";
-                readonly description: "Grok web search via xAI Responses API (requires XAI_API_KEY)";
+                readonly description: "Grok web search via xAI Responses API (uses SuperGrok/X Premium+ OAuth via /login xai-oauth, or XAI_API_KEY)";
             } | {
                 readonly value: "zai";
                 readonly label: "Z.AI";
@@ -5110,7 +5110,7 @@ export declare const SETTINGS_SCHEMA: {
             } | {
                 readonly value: "xai";
                 readonly label: "xAI";
-                readonly description: "Grok web search via xAI Responses API (requires XAI_API_KEY)";
+                readonly description: "Grok web search via xAI Responses API (uses SuperGrok/X Premium+ OAuth via /login xai-oauth, or XAI_API_KEY)";
             } | {
                 readonly value: "zai";
                 readonly label: "Z.AI";
@@ -5856,7 +5856,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "providers";
             readonly group: "Services";
             readonly label: "Codex Auto-Redeem Saved Resets";
-            readonly description: "When a turn is blocked by the Codex weekly limit on the active account and no other account is available, run the conservative saved-reset check. unset asks before spending the first eligible reset, yes spends eligible resets without prompting, and no disables the check entirely. Requires retries enabled.";
+            readonly description: "Spend saved Codex rate-limit resets automatically: restore an account blocked by an exhausted 5h or weekly window when a turn is stuck and no other account can take over, and salvage credits that are about to expire. unset asks before the first spend, yes spends without prompting, and no disables both checks.";
             readonly options: readonly [{
                 readonly value: "unset";
                 readonly label: "Unset";
@@ -5879,7 +5879,7 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "providers";
             readonly group: "Services";
             readonly label: "Codex Auto-Redeem Min Block";
-            readonly description: "Only auto-redeem when the natural weekly reset is at least this many minutes away (don't spend a ~30-day credit to save a short wait).";
+            readonly description: "Only auto-redeem when the natural unblock — the latest reset among the exhausted 5h/weekly windows — is at least this many minutes away (don't spend a scarce credit to save a short wait). Raise it (e.g. 360) to ignore 5h-only blocks.";
         };
     };
     readonly "codexResets.keepCredits": {
@@ -5889,7 +5889,17 @@ export declare const SETTINGS_SCHEMA: {
             readonly tab: "providers";
             readonly group: "Services";
             readonly label: "Codex Auto-Redeem Reserve";
-            readonly description: "Never auto-spend below this many saved resets (0 = the last credit may be spent automatically).";
+            readonly description: "Never auto-spend below this many saved resets (0 = the last credit may be spent automatically). Credits about to expire are exempt — a reserved credit that expires preserves nothing.";
+        };
+    };
+    readonly "codexResets.salvageHorizonHours": {
+        readonly type: "number";
+        readonly default: 12;
+        readonly ui: {
+            readonly tab: "providers";
+            readonly group: "Services";
+            readonly label: "Codex Reset Salvage Horizon";
+            readonly description: "Spend a saved Codex reset automatically when it would otherwise expire within this many hours and either chat window (5h or weekly) has meaningful usage to restore (0 disables expiry salvage).";
         };
     };
     readonly "provider.appendOnlyContext": {
@@ -6319,6 +6329,7 @@ export interface CodexResetsSettings {
     autoRedeem: CodexAutoRedeemMode;
     minBlockedMinutes: number;
     keepCredits: number;
+    salvageHorizonHours: number;
 }
 export interface GcSettings {
     blobs: boolean;

package/dist/types/edit/hashline/block-resolver.d.ts

@@ -1,9 +1,9 @@
 /**
- * Tree-sitter-backed {@link BlockResolver} for the hashline block replace
- * operator. Bridges the pure hashline seam to the native `blockRangeAt`
- * primitive in `@oh-my-pi/pi-natives`, which infers the language from the file
- * path and returns the 1-indexed line span of the syntactic block beginning on
- * the requested line (or `null` when none can be resolved).
+ * Tree-sitter-backed {@link BlockResolver} for the hashline `N*` locator.
+ * Bridges the pure hashline seam to the native `blockRangeAt` primitive in
+ * `@oh-my-pi/pi-natives`, which infers the language from the file path and
+ * returns the 1-indexed line span of the syntactic block beginning on the
+ * requested line (or `null` when none can be resolved).
  */
 import type { BlockResolver } from "@oh-my-pi/hashline";
 export declare const nativeBlockResolver: BlockResolver;

package/dist/types/edit/hashline/diff.d.ts

@@ -14,10 +14,10 @@ export interface HashlineDiffOptions {
     skipHashValidation?: boolean;
     /**
      * Clipboard register shared across the sections of one patch preview.
-     * `CUT` in an earlier section feeds `PASTE` in a later one, so the preview
-     * matches apply. Multi-section previews MUST thread one register through
-     * sections in patch order; omitted, each section gets a
-     * private register (same-file cut/paste still previews correctly).
+     * `CUT` in an earlier section feeds a register-backed `PUT` in a later one,
+     * so the preview matches apply. Multi-section previews MUST thread one
+     * register through sections in patch order; omitted, each section gets a
+     * private register (same-file cut/put still previews correctly).
      */
     clipboard?: Clipboard;
 }

package/dist/types/eval/executor-base.d.ts

@@ -90,6 +90,33 @@ export declare function attachSessionOwner(session: {
     ownerIds: Set<string>;
     hasFallbackOwner: boolean;
 }, sessionId: string, ownerId: string | undefined): void;
+/** Owner registry shared by every language's live/starting session records. */
+export interface SessionOwners {
+    ownerIds: Set<string>;
+    hasFallbackOwner: boolean;
+}
+/**
+ * Resolve the session key an owner's eval cell runs on, forking `reset` away
+ * from shared kernels.
+ *
+ * Eval sessions are shared across agents by design (subagents inherit the
+ * parent's eval session id), so honoring `reset` on a co-owned kernel would
+ * destroy every other agent's state — including cells executing at that
+ * moment. When the requester does not exclusively own the live base session,
+ * its reset resolves to a deterministic per-owner fork key: the requester
+ * starts a fresh private kernel while co-owners keep the shared one. Once
+ * forked, the owner keeps resolving to its fork, and per-owner dispose reaps
+ * the fork since the requester is its only registered owner.
+ */
+export declare function resolveOwnerScopedSessionKey(options: {
+    baseKey: string;
+    ownerId: string | undefined;
+    reset: boolean;
+    /** True when a live or starting session exists under `key`. */
+    hasSession: (key: string) => boolean;
+    /** Owner registry for the session under `key`, when inspectable. */
+    getOwners: (key: string) => SessionOwners | undefined;
+}): string;
 export interface ExecuteWithKernelBaseParams<TOptions extends KernelExecutorBaseOptions, TEnv extends KernelEnvPatch = Record<string, string | null>> {
     kernel: GenericKernel<TEnv>;
     code: string;

package/dist/types/eval/js/context-manager.d.ts

@@ -18,6 +18,8 @@ export declare function setJsEvalWorkerThreadForTests(enabled: boolean): boolean
 export declare function executeInVmContext(options: {
     sessionKey: string;
     sessionId: string;
+    /** Logical owner identifier; scopes `reset` on shared contexts and retained-worker cleanup. */
+    ownerId?: string;
     cwd: string;
     session: ToolSession;
     localRoots?: Record<string, string>;
@@ -31,6 +33,11 @@ export declare function executeInVmContext(options: {
 }>;
 export declare function resetVmContext(sessionKey: string): Promise<void>;
 export declare function disposeAllVmContexts(): Promise<void>;
+/**
+ * Shut down retained JS contexts owned solely by `ownerId` (e.g. a subagent's
+ * private fork); shared contexts just drop the owner registration.
+ */
+export declare function disposeVmContextsByOwner(ownerId: string): Promise<void>;
 /**
  * Smoke probe: spawn the JS evaluator through the worker-host entry and prove
  * it answers the `init` handshake in a real isolated subprocess (not the inline

package/dist/types/eval/js/executor.d.ts

@@ -15,6 +15,8 @@ export interface JsExecutorOptions {
     onStatus?: (event: JsStatusEvent) => void;
     signal?: AbortSignal;
     sessionId: string;
+    /** Logical owner identifier; scopes `reset` on shared contexts and retained-worker cleanup. */
+    kernelOwnerId?: string;
     reset?: boolean;
     sessionFile?: string;
     artifactPath?: string;

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

@@ -1,7 +1,7 @@
 /**
  * Extension runner - executes extensions and manages their lifecycle.
  */
-import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AgentMessage, AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMetadata } from "@oh-my-pi/pi-ai";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import type { ModelRegistry } from "../../config/model-registry.js";
@@ -65,7 +65,6 @@ export declare class ExtensionRunner {
     #private;
     private readonly extensions;
     private readonly runtime;
-    private readonly cwd;
     private readonly sessionManager;
     private readonly modelRegistry;
     private readonly settings?;
@@ -74,7 +73,51 @@ export declare class ExtensionRunner {
     markToolCallEmitted(toolCallId: string, toolName: string): void;
     /** Consumes a {@link markToolCallEmitted} marker; true when the loop already emitted. */
     consumeToolCallEmitted(toolCallId: string, toolName: string): boolean;
-    constructor(extensions: Extension[], runtime: ExtensionRuntime, cwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined, getAsyncJobSnapshot?: () => AsyncJobSnapshot | null);
+    /** Wires the native-tool resolver used by {@link invokeNativeTool}. */
+    setNativeToolResolver(resolve: (name: string) => {
+        tool: AgentTool;
+        makeContext: () => AgentToolContext;
+    } | undefined): void;
+    /** Whether a native built-in of `name` is available to delegate to. */
+    hasNativeTool(name: string): boolean;
+    /**
+     * Run the native built-in of `name` with `params` and return its result — the delegation target
+     * of a same-tool `ctx.invokeTool`. Calls the unwrapped native `execute` directly with the loop's
+     * ordinary tool context, so it inherits the caller's already-granted approval (the caller is the
+     * same tool) rather than re-running the gate. `depth` guards a wrapper that recurses into itself;
+     * it is per call chain (threaded from the caller), not session-global, so concurrent independent
+     * delegations do not interfere.
+     */
+    invokeNativeTool<TDetails = unknown>(name: string, params: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+        onUpdate?: AgentToolUpdateCallback<TDetails>;
+        depth?: number;
+        /**
+         * The caller tool's own context. Reused for the native call so metadata the native tool
+         * reads — `toolCall` (write/edit LSP batch flushing) and provider metadata /
+         * `providerSafetyApproved` (computer) — is preserved. Falls back to a fresh session tool
+         * context only when the caller had none.
+         */
+        callerContext?: AgentToolContext;
+    }): Promise<AgentToolResult<TDetails>>;
+    constructor(extensions: Extension[], runtime: ExtensionRuntime, 
+    /** Ignored: `cwd` is always read live via the `cwd` getter below, not cached here. */
+    _initialCwd: string, sessionManager: SessionManager, modelRegistry: ModelRegistry, getMemory?: () => MemoryRuntimeContext | undefined, settings?: Settings | undefined, localProtocolOptions?: LocalProtocolOptions | undefined, getAsyncJobSnapshot?: () => AsyncJobSnapshot | null);
+    /**
+     * Live session directory, not a session-start snapshot: `/move`
+     * (`SessionManager.moveTo()`) relocates the owning session by updating
+     * `sessionManager`'s own `#cwd`, not a process-global. Reading it here
+     * via the getter — instead of caching the constructor-time value in a
+     * field — keeps every `ExtensionContext` built below in sync with this
+     * session's actual, current directory. Deliberately `sessionManager.getCwd()`
+     * rather than `getProjectDir()`: the latter is a single process-wide value
+     * that only the interactive TUI's `/move` handler happens to also update
+     * (`InteractiveModeContext#applyCwdChange`) — an SDK/ACP host running
+     * several concurrent sessions each with their own `cwd` (see
+     * `CreateAgentSessionOptions.cwd`) must never have one session's move
+     * leak into another's `ctx.cwd` by reading a shared global.
+     */
+    get cwd(): string;
     initialize(actions: ExtensionActions, contextActions: ExtensionContextActions, commandContextActions?: ExtensionCommandContextActions, uiContext?: ExtensionUIContext): void;
     /**
      * Forward a `credential_disabled` event from `AuthStorage` to extension handlers.
@@ -137,8 +180,24 @@ export declare class ExtensionRunner {
         path: string;
     }>;
     getCommand(name: string): RegisteredCommand | undefined;
-    /** Creates an extension context, optionally scoped to a provider request model. */
-    createContext(model?: Model): ExtensionContext;
+    /**
+     * Creates an extension context, optionally scoped to a provider request model.
+     *
+     * `delegation` wires the same-tool `ctx.invokeTool` for a re-registered built-in: when `toolName`
+     * names an existing native built-in, the context carries an `invokeTool` that runs it (see
+     * {@link invokeNativeTool}). The rest inherits the wrapper's own call so a bare
+     * `ctx.invokeTool(params)` behaves like the outer call — `context` preserves `toolCall`/provider
+     * metadata, `signal`/`onUpdate` default to the wrapper's own channels so aborting the outer tool
+     * call stops the native one and native progress still streams, and `depth` bounds recursion per
+     * call chain. Explicit options passed to `invokeTool` override the inherited `signal`/`onUpdate`.
+     */
+    createContext(model?: Model, delegation?: {
+        toolName: string;
+        depth?: number;
+        context?: AgentToolContext;
+        signal?: AbortSignal;
+        onUpdate?: AgentToolUpdateCallback;
+    }): ExtensionContext;
     /**
      * Request a graceful shutdown. Called by extension tools and event handlers.
      */

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

@@ -325,6 +325,21 @@ export interface ExtensionContext {
     setTimeout(callback: (...args: unknown[]) => void, ms?: number, ...args: unknown[]): Timer;
     /** Clear a timer scheduled via {@link setInterval} or {@link setTimeout}. */
     clearTimer(timer: Timer): void;
+    /**
+     * Run the NATIVE built-in implementation of the tool this handler re-registered, with `params`,
+     * and return its result. Lets a tool that re-registers a built-in (e.g. wrapping `write` to add
+     * logging or a policy check) delegate to the original instead of reimplementing it — the native
+     * tool performs its own side effects and internal bookkeeping.
+     *
+     * Delegation is same-tool only: it invokes the built-in of the SAME name as the registering tool,
+     * never an arbitrary target, so it cannot escalate past the approval already granted for this
+     * call. Present only when a native built-in of that name exists (undefined otherwise, e.g. for a
+     * net-new tool that shadows no built-in). Recursion is depth-guarded per call chain.
+     */
+    invokeTool?<TDetails = unknown>(params: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+        onUpdate?: AgentToolUpdateCallback<TDetails>;
+    }): Promise<AgentToolResult<TDetails>>;
 }
 /**
  * Extended context for command handlers.

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

@@ -20,7 +20,7 @@ export declare class RegisteredToolAdapter implements AgentTool<any, any, any> {
     renderResult?: (result: any, options: any, theme: any, args?: any) => any;
     readonly loadMode: ToolLoadMode;
     constructor(registeredTool: RegisteredTool, runner: ExtensionRunner);
-    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, _context?: AgentToolContext): Promise<AgentToolResult<unknown, unknown>>;
+    execute(toolCallId: string, params: any, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<any>, context?: AgentToolContext): Promise<AgentToolResult<unknown, unknown>>;
 }
 /**
  * Backward-compatible factory function wrapper.

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

@@ -398,7 +398,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 { compact, estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
 export { CONFIG_DIR_NAME } from "@oh-my-pi/pi-utils";
 export { parseArgs } from "../cli/args.js";
 export * from "../index.js";

package/dist/types/live/visualizer.d.ts

@@ -1,10 +1,12 @@
-import { type Component } from "@oh-my-pi/pi-tui";
+import { type Component, type KeyId } from "@oh-my-pi/pi-tui";
 /** Distinct states of a realtime call connection. */
 export type LivePhase = "connecting" | "listening" | "working" | "speaking" | "muted" | "error";
 /** Configuration callbacks for user interactions in the visualizer. */
 export interface LiveVisualizerOptions {
     onStop(): void;
     onToggleMute(): void;
+    /** Configured `app.live.toggle` chords that also end the call (Ctrl+L by default). */
+    stopKeys?: readonly KeyId[];
 }
 /** A compact, fixed-height terminal component for displaying a realtime call. */
 export declare class LiveVisualizer implements Component {

package/dist/types/modes/acp/acp-agent.d.ts

@@ -23,9 +23,9 @@ type CreateAcpSession = (cwd: string) => Promise<AgentSession>;
  * symmetric with every other `sessionUpdate` call in this file
  * (`record.session.sessionId` is always evaluated at emit time).
  *
- * The non-elicitation surface (custom components, editor, theming,
- * terminal input) remains stubbed — ACP clients render those themselves
- * or not at all. Capability gating respects the client's `initialize`
+ * The non-elicitation surface (custom components, theming, terminal
+ * input) remains stubbed — ACP clients render those themselves or not
+ * at all. Capability gating respects the client's `initialize`
  * advertisement.
  */
 export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, clientCapabilities: ClientCapabilities | undefined): ExtensionUIContext;

package/dist/types/modes/components/keybinding-hints.d.ts

@@ -2,7 +2,7 @@
  * Utilities for formatting keybinding hints in the UI.
  */
 import { type Keybinding } from "@oh-my-pi/pi-tui";
-import type { AppKeybinding, KeybindingsManager } from "../../config/keybindings.js";
+import { type AppKeybinding, type KeybindingsManager } from "../../config/keybindings.js";
 /**
  * Get display string for an editor action.
  */

package/dist/types/modes/controllers/mcp-command-controller.d.ts

@@ -69,4 +69,17 @@ export declare class MCPCommandController {
     handle(text: string): Promise<void>;
     /** Reauthorize a server after a tool-level OAuth challenge. */
     handleMCPAuthChallenge(name: string, challenge: MCPAuthChallenge): Promise<MCPServerConfig | undefined>;
+    /**
+     * Reconnect every configured MCP server and rebind the session's MCP tools.
+     *
+     * Disconnects all live connections, rediscovers `.mcp.json` configs, and
+     * calls `session.refreshMCPTools(...)` so config edits take effect without a
+     * restart. Public because `/reload-plugins` reuses it alongside `/mcp reload`
+     * and the config-mutation flows in this controller.
+     *
+     * Discovery options are derived from settings so the reload honors the same
+     * opt-outs as startup — notably `mcp.enableProjectConfig: false`, which must
+     * keep project `.mcp.json` servers from being started on reload.
+     */
+    reloadServers(): Promise<void>;
 }

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

@@ -382,6 +382,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handleCtrlC(): void;
     handleCtrlD(): void;
     handleCtrlZ(): void;
+    resetDisplayAfterAppearanceRefresh(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
     /** Queue slash-command input behind the active turn. */

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

@@ -292,7 +292,7 @@ export declare function setAutoThemeMapping(mode: "dark" | "light", themeName: s
  * The terminal layer queries OSC 11 (background color) and computes luminance;
  * Mode 2031 notifications trigger re-queries rather than providing the value directly.
  */
-export declare function onTerminalAppearanceChange(mode: "dark" | "light"): void;
+export declare function onTerminalAppearanceChange(mode: "dark" | "light", event?: ThemeChangeEvent): void;
 export declare function setThemeInstance(themeInstance: Theme): void;
 /**
  * Set the symbol preset override, recreating the theme with the new preset.

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

@@ -375,6 +375,8 @@ export interface InteractiveModeContext {
     handleCtrlC(): void;
     handleCtrlD(): void;
     handleCtrlZ(): void;
+    /** Re-query terminal appearance for an explicit display reset, then immediately replay the display. */
+    resetDisplayAfterAppearanceRefresh(): void;
     handleDequeue(): void;
     handleImagePaste(): Promise<boolean>;
     /** Queue a message for delivery only after the active agent turn would stop. */

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

@@ -12,6 +12,14 @@ import { type SecretEntry } from "./obfuscator.js";
 export declare function getSecretPlaceholderKey(keyDir?: string): Promise<string>;
 /** Return an existing placeholder key for redaction without creating a new key file. */
 export declare function getExistingSecretPlaceholderKey(keyDir?: string): Promise<string | undefined>;
+/**
+ * Synchronous variant of `getSecretPlaceholderKey` for the lazy key provider
+ * `SecretObfuscator` invokes inside its synchronous `obfuscate()` path when a
+ * built-in credential-pattern entry first matches session content. Never
+ * throws: an unreadable or unwritable key file degrades to a process-ephemeral
+ * key (with a warning) instead of breaking the session.
+ */
+export declare function getSecretPlaceholderKeySync(keyDir?: string): string;
 export { deobfuscateSessionContext, deobfuscateToolArguments, obfuscateMessages, obfuscateProviderContext, type SecretEntry, SecretObfuscator, secretEntriesNeedPlaceholderKey, secretEntryNeedsPlaceholderKey, } from "./obfuscator.js";
 /**
  * Load secrets from project-local and global secrets.yml files.
@@ -20,3 +28,17 @@ export { deobfuscateSessionContext, deobfuscateToolArguments, obfuscateMessages,
 export declare function loadSecrets(cwd: string, agentDir: string): Promise<SecretEntry[]>;
 /** Collect environment variable values that look like secrets. */
 export declare function collectEnvSecrets(): SecretEntry[];
+/**
+ * Built-in entries covering credential-shaped tokens (GitHub/GitLab/OpenAI-style
+ * API keys) that are NOT configured via secrets.yml or the environment. Without
+ * these, such a token in a tool result falls through to pi-ai's irreversible
+ * provider-boundary redaction (`[openai_token_redacted]`); the model then echoes
+ * that placeholder into edit-tool `old_text`, which can never match the real
+ * bytes on disk (issue #6968). Routing the same shapes through the obfuscator
+ * mints reversible keyed placeholders that `deobfuscateToolArguments` restores
+ * before tool execution, keeping exact-match edits working while the credential
+ * bytes still never reach the provider. Unlike the pi-ai redaction there is no
+ * entropy gate here — a false positive only over-obfuscates, which stays
+ * transparent because the round trip is lossless.
+ */
+export declare function builtinCredentialSecretEntries(): SecretEntry[];

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

@@ -86,7 +86,7 @@ export declare function secretEntriesNeedPlaceholderKey(entries: SecretEntry[]):
 export declare function stripPendingSecretPlaceholderSuffix(text: string): string;
 export declare class SecretObfuscator {
     #private;
-    constructor(entries: SecretEntry[], key?: string);
+    constructor(entries: SecretEntry[], key?: string | (() => string));
     hasSecrets(): boolean;
     /** Obfuscate all secrets in text. Bidirectional placeholders for obfuscate mode, one-way for replace. */
     obfuscate(text: string, sharedRegexSecretValues?: ReadonlySet<string>): string;

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

@@ -17,6 +17,7 @@ import type { FileSlashCommand } from "../extensibility/slash-commands.js";
 import type { SecretObfuscator } from "../secrets/obfuscator.js";
 import type { ConfiguredThinkingLevel } from "../thinking.js";
 import type { XdevState } from "../tools/xdev.js";
+import type { CodexAutoRedeemCoordinator } from "./codex-auto-reset.js";
 import type { SessionManager } from "./session-manager.js";
 /** Maximum time the interactive shutdown path waits for Mnemopi consolidation. */
 export declare const SHUTDOWN_CONSOLIDATE_BUDGET_MS = 1500;
@@ -148,6 +149,8 @@ export interface AgentSessionConfig {
     initialAdvisorCosts?: ReadonlyMap<string, number>;
     /** Prefer websocket transport for OpenAI Codex requests when supported. */
     preferWebsockets?: boolean;
+    /** Codex saved-reset coordinator; defaults to the process-wide singleton so concurrent sessions can't double-spend. Inject a fresh one in tests. */
+    codexResetCoordinator?: CodexAutoRedeemCoordinator;
     /** Provider payload hook used by the active session request path. */
     onPayload?: SimpleStreamOptions["onPayload"];
     /** Provider response hook used by the active session request path. */
@@ -161,6 +164,7 @@ export interface AgentSessionConfig {
     /** System prompt builder that can consider tool availability. */
     rebuildSystemPrompt?: (toolNames: string[], tools: Map<string, AgentTool>) => Promise<{
         systemPrompt: string[];
+        xdevCatalogNames?: readonly string[];
     }>;
     /** Local calendar date provider used by prompt-cache invalidation. */
     getLocalCalendarDate?: () => string;

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

@@ -540,6 +540,13 @@ export declare class AgentSession {
     get skillWarnings(): readonly SkillWarning[];
     getTodoPhases(): TodoPhase[];
     setTodoPhases(phases: TodoPhase[]): void;
+    /**
+     * Start automatic title generation when the session and input are eligible.
+     * Interactive and CLI-bootstrap submissions share this gate so every first
+     * user message persists titles with the same environment, signal, and local
+     * extension-command policy.
+     */
+    maybeStartTitleGeneration(firstMessage: string, onStart?: () => void): void;
     /**
      * Generate an automatic session title tied to this session's lifecycle.
      * Input and replan callers share the signal so disposal cancels provider and
@@ -744,6 +751,8 @@ export declare class AgentSession {
     deliverIrcMessage(msg: IrcMessage, opts?: {
         expectsReply?: boolean;
     }): Promise<"injected" | "woken">;
+    /** Installs task-executor monitoring around autonomous IRC wake turns. */
+    setIrcWakeTurnObserver(observer: ((records: CustomMessage[]) => ((error?: unknown) => void | Promise<void>) | undefined) | undefined): void;
     /** Emits an IRC relay observation for UI rendering without persisting it. */
     emitIrcRelayObservation(record: CustomMessage): void;
     /**