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

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

@@ -1,6 +1,6 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import { type SecretObfuscator } from "../secrets/obfuscator.js";
+import type { SecretObfuscator } from "../secrets/obfuscator.js";
 /**
  * Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core
  * `Agent`. `state.error` mirrors `Agent.state.error`: provider/stream failures

package/dist/types/config/custom-models.d.ts

@@ -0,0 +1,31 @@
+import type { Api, Model, ModelSpec, RemoteCompactionConfig } from "@oh-my-pi/pi-ai/types";
+import { type HeaderSource } from "./model-config-values.js";
+import { type ModelPatch } from "./model-patch.js";
+import type { ModelOverride, ProviderAuthMode } from "./models-config-schema.js";
+export interface CustomModelDefinitionLike extends ModelPatch {
+    id: string;
+    api?: Api;
+    baseUrl?: string;
+    cost?: Model<Api>["cost"];
+}
+export interface CustomModelBuildOptions {
+    useDefaults: boolean;
+}
+export interface CustomModelOverlay extends ModelPatch {
+    id: string;
+    provider: string;
+    api: Api;
+    baseUrl: string;
+    cost?: Model<Api>["cost"];
+    isOAuth?: boolean;
+}
+export declare function mergeAuthHeaderSources(sources: readonly HeaderSource[], authHeader: boolean | undefined, apiKeyConfig: string | undefined): Record<string, string> | undefined;
+export declare function buildCustomModelOverlay(providerName: string, providerBaseUrl: string, providerApi: Api | undefined, providerHeaders: Record<string, string> | undefined, providerApiKey: string | undefined, authHeader: boolean | undefined, providerCompat: ModelSpec<Api>["compat"] | undefined, providerAuth: ProviderAuthMode | undefined, providerRemoteCompaction: RemoteCompactionConfig<Api> | undefined, modelDef: CustomModelDefinitionLike): CustomModelOverlay | undefined;
+export declare function finalizeCustomModel(model: CustomModelOverlay, options: CustomModelBuildOptions): Model<Api>;
+export declare function normalizeSuppressedSelector(selector: string, hasLiveModel?: (provider: string, id: string) => boolean): string;
+/**
+ * Look up a model's override, falling back to entries keyed by retired
+ * effort-tier variant ids (models.yml authored before collapsing). A raw key
+ * only re-binds when no live model holds that id.
+ */
+export declare function resolveModelOverrideWithAliases(overrides: Map<string, ModelOverride>, model: Model<Api>, hasLiveModel: (provider: string, id: string) => boolean): ModelOverride | undefined;

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

@@ -0,0 +1,19 @@
+export declare function isCommandConfigValue(valueConfig: string | undefined): valueConfig is string;
+export interface CommandApiKeyResolution {
+    configured: boolean;
+    value?: string;
+}
+/**
+ * Resolve a models.yml/models.yaml secret/config value to an actual value.
+ * `!cmd` runs a shell command and returns trimmed stdout, otherwise env vars are
+ * checked first and the input falls back to a literal value.
+ */
+export declare function resolveConfigValue(valueConfig: string): string | undefined;
+export type HeaderSource = Record<string, string> | undefined;
+interface HeaderResolutionOptions {
+    authHeader?: boolean;
+    apiKeyConfig?: string;
+}
+export declare function createLiveConfigHeaders(sources: readonly HeaderSource[], options?: HeaderResolutionOptions): Record<string, string> | undefined;
+export declare function resolveConfigHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined;
+export {};

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

