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

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

@@ -0,0 +1,33 @@
+/** 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. */
+type ContainedPathResolution = {
+    status: "missing";
+} | {
+    status: "outside";
+} | {
+    status: "ok";
+    realPath: string;
+};
+/**
+ * Resolve a fixed package path WITHOUT reading it: symlinks and equivalent
+ * mechanisms are resolved first, and a path escaping the filesystem-resolved
+ * plugin root is rejected before any I/O could consume outside content.
+ */
+export declare function resolveContainedPath(realBase: string, target: string): Promise<ContainedPathResolution>;
+/**
+ * Verify a package path stays within the filesystem-resolved plugin root:
+ * lexically, and — when the target exists — after resolving symlinks. Unlike
+ * {@link resolveContainedPath}, a missing target passes. ONLY for configured
+ * paths that are validated but never read or executed at load time (stdio
+ * `command`, `cwd` — including `${PLUGIN_DATA}` paths created after
+ * validation); access paths MUST use {@link resolveContainedPath} instead,
+ * which fails closed on unresolvable targets.
+ */
+export declare function isContainedResolved(realBase: string, target: string): Promise<boolean>;
+/**
+ * Sync variant of {@link resolveContainedPath} for synchronous callsites
+ * (bash `skill://` expansion).
+ */
+export declare function resolveContainedPathSync(realBase: string, target: string): ContainedPathResolution;
+export {};

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

@@ -18,6 +18,7 @@ import "../capability/slash-command.js";
 import "../capability/ssh.js";
 import "../capability/system-prompt.js";
 import "../capability/tool.js";
+import "./agent-plugins.js";
 import "./agents-md.js";
 import "./builtin.js";
 import "./builtin-defaults.js";

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/extensibility/custom-tools/types.d.ts

@@ -22,7 +22,7 @@ import type { LocalProtocolOptions } from "../../internal-urls/local-protocol.js
 import type { Theme } from "../../modes/theme/theme.js";
 import type { ReadonlySessionManager } from "../../session/session-manager.js";
 import type { TodoItem } from "../../tools/todo.js";
-import type { RecoveredRetryError } from "../shared-events.js";
+import type { RetryErrorUpdate } from "../shared-events.js";
 /** Alias for clarity */
 export type CustomToolUIContext = HookUIContext;
 export type { ExecOptions, ExecResult } from "../../exec/exec.js";
@@ -119,7 +119,7 @@ export type CustomToolSessionEvent = {
     success: boolean;
     attempt: number;
     finalError?: string;
-    recoveredErrors?: RecoveredRetryError[];
+    retryErrors?: RetryErrorUpdate[];
 } | {
     reason: "ttsr_triggered";
     rules: Rule[];

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

@@ -16,6 +16,8 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
         config: ProviderConfig;
         sourceId: string;
     }>;
+    registerProvider(name: string, config: ProviderConfig, sourceId: string): void;
+    unregisterProvider(name: string): void;
     sendMessage(): void;
     sendUserMessage(): void;
     appendEntry(): void;
@@ -38,6 +40,11 @@ export declare class ExtensionRuntime implements IExtensionRuntime {
 export declare function loadExtensionFromFactory(factory: ExtensionFactory, cwd: string, eventBus: EventBus, runtime: IExtensionRuntime, name?: string): Promise<Extension>;
 /**
  * Load extensions from paths.
+ *
+ * Module import (the dominant cold-start cost — file I/O plus module
+ * evaluation) runs concurrently across extensions; factory binding then runs
+ * sequentially in the original path order, so registration semantics
+ * (last-wins collisions, shared runtime flag defaults) stay deterministic.
  */
 export declare function loadExtensions(paths: string[], cwd: string, eventBus?: EventBus): Promise<LoadExtensionsResult>;
 /**

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

@@ -918,6 +918,13 @@ export interface ExtensionAPI {
      * });
      */
     registerProvider(name: string, config: ProviderConfig): void;
+    /**
+     * Unregister a provider previously registered by an extension.
+     *
+     * Removes extension-provided models and restores overridden built-in models.
+     * Has no effect when the provider is not registered.
+     */
+    unregisterProvider(name: string): void;
     /** Shared event bus for extension communication. */
     events: EventBus;
 }
@@ -1042,6 +1049,10 @@ export interface ExtensionRuntimeState {
         config: ProviderConfig;
         sourceId: string;
     }>;