@@ -0,0 +1,93 @@
+import type { Api, Model, ModelSpec, RemoteCompactionConfig, ThinkingConfig } from "@oh-my-pi/pi-ai/types";
+import type { ModelOverride } from "./models-config-schema.js";
+/** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */
+export interface ProviderOverride {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    apiKey?: string;
+    authHeader?: boolean;
+    compat?: ModelSpec<Api>["compat"];
+    remoteCompaction?: RemoteCompactionConfig<Api>;
+    transport?: Model<Api>["transport"];
+}
+/**
+ * Merge a freshly discovered model with the matching bundled/configured entry
+ * (or a runtime provider override when no bundled entry exists).
+ *
+ * `baseUrl` resolution priority:
+ *   1. User-set `providerOverride.baseUrl` (explicit override in models.json)
+ *   2. Discovered baseUrl (xiaomi `tp-` token-plan keys resolve to
+ *      `token-plan-sgp.xiaomimimo.com` at discovery time)
+ *   3. Existing bundled baseUrl (the host baked into `models.json`)
+ *
+ * `transport` resolution priority:
+ *   1. `providerOverride.transport` (e.g. `pi-native` for auth-gateway users)
+ *   2. `existing.transport` (carried over from boot-time override application)
+ *   3. `model.transport` (rarely set — discovery defaults omit it)
+ *
+ * Without (1), the user's override would lose to discovery; without (2)
+ * preferred over (3), the bundled `api.xiaomimimo.com` would shadow the
+ * tp- token-plan host and produce 401s on the first stream call.
+ * Without explicit transport propagation, an openrouter (or any) entry
+ * marked `transport: pi-native` in models.yml silently reverts to the
+ * default openai-completions transport after the background catalog
+ * refresh — so the first `/model` switch after boot hits the raw OpenAI
+ * chat-completions URL instead of the gateway's `/v1/pi/stream` (#2555).
+ * See `xiaomi-tp-discovery-merge.test.ts` and the `refresh()` baseUrl-override
+ * regression in `model-registry.test.ts`.
+ */
+export declare function mergeDiscoveredModel<TApi extends Api>(model: Model<TApi>, existing: Model<Api> | undefined, providerOverride?: Pick<ProviderOverride, "baseUrl" | "compat" | "headers" | "remoteCompaction" | "transport">): Model<TApi>;
+export declare const AUTHORITATIVE_RUNTIME_CATALOG_PROVIDERS: Set<string>;
+export declare function providersWithAuthoritativeProjectCatalog(models: readonly Model<Api>[]): Set<string>;
+export declare function dropProviderModels(models: readonly Model<Api>[], providers: ReadonlySet<string>): Model<Api>[];
+/**
+ * Merge `incoming` entries into a copy of `base`, keyed by `provider`+`id`.
+ * Matches are replaced with `combine(existing, entry)`; new entries are
+ * appended as `combine(undefined, entry)`.
+ */
+export declare function mergeByModelKey<T extends {
+    provider: string;
+    id: string;
+}>(base: readonly Model<Api>[], incoming: readonly T[], combine: (existing: Model<Api> | undefined, entry: T) => Model<Api>): Model<Api>[];
+export declare function mergeCompat<TBase extends object, TOverride extends object>(baseCompat: TBase | null | undefined, overrideCompat: TOverride | null | undefined): (TBase & TOverride) | TBase | TOverride | undefined;
+export declare function mergeRemoteCompactionConfig(baseConfig: RemoteCompactionConfig<Api> | undefined, overrideConfig: RemoteCompactionConfig<Api> | undefined): RemoteCompactionConfig<Api> | undefined;
+export declare function mergeProviderRemoteCompactionConfig(modelConfig: RemoteCompactionConfig<Api> | undefined, providerConfig: RemoteCompactionConfig<Api> | undefined): RemoteCompactionConfig<Api> | undefined;
+/**
+ * Project a built model back to spec shape for the model-manager/cache
+ * boundary: sparse compat comes from `compatConfig`, never from the resolved
+ * record.
+ */
+export declare function toModelSpec<TApi extends Api>(model: Model<TApi>): ModelSpec<TApi>;
+/**
+ * The patchable subset of `Model` fields shared by `modelOverrides` entries,
+ * custom model definitions, and parsed custom-model overlays. `undefined`
+ * always means "leave the base value alone".
+ */
+export interface ModelPatch {
+    name?: string;
+    reasoning?: boolean;
+    thinking?: ThinkingConfig;
+    input?: ("text" | "image")[];
+    supportsTools?: boolean;
+    cost?: Partial<Model<Api>["cost"]>;
+    contextWindow?: number;
+    maxTokens?: number;
+    omitMaxOutputTokens?: boolean;
+    headers?: Record<string, string>;
+    compat?: ModelSpec<Api>["compat"];
+    contextPromotionTarget?: string;
+    compactionModel?: string;
+    remoteCompaction?: RemoteCompactionConfig<Api>;
+    premiumMultiplier?: number;
+}
+/**
+ * How a patch treats the base model's transport metadata (headers/compat):
+ * - `merge`: fold the patch into the base's (modelOverrides semantics).
+ * - `replace`: the patch owns transport wholesale — same-id custom definitions
+ *   already folded provider-level headers/compat in during parsing, so bundled
+ *   transport metadata must not be re-merged (see `#mergeCustomModels`).
+ */
+type ModelTransportPolicy = "merge" | "replace";
+export declare function applyModelPatch(base: Model<Api>, patch: ModelPatch, transport: ModelTransportPolicy): Model<Api>;
+export declare function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<Api>;
+export {};

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

@@ -0,0 +1,51 @@
+import type { Api, Model } from "@oh-my-pi/pi-ai/types";
+import { type OpenAICodexAccount } from "@oh-my-pi/pi-catalog/provider-models";
+import type { AuthStorage, OAuthCredential } from "../session/auth-storage.js";
+export declare const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[];
+/**
+ * Hard bound for extension-provided fetchDynamicModels to prevent indefinite hangs
+ * during runtime provider discovery. Uses a cancellable manual timer (not AbortSignal.timeout)
+ * so a successful fast path does not leave an armed timeout signal for concurrent GC.
+ */
+export declare const RUNTIME_DYNAMIC_MODEL_FETCH_TIMEOUT_MS = 15000;
+export declare const BUILT_IN_DISCOVERY_CACHE_TTL_MS: number;
+export declare const BUILT_IN_DISCOVERY_NON_AUTHORITATIVE_RETRY_MS: number;
+export declare const kNoAuth = "N/A";
+export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
+export declare function isDiscoveryBearerApiKey(apiKey: string | undefined | null): apiKey is string;
+/**
+ * Wraps an extension-provided fetchDynamicModels call with a hard timeout.
+ * Uses a cancellable manual timer (not AbortSignal.timeout) so that a fast
+ * successful path does not leave an armed timeout signal for concurrent GC.
+ * The inner fetcher does not receive a signal (extension contract has none).
+ */
+export declare function withRuntimeDynamicModelsTimeout<T>(timeoutMs: number, run: () => Promise<T>): Promise<T>;
+export interface BuiltInDiscoveryResult {
+    models: Model<Api>[];
+    authoritativeProviders: Set<string>;
+}
+export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
+export interface ProviderDiscoveryState {
+    provider: string;
+    status: ProviderDiscoveryStatus;
+    optional: boolean;
+    stale: boolean;
+    fetchedAt?: number;
+    models: string[];
+    error?: string;
+}
+export declare function extractGoogleOAuthToken(value: string | undefined): string | undefined;
+export declare function getOAuthCredentialsForProvider(authStorage: AuthStorage, provider: string): OAuthCredential[];
+/**
+ * Resolve every configured Codex OAuth account for catalog discovery, refreshing
+ * each credential exactly once. Codex `/models` is account-scoped, so discovery
+ * must fetch per account and union the results; resolving a single access token
+ * (as before) hid models available only through a sibling account (#6265).
+ *
+ * Returns `null` when any stored account fails to resolve (e.g. a transient
+ * refresh failure): the Codex manager is authoritative, so unioning only the
+ * accounts that resolved would cache a partial catalog and hide the failed
+ * account's models for the cache TTL. Aborting keeps the previous/bundled
+ * catalog instead.
+ */
+export declare function resolveCodexDiscoveryAccounts(authStorage: AuthStorage, resolvedAccessToken: string): Promise<OpenAICodexAccount[] | null>;

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

@@ -1,60 +1,14 @@
+import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type { Api, Context, Model, ModelSpec, RemoteCompactionConfig, SimpleStreamOptions, ThinkingConfig } from "@oh-my-pi/pi-ai/types";
 import type { AssistantMessageEventStream } from "@oh-my-pi/pi-ai/utils/event-stream";
 import { type ModelRefreshStrategy } from "@oh-my-pi/pi-catalog/model-manager";