+    /** Queue a provider registration until initialization, then apply it immediately. */
+    registerProvider(name: string, config: ProviderConfig, sourceId: string): void;
+    /** Remove a queued or initialized provider registration. */
+    unregisterProvider(name: string, sourceId: string): void;
 }
 /** Action implementations for ExtensionAPI methods. */
 export interface ExtensionActions {

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

@@ -200,7 +200,8 @@ export interface AutoRetryStartEvent {
     errorMessage: string;
     errorId?: number;
 }
-export interface RecoveredRetryError {
+/** Persisted retry error whose transcript presentation changed when the retry saga settled. */
+export interface RetryErrorUpdate {
     entryId: string;
     persistenceKey?: string;
     note: string;
@@ -212,7 +213,7 @@ export interface AutoRetryEndEvent {
     success: boolean;
     attempt: number;
     finalError?: string;
-    recoveredErrors?: RecoveredRetryError[];
+    retryErrors?: RetryErrorUpdate[];
 }
 /** Fired when TTSR rule matching interrupts generation */
 export interface TtsrTriggeredEvent {

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

@@ -13,6 +13,11 @@ export interface Skill {
      * prompt's `<skills>` listing.
      */
     hide?: boolean;
+    /**
+     * Filesystem-resolved plugin root for Agent Plugin skills (spec §4.1):
+     * every `skill://` resource access must realpath-resolve within it.
+     */
+    containRoot?: string;
     /** Source metadata for display */
     _source?: SourceMeta;
 }

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 {};

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

@@ -1,130 +1,9 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
-import type { BunFile } from "bun";
-import { type Theme } from "../modes/theme/theme.js";
-import type { ToolSession } from "../tools/index.js";
-import { type LspServerStatus } from "./client.js";
-import { type LspParams, type LspToolDetails, lspSchema } from "./types.js";
 export type { LspServerStatus } from "./client.js";
+export type { FileDiagnosticsResult } from "./diagnostics.js";
+export { FileFormatResult } from "./diagnostics.js";
+export type { LspStartupServerInfo, LspWarmupOptions, LspWarmupResult } from "./servers.js";
+export { discoverStartupLspServers, getLspStatus, LSP_READONLY_ACTIONS, warmupLspServers, } from "./servers.js";
+export { LspTool } from "./tool.js";
 export type { LspToolDetails } from "./types.js";
-/**
- * LSP actions that do not mutate the workspace or language-server state.
- * Anything not in this set (rename, code_actions with apply, rename_file,
- * reload, raw request, etc.) is classified as write-tier.
- */
-export declare const LSP_READONLY_ACTIONS: ReadonlySet<string>;
-export interface LspStartupServerInfo {
-    name: string;
-    status: "connecting" | "ready" | "error" | "available";
-    fileTypes: string[];
-    error?: string;
-}
-/** Result from warming up LSP servers */
-export interface LspWarmupResult {
-    servers: Array<LspStartupServerInfo & {
-        status: "ready" | "error";
-    }>;
-}
-/** Options for warming up LSP servers */
-export interface LspWarmupOptions {
-    /** Called when starting to connect to servers */
-    onConnecting?: (serverNames: string[]) => void;
-}
-export declare function discoverStartupLspServers(cwd: string, status?: LspStartupServerInfo["status"]): LspStartupServerInfo[];
-/**
- * Warm up LSP servers for a directory by connecting to all detected servers.
- * This should be called at startup to avoid cold-start delays.
- *
- * @param cwd - Working directory to detect and start servers for
- * @param options - Optional callbacks for progress reporting
- * @returns Status of each server that was started
- */
-export declare function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult>;
-/**
- * Get status of currently active LSP servers.
- */
-export declare function getLspStatus(): LspServerStatus[];
-/** 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 declare enum FileFormatResult {
-    UNCHANGED = "unchanged",
-    FORMATTED = "formatted"
-}
-/** Options for creating the LSP writethrough callback */
-export interface WritethroughOptions {
-    /** Whether to format the file using LSP after writing */
-    enableFormat?: boolean;
-    /** Whether to get LSP diagnostics after writing */
-    enableDiagnostics?: boolean;
-    /** Called when diagnostics arrive after the main timeout. */
-    onDeferredDiagnostics?: (diagnostics: FileDiagnosticsResult) => void;
-    /** Signal to cancel a pending deferred diagnostics fetch. */
-    deferredSignal?: AbortSignal;
-    /** Transform diagnostics before surfacing them after a successful fetch. */
-    transformDiagnostics?: (absPath: string, result: FileDiagnosticsResult) => FileDiagnosticsResult;
-}
-/** Per-file deferred LSP diagnostics wiring for {@link WritethroughCallback}. */
-export type WritethroughDeferredHandle = {
-    onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void;
-    signal: AbortSignal;
-    finalize: (diagnostics: FileDiagnosticsResult | undefined) => void;
-};
-/** Callback type for the LSP writethrough */
-export type WritethroughCallback = (dst: string, content: string, signal?: AbortSignal, file?: BunFile, batch?: LspWritethroughBatchRequest, getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined) => Promise<FileDiagnosticsResult | undefined>;
-/** No-op writethrough callback */
-export declare function writethroughNoop(dst: string, content: string, _signal?: AbortSignal, file?: BunFile, _batch?: LspWritethroughBatchRequest, _getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined): Promise<FileDiagnosticsResult | undefined>;
-interface LspWritethroughBatchRequest {
-    id: string;
-    flush: boolean;
-}
-export declare function flushLspWritethroughBatch(id: string, cwd: string, signal?: AbortSignal): Promise<FileDiagnosticsResult | undefined>;
-/** Create a writethrough callback for LSP aware write operations */
-export declare function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback;
-/**
- * LSP tool for language server protocol operations.
- */
-export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Theme> {
-    private readonly session;
-    readonly name = "lsp";
-    readonly approval: (args: unknown) => ToolApprovalDecision;
-    readonly formatApprovalDetails: (args: unknown) => string[];
-    readonly label = "LSP";
-    readonly loadMode = "discoverable";
-    readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
-    readonly description: string;
-    readonly parameters: import("@oh-my-pi/omptype").FluentType<{
-        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
-        apply?: boolean | undefined;
-        file?: string | undefined;
-        line?: number | undefined;
-        new_name?: string | undefined;
-        payload?: string | undefined;
-        query?: string | undefined;
-        symbol?: string | undefined;
-        timeout?: number | undefined;
-    }, {
-        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
-        apply?: boolean | undefined;
-        file?: string | undefined;
-        line?: number | undefined;
-        new_name?: string | undefined;
-        payload?: string | undefined;
-        query?: string | undefined;
-        symbol?: string | undefined;
-        timeout?: number | undefined;
-    }>;
-    readonly strict = true;
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): LspTool | null;
-    execute(_toolCallId: string, params: LspParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<LspToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<LspToolDetails>>;
-}
+export type { WritethroughCallback, WritethroughDeferredHandle, WritethroughOptions, } from "./writethrough.js";
+export { createLspWritethrough, flushLspWritethroughBatch, writethroughNoop, } from "./writethrough.js";

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

@@ -0,0 +1,72 @@
+import { type LspServerStatus } from "./client.js";
+import { type LspConfig } from "./config.js";
+import type { LspClient, ServerConfig } from "./types.js";
+/**
+ * LSP actions that do not mutate the workspace or language-server state.
+ * Anything not in this set (rename, code_actions with apply, rename_file,
+ * reload, raw request, etc.) is classified as write-tier.
+ */
+export declare const LSP_READONLY_ACTIONS: ReadonlySet<string>;
+export interface LspStartupServerInfo {
+    name: string;
+    status: "connecting" | "ready" | "error" | "available";
+    fileTypes: string[];
+    error?: string;
+}
+/** Result from warming up LSP servers */
+export interface LspWarmupResult {
+    servers: Array<LspStartupServerInfo & {
+        status: "ready" | "error";
+    }>;
+}
+/** Options for warming up LSP servers */
+export interface LspWarmupOptions {
+    /** Called when starting to connect to servers */
+    onConnecting?: (serverNames: string[]) => void;
+}
+export declare function discoverStartupLspServers(cwd: string, status?: LspStartupServerInfo["status"]): LspStartupServerInfo[];
+/**
+ * Warm up LSP servers for a directory by connecting to all detected servers.
+ * This should be called at startup to avoid cold-start delays.
+ *
+ * @param cwd - Working directory to detect and start servers for
+ * @param options - Optional callbacks for progress reporting
+ * @returns Status of each server that was started
+ */
+export declare function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult>;
+/**
+ * Get status of currently active LSP servers.
+ */
+export declare function getLspStatus(): LspServerStatus[];
+/**
+ * Sync in-memory file content to all applicable LSP servers.
+ * Sends didOpen (if new) or didChange (if already open).
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param content - The new file content
+ * @param cwd - Working directory for LSP config resolution
+ * @param servers - Servers to sync to
+ */
+export declare function syncFileContent(absolutePath: string, content: string, cwd: string, servers: Array<[string, ServerConfig]>, signal?: AbortSignal, createMissing?: boolean): Promise<void>;
+/**
+ * Notify all LSP servers that a file was saved.
+ * Assumes content was already synced via syncFileContent.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @param servers - Servers to notify
+ */
+export declare function notifyFileSaved(absolutePath: string, cwd: string, servers: Array<[string, ServerConfig]>, signal?: AbortSignal, createMissing?: boolean): Promise<void>;
+export declare const configCache: Map<string, LspConfig>;
+export declare function getConfig(cwd: string): LspConfig;
+export declare function splitServers(servers: Array<[string, ServerConfig]>): {
+    lspServers: Array<[string, ServerConfig]>;
+    customLinterServers: Array<[string, ServerConfig]>;
+};
+export declare function getLspServers(config: LspConfig): Array<[string, ServerConfig]>;
+export declare function getLspServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]>;
+export declare function getLspServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null;
+export declare function isProjectAwareLspServer(serverConfig: ServerConfig): boolean;
+/** True when an LSP error indicates the server doesn't implement the requested method. */
+export declare function isMethodNotFoundError(err: unknown): boolean;
+export declare function reloadServer(client: LspClient, serverName: string, signal?: AbortSignal): Promise<string>;

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

@@ -0,0 +1,42 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@oh-my-pi/pi-agent-core";
+import { type Theme } from "../modes/theme/theme.js";
+import type { ToolSession } from "../tools/index.js";
+import { type LspParams, type LspToolDetails, lspSchema } from "./types.js";
+/**
+ * LSP tool for language server protocol operations.
+ */
+export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Theme> {
+    private readonly session;
+    readonly name = "lsp";
+    readonly approval: (args: unknown) => ToolApprovalDecision;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    readonly label = "LSP";
+    readonly loadMode = "discoverable";
+    readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
+    readonly description: string;
+    readonly parameters: import("@oh-my-pi/omptype").FluentType<{
+        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+        apply?: boolean | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        new_name?: string | undefined;
+        payload?: string | undefined;
+        query?: string | undefined;
+        symbol?: string | undefined;
+        timeout?: number | undefined;
+    }, {
+        action: "capabilities" | "code_actions" | "definition" | "diagnostics" | "hover" | "implementation" | "references" | "reload" | "rename" | "rename_file" | "request" | "status" | "symbols" | "type_definition";
+        apply?: boolean | undefined;
+        file?: string | undefined;
+        line?: number | undefined;
+        new_name?: string | undefined;
+        payload?: string | undefined;
+        query?: string | undefined;
+        symbol?: string | undefined;
+        timeout?: number | undefined;
+    }>;
+    readonly strict = true;
+    constructor(session: ToolSession);
+    static createIf(session: ToolSession): LspTool | null;
+    execute(_toolCallId: string, params: LspParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<LspToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<LspToolDetails>>;
+}

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

@@ -0,0 +1,12 @@
+/** Project type detection result */
+interface ProjectType {
+    type: "rust" | "typescript" | "go" | "python" | "unknown";
+    command?: string[];
+    description: string;
+}
+/** Run workspace diagnostics command and parse output */
+export declare function runWorkspaceDiagnostics(cwd: string, signal?: AbortSignal): Promise<{
+    output: string;
+    projectType: ProjectType;
+}>;
+export {};

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

@@ -0,0 +1,33 @@
+import type { BunFile } from "bun";
+import { type FileDiagnosticsResult } from "./diagnostics.js";
+/** Options for creating the LSP writethrough callback */
+export interface WritethroughOptions {
+    /** Whether to format the file using LSP after writing */
+    enableFormat?: boolean;
+    /** Whether to get LSP diagnostics after writing */
+    enableDiagnostics?: boolean;
+    /** Called when diagnostics arrive after the main timeout. */
+    onDeferredDiagnostics?: (diagnostics: FileDiagnosticsResult) => void;
+    /** Signal to cancel a pending deferred diagnostics fetch. */
+    deferredSignal?: AbortSignal;
+    /** Transform diagnostics before surfacing them after a successful fetch. */
+    transformDiagnostics?: (absPath: string, result: FileDiagnosticsResult) => FileDiagnosticsResult;
+}
+/** Per-file deferred LSP diagnostics wiring for {@link WritethroughCallback}. */
+export type WritethroughDeferredHandle = {
+    onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void;
+    signal: AbortSignal;
+    finalize: (diagnostics: FileDiagnosticsResult | undefined) => void;
+};
+/** Callback type for the LSP writethrough */
+export type WritethroughCallback = (dst: string, content: string, signal?: AbortSignal, file?: BunFile, batch?: LspWritethroughBatchRequest, getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined) => Promise<FileDiagnosticsResult | undefined>;
+/** No-op writethrough callback */
+export declare function writethroughNoop(dst: string, content: string, _signal?: AbortSignal, file?: BunFile, _batch?: LspWritethroughBatchRequest, _getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined): Promise<FileDiagnosticsResult | undefined>;
+interface LspWritethroughBatchRequest {
+    id: string;
+    flush: boolean;
+}
+export declare function flushLspWritethroughBatch(id: string, cwd: string, signal?: AbortSignal): Promise<FileDiagnosticsResult | undefined>;
+/** Create a writethrough callback for LSP aware write operations */
+export declare function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback;
+export {};