-import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
 import type { AuthStorage } from "../session/auth-storage.js";
 import { type ApiKeyResolverModel, type ApiKeyResolverOptions } from "./api-key-resolver.js";
 import type { ConfigError } from "./config-file.js";
-export declare const kNoAuth = "N/A";
-export declare function isAuthenticated(apiKey: string | undefined | null): apiKey is string;
-/** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */
-interface ProviderOverride {
-    baseUrl?: string;
-    headers?: Record<string, string>;
-    apiKey?: string;
-    authHeader?: boolean;
-    compat?: ModelSpec<Api>["compat"];
-    remoteCompaction?: RemoteCompactionConfig<Api>;
-    transport?: Model<Api>["transport"];
-}
-/**
- * Merge a freshly discovered model with the matching bundled/configured entry
- * (or a runtime provider override when no bundled entry exists).
- *
- * `baseUrl` resolution priority:
- *   1. User-set `providerOverride.baseUrl` (explicit override in models.json)
- *   2. Discovered baseUrl (xiaomi `tp-` token-plan keys resolve to
- *      `token-plan-sgp.xiaomimimo.com` at discovery time)
- *   3. Existing bundled baseUrl (the host baked into `models.json`)
- *
- * `transport` resolution priority:
- *   1. `providerOverride.transport` (e.g. `pi-native` for auth-gateway users)
- *   2. `existing.transport` (carried over from boot-time override application)
- *   3. `model.transport` (rarely set — discovery defaults omit it)
- *
- * Without (1), the user's override would lose to discovery; without (2)
- * preferred over (3), the bundled `api.xiaomimimo.com` would shadow the
- * tp- token-plan host and produce 401s on the first stream call.
- * Without explicit transport propagation, an openrouter (or any) entry
- * marked `transport: pi-native` in models.yml silently reverts to the
- * default openai-completions transport after the background catalog
- * refresh — so the first `/model` switch after boot hits the raw OpenAI
- * chat-completions URL instead of the gateway's `/v1/pi/stream` (#2555).
- * See `xiaomi-tp-discovery-merge.test.ts` and the `refresh()` baseUrl-override
- * regression in `model-registry.test.ts`.
- */
-export declare function mergeDiscoveredModel<TApi extends Api>(model: Model<TApi>, existing: Model<Api> | undefined, providerOverride?: Pick<ProviderOverride, "baseUrl" | "compat" | "headers" | "remoteCompaction" | "transport">): Model<TApi>;
-export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
-export interface ProviderDiscoveryState {
-    provider: string;
-    status: ProviderDiscoveryStatus;
-    optional: boolean;
-    stale: boolean;
-    fetchedAt?: number;
-    models: string[];
-    error?: string;
-}
+import { type ProviderDiscoveryState } from "./model-provider-discovery.js";
+export { mergeDiscoveredModel } from "./model-patch.js";
+export { isAuthenticated, kNoAuth, type ProviderDiscoveryState, type ProviderDiscoveryStatus, } from "./model-provider-discovery.js";
 /** Authentication material returned to legacy extensions for one model request. */
 export type ResolvedRequestAuth = {
     ok: true;
@@ -315,4 +269,3 @@ export interface ProviderConfigInput {
         premiumMultiplier?: number;
     }>;
 }
-export {};

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

@@ -55,10 +55,12 @@ export declare class Settings {
      */
     static loadIsolated(options?: SettingsOptions): Promise<Settings>;
     /**
-     * Create an isolated instance for testing.
-     * Does not affect the global singleton.
+     * Create an in-memory settings instance without affecting the global singleton.
+     * A supplied storage handle remains shared for runtime data while setting overrides stay non-persistent.
      */
-    static isolated(overrides?: Partial<Record<SettingPath, unknown>>): Settings;
+    static isolated(overrides?: Partial<Record<SettingPath, unknown>>, options?: {
+        storage?: AgentStorage | null;
+    }): Settings;
     /**
      * Get the global singleton.
      * Throws if not initialized.

package/dist/types/debug/raw-sse-buffer.d.ts

@@ -40,5 +40,14 @@ export declare class RawSseDebugBuffer {
     recordEvent(event: RawSseEvent, model?: Model): void;
     snapshot(): RawSseDebugSnapshot;
     toRawText(): string;
+    /**
+     * Drop every retained record and reset accounting. Called from
+     * {@link AgentSession} teardown so a disposed (e.g. parked subagent) session
+     * stops pinning captured wire frames — each trimmed record holds a
+     * `slice()` of its parent SSE frame, which under JSC keeps the whole
+     * multi-MB frame alive. Notifies subscribers so a live debug viewer redraws
+     * empty.
+     */
+    clear(): void;
 }
 export declare function resolveRawSseDebugBuffer(owner?: object): RawSseDebugBuffer;

package/dist/types/discovery/agent-plugin-format.d.ts

@@ -32,7 +32,7 @@ export interface AgentPluginManifest {
  * - `invalid` — the document targets Agent Plugins but violates the closed schema
  *   fatally; the plugin must be rejected and none of its components loaded (spec §5.2).
  */
-export type AgentPluginManifestResult = {
+type AgentPluginManifestResult = {
     status: "none";
 } | {
     status: "valid";
@@ -42,8 +42,6 @@ export type AgentPluginManifestResult = {
     status: "invalid";
     reason: string;
 };
-/** Enforce the plugin `name` constraints from spec §5.5. */
-export declare function isValidAgentPluginName(name: string): boolean;
 /**
  * Validate `SKILL.md` frontmatter against the Agent Skills specification
  * (https://agentskills.io/specification), the source of truth for skill
@@ -58,14 +56,8 @@ export declare function validateAgentSkillFrontmatter(frontmatter: Record<string
  * Agent Plugins 1.0.0 manifest schema (spec §5.2–§5.5, §8.1).
  */
 export declare function parseAgentPluginManifest(raw: string): AgentPluginManifestResult;
-/**
- * Expand `${PLUGIN_ROOT}` and `${PLUGIN_DATA}` in a configuration value
- * (spec §9.2). Single non-recursive pass; replacement text is never rescanned,
- * and no other placeholder or environment-variable expansion is performed.
- */
-export declare function expandAgentPluginPlaceholders(value: string, pluginRoot: string, pluginData: string): string;
 /** A validated `mcp.json` server entry, resolved to launch-ready values. */
-export interface AgentPluginMcpServer {
+interface AgentPluginMcpServer {
     name: string;
     transport: "stdio" | "http" | "sse";
     /** Absolute path for `./`-relative commands; bare executable token otherwise. */
@@ -85,7 +77,7 @@ export interface AgentPluginMcpServer {
  * - `ok` — the document is valid; individually invalid server entries are
  *   skipped with a warning (spec §7.2.2 rule 3).
  */
-export type AgentPluginMcpResult = {
+type AgentPluginMcpResult = {
     status: "disabled";
     reason: string;
 } | {
@@ -93,7 +85,7 @@ export type AgentPluginMcpResult = {
     servers: AgentPluginMcpServer[];
     warnings: string[];
 };
-export interface AgentPluginMcpOptions {
+interface AgentPluginMcpOptions {
     /** Filesystem-resolved plugin root. */
     pluginRoot: string;
     /** Client-managed persistent data directory for this plugin (spec §9.1). */
@@ -114,7 +106,7 @@ export declare function parseAgentPluginMcp(raw: string, options: AgentPluginMcp
  * - `invalid` — the root claims Agent Plugins conformance but its manifest is
  *   fatally invalid; no component may be discovered or executed (spec §11.3).
  */
-export type AgentPluginRootStatus = {
+type AgentPluginRootStatus = {
     kind: "none";
 } | {
     kind: "standard";
@@ -141,3 +133,4 @@ export declare function classifyAgentPluginRoot(rootPath: string): Promise<Agent
  * hybrid packages. Fatally invalid Agent Plugins packages are rejected entirely.
  */
 export declare function legacyProviderAllowed(rootPath: string, surface: "skills" | "mcp" | "other"): Promise<boolean>;
+export {};

package/dist/types/discovery/contained-path.d.ts

@@ -1,9 +1,7 @@
-/** Lexical containment: `target` is `base` itself or a descendant of it. */
-export declare function isContained(base: string, target: string): boolean;
 /** Resolve symlinks and equivalents; `null` when the path is missing or unresolvable. */
 export declare function realpathIfExists(p: string): Promise<string | null>;
 /** Outcome of resolving a fixed package path without reading it. */
-export type ContainedPathResolution = {
+type ContainedPathResolution = {
     status: "missing";
 } | {
     status: "outside";
@@ -32,3 +30,4 @@ export declare function isContainedResolved(realBase: string, target: string): P
  * (bash `skill://` expansion).
  */
 export declare function resolveContainedPathSync(realBase: string, target: string): ContainedPathResolution;
+export {};

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

@@ -71,7 +71,7 @@ export declare function isTimedOutCancellation(error: unknown, cancelledErrorCla
 export declare function waitForPromiseWithCancellation<T>(promise: Promise<T>, options: {
     signal?: AbortSignal;
     deadlineMs?: number;
-}, cancelledErrorClass: CancelledErrorClass): Promise<T>;
+}, cancelledErrorClass: CancelledErrorClass, timedOutResolver?: (error: unknown, signal?: AbortSignal) => boolean): Promise<T>;
 export declare function createCancelledKernelResult(output: string): KernelExecutionResult;
 export declare const MANAGED_KERNEL_ENV_KEYS: readonly ["PI_SESSION_FILE", "PI_ARTIFACTS_DIR", "PI_TOOL_BRIDGE_URL", "PI_TOOL_BRIDGE_TOKEN", "PI_TOOL_BRIDGE_SESSION", "PI_EVAL_LOCAL_ROOTS"];
 interface ManagedKernelEnvOptions {
@@ -84,8 +84,14 @@ interface ManagedKernelEnvOptions {
     };
     localRoots?: Record<string, string>;
 }
+interface ManagedKernelEnvPolicy {
+    sparse?: boolean;
+}
 export declare function buildManagedKernelEnvPatch(options: ManagedKernelEnvOptions): Record<string, string | null>;
-export declare function buildManagedKernelEnv(options: ManagedKernelEnvOptions): Record<string, string> | undefined;
+export declare function buildManagedKernelEnvPatch(options: ManagedKernelEnvOptions, policy: {
+    sparse: true;
+}): Record<string, string | undefined>;
+export declare function buildManagedKernelEnv(options: ManagedKernelEnvOptions, policy?: ManagedKernelEnvPolicy): Record<string, string> | undefined;
 export declare function attachSessionOwner(session: {
     ownerIds: Set<string>;
     hasFallbackOwner: boolean;

package/dist/types/eval/kernel-session-registry.d.ts

@@ -0,0 +1,60 @@
+import { type CancelledErrorClass, type SessionOwners } from "./executor-base.js";
+interface KernelSessionRegistryOptions {
+    sessionId?: string;
+    kernelOwnerId?: string;
+    interpreter?: string;
+    reset?: boolean;
+    signal?: AbortSignal;
+    deadlineMs?: number;
+    bridge?: unknown;
+    bridgeSessionId?: string;
+}
+interface RegistryKernelShutdownResult {
+    confirmed?: boolean;
+}
+interface RegistryKernel {
+    isAlive(): boolean;
+    shutdown(options?: {
+        timeoutMs: number;
+    }): Promise<RegistryKernelShutdownResult>;
+}
+export interface KernelSession<TKernel extends RegistryKernel> extends SessionOwners {
+    sessionKey: string;
+    sessionId: string;
+    cwd: string;
+    kernel: TKernel;
+}
+export interface KernelSessionRegistryContext<TKernel extends RegistryKernel, TOptions extends KernelSessionRegistryOptions, TSession extends KernelSession<TKernel>> {
+    sessions: Map<string, TSession>;
+    startKernel: (cwd: string, options: TOptions) => Promise<TKernel>;
+    replaceSessionKernel: (session: TSession, cwd: string, options: TOptions) => Promise<TKernel>;
+}
+interface KernelSessionRegistryDescriptor<TKernel extends RegistryKernel, TOptions extends KernelSessionRegistryOptions, TResult, TSession extends KernelSession<TKernel>> {
+    languageLabel: string;
+    cancelledErrorClass: CancelledErrorClass;
+    buildSessionKey: (sessionId: string, cwd: string, interpreter: string | undefined) => string;
+    createSession: (session: KernelSession<TKernel>) => TSession;
+    startKernel: (cwd: string, options: TOptions) => Promise<TKernel>;
+    executeWithKernel: (kernel: TKernel, code: string, options: TOptions) => Promise<TResult>;
+    waitForStartup?: (promise: Promise<TSession>, options: TOptions) => Promise<TSession>;
+    replaceSessionKernel?: (session: TSession, cwd: string, options: TOptions, context: KernelSessionRegistryContext<TKernel, TOptions, TSession>) => Promise<TKernel>;
+    acquireLiveSessionKernel?: (session: TSession, cwd: string, options: TOptions, context: KernelSessionRegistryContext<TKernel, TOptions, TSession>) => Promise<TKernel>;
+    invalidateSession?: (session: TSession) => void;
+    shutdownSession?: (session: TSession, resetting: boolean) => Promise<RegistryKernelShutdownResult>;
+    clearResetsOnDisposeAll?: boolean;
+    logBeforeReplacement?: boolean;
+    isCancellation?: (error: unknown) => boolean;
+    isTimedOutCancellation?: (error: unknown, signal?: AbortSignal) => boolean;
+    validateKernel?: (session: TSession, kernel: TKernel) => boolean;
+}
+interface KernelSessionRegistry<TOptions extends KernelSessionRegistryOptions, TResult> {
+    disposeAll(): Promise<void>;
+    disposeByOwner(ownerId: string): Promise<void>;
+    executeOnSession(code: string, cwd: string, options: TOptions): Promise<TResult>;
+}
+export declare function normalizeKernelSessionCwd(cwd: string): string;
+export declare function requireRemainingKernelTimeoutMs(deadlineMs: number | undefined, cancelledErrorClass: CancelledErrorClass): number | undefined;
+export declare function formatSessionTimeoutAnnotation(timeoutMs?: number): string;
+export declare function formatSessionKernelTimeoutAnnotation(timeoutMs: number | undefined, kernelKilled: boolean): string;
+export declare function createKernelSessionRegistry<TKernel extends RegistryKernel, TOptions extends KernelSessionRegistryOptions, TResult, TSession extends KernelSession<TKernel>>(descriptor: KernelSessionRegistryDescriptor<TKernel, TOptions, TResult, TSession>): KernelSessionRegistry<TOptions, TResult>;
+export {};

package/dist/types/export/share.d.ts

@@ -1,6 +1,6 @@
 import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { DEFAULT_SHARE_URL } from "@oh-my-pi/pi-wire";
-import { type SecretObfuscator } from "../secrets/obfuscator.js";
+import type { SecretObfuscator } from "../secrets/obfuscator.js";
 import type { SessionManager } from "../session/session-manager.js";
 import { type SessionData } from "./html/index.js";
 export { DEFAULT_SHARE_URL };

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

@@ -0,0 +1,96 @@
+import type { Diagnostic, Location, LocationLink, LspClient, Position, ServerConfig } from "./types.js";
+export declare const SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 3000;
+export declare const BATCH_DIAGNOSTICS_WAIT_TIMEOUT_MS = 400;
+/**
+ * How long the edit/write writethrough blocks inline waiting for fresh
+ * diagnostics before handing slow servers off to the deferred late-injection
+ * channel. Keeps the common fast-server case inline while letting an edit
+ * return promptly when a server (e.g. a large-monorepo tsserver) is slow to
+ * publish fresh diagnostics.
+ */
+export declare const INLINE_DIAGNOSTICS_WAIT_TIMEOUT_MS = 500;
+/**
+ * Inner per-server diagnostics wait budget for the background/deferred fetch.
+ * Longer than the inline cap (and the old 3s default) so a slow server still
+ * delivers late instead of giving up before it ever publishes.
+ */
+export declare const DEFERRED_DIAGNOSTICS_WAIT_TIMEOUT_MS = 12000;
+export declare const MAX_GLOB_DIAGNOSTIC_TARGETS = 20;
+export declare const WORKSPACE_SYMBOL_LIMIT = 200;
+export declare const PROJECT_INDEXED_ACTIONS: ReadonlySet<string>;
+export declare function hasRustWorkspaceAncestor(filePath: string): boolean;
+export declare function limitDiagnosticMessages(messages: string[]): string[];
+export declare const REFERENCE_CONTEXT_LIMIT = 50;
+export declare const REFERENCES_RETRY_COUNT = 2;
+export declare const REFERENCES_RETRY_DELAY_MS = 250;
+export declare function isOnlyQueriedDeclaration(locations: Location[], uri: string, position: Position): boolean;
+export declare function normalizeLocationResult(result: Location | Location[] | LocationLink | LocationLink[] | null): Location[];
+export declare function formatLocationWithContext(location: Location, cwd: string): Promise<string>;
+interface WaitForDiagnosticsOptions {
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    minVersion?: number;
+    expectedDocumentVersion?: number;
+    /**
+     * Quiescence window (ms). typescript-language-server never echoes the document
+     * version (issue #983) and emits diagnostics from several sources at different
+     * times, so there is no single "complete, version-matched" publish to gate on.
+     * When the server does not exact-version-match, accept the latest publish only
+     * after no newer one has arrived for this long, letting an in-flight pre-edit
+     * publish be superseded by the fresh one.
+     */
+    settleMs?: number;
+}
+export declare function waitForDiagnostics(client: LspClient, uri: string, options?: WaitForDiagnosticsOptions): Promise<Diagnostic[]>;
+/** Result from getDiagnosticsForFile */
+export interface FileDiagnosticsResult {
+    /** Name of the LSP server used (if available) */
+    server?: string;
+    /** Formatted diagnostic messages */
+    messages: string[];
+    /** Summary string (e.g., "2 error(s), 1 warning(s)") */
+    summary: string;
+    /** Whether there are any errors (severity 1) */
+    errored: boolean;
+    /** Whether the file was formatted */
+    formatter?: FileFormatResult;
+}
+export type ServerVersionMap = Map<string, number>;
+interface GetDiagnosticsForFileOptions {
+    signal?: AbortSignal;
+    minVersions?: ServerVersionMap;
+    expectedDocumentVersions?: ServerVersionMap;
+    /** Per-server wait budget (ms). Defaults to {@link SINGLE_DIAGNOSTICS_WAIT_TIMEOUT_MS}. */
+    timeoutMs?: number;
+}
+/**
+ * Capture current diagnostic versions for all LSP servers.
+ * Call this BEFORE syncing content to detect stale diagnostics later.
+ */
+export declare function captureDiagnosticVersions(cwd: string, servers: Array<[string, ServerConfig]>, initTimeoutMs?: number, signal?: AbortSignal): Promise<ServerVersionMap>;
+export declare function captureOpenFileVersions(absolutePath: string, cwd: string, servers: Array<[string, ServerConfig]>, signal?: AbortSignal): Promise<ServerVersionMap>;
+/**
+ * Get diagnostics for a file using LSP or custom linter client.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @param servers - Servers to query diagnostics for
+ * @param minVersions - Minimum diagnostic versions per server (to detect stale results)
+ * @returns Diagnostic results or undefined if no servers
+ */
+export declare function getDiagnosticsForFile(absolutePath: string, cwd: string, servers: Array<[string, ServerConfig]>, options?: GetDiagnosticsForFileOptions): Promise<FileDiagnosticsResult | undefined>;
+export declare enum FileFormatResult {
+    UNCHANGED = "unchanged",
+    FORMATTED = "formatted"
+}
+/**
+ * Format content using LSP or custom linter client.
+ *
+ * @param absolutePath - Absolute path (for URI)
+ * @param content - Content to format
+ * @param cwd - Working directory for LSP config resolution
+ * @param servers - Servers to try formatting with
+ * @returns Formatted content, or original if no formatter available
+ */
+export declare function formatContent(absolutePath: string, content: string, cwd: string, servers: Array<[string, ServerConfig]>, signal?: AbortSignal): Promise<string>;
+export {};