@skaile/workspaces 0.8.5

package/dist/bridge/src/drivers/claude-sdk.d.ts

@@ -0,0 +1,224 @@
+import type { TokenUsage } from "@skaile/workspaces/types";
+import { type ModelEntry } from "../models.js";
+import { type AgentConfig, AgentDriver, type DriverInfo, type SlashCommandInfo } from "../types.js";
+/**
+ * Agent driver for the Anthropic Claude Agent SDK.
+ *
+ * Runs the agent in-process — no subprocess is spawned. Anthropic models only.
+ *
+ * @remarks
+ * **Lazy-loading** — `@anthropic-ai/claude-agent-sdk` is imported dynamically inside
+ * `start()` so it remains an optional peer dependency. If the package is not installed
+ * an actionable error is thrown. The CJS/ESM `require` polyfill at the top of this file
+ * is required because the SDK bundles ajv which uses `require()` internally.
+ *
+ * **Session continuity** — each `prompt()` tries to feed into a live SDK query via
+ * `streamInput()` (persistent multi-turn mode). When no live query exists it starts a
+ * new one, applying a three-level resume chain:
+ *   1. `resumeSessionId` from config (explicit caller resume)
+ *   2. `sessionId` captured from the current driver lifetime
+ *   3. `continue: true` (resume most recent session in cwd from disk)
+ *
+ * **Tool synthesis** — emits `tool_call` and `tool_execution_end` events that the
+ * runner's activity tracker needs for file-change detection. These are not native SDK
+ * events; they are synthesised from `assistant` and `user` SDK messages.
+ *
+ * **agentName** — maps to the `agent` SDK query option. The SDK reads
+ * `.claude/agents/<agentName>.md` from `cwd` for model, tools, and system prompt.
+ * Requires the agent file to have been rendered by `asset-manager` (claudeCodeRenderer)
+ * during `skaile install`. Ignored by other drivers.
+ *
+ * **mcpServers** — `AgentConfig.mcpServers` passes in-process MCP server instances to
+ * the SDK's `mcpServers` query option. Used by `workspaces/connectors` to inject
+ * resource tools as native `tool_use`. Ignored by other drivers.
+ *
+ * @docLink packages/bridge/drivers#claude-sdk-driver
+ */
+export declare class ClaudeSdkDriver extends AgentDriver {
+    readonly driverInfo: DriverInfo;
+    private readonly log;
+    private config;
+    private abortController;
+    private running;
+    private sdk;
+    private toolIdToName;
+    private prevText;
+    /** Active query — may stay alive between turns if streamInput works. */
+    private query;
+    /** Resolves when the current turn completes. */
+    private turnResolve;
+    /** Rejects when the current turn errors. */
+    private turnReject;
+    /** Guards against duplicate agent_end emissions per turn. */
+    private turnCompleted;
+    /** Tracks whether a session has been started (for continue: true). */
+    private hasSession;
+    /** Session ID from the SDK — used for streamInput messages. */
+    private sessionId;
+    /** Cached slash commands discovered from the SDK. */
+    private cachedCommands;
+    /** Token usage from the most recent completed turn. */
+    private _lastTokens;
+    /** Context window size from the most recent result's modelUsage. */
+    private _contextWindow;
+    /**
+     * `true` when the active credential is a Claude Code OAuth subscription
+     * (no API key in config) rather than a raw `ANTHROPIC_API_KEY`. Set on
+     * every `startQuery` because the credential source can be reconfigured
+     * at runtime via `configure`. Threaded into `classifyClaudeSdkError` so
+     * upstream auth-shaped failures get a quota-aware hint when warranted.
+     */
+    private usingOauthCredential;
+    /**
+     * @param config - Driver configuration. Claude SDK-relevant fields:
+     *   - `cwd` — working directory; SDK session files and agent definitions are read from here.
+     *   - `model` — Anthropic model identifier (e.g. `"claude-sonnet-4-5"`). Defaults to `"sonnet"`.
+     *   - `apiKeys.anthropic` / `env.ANTHROPIC_API_KEY` — API key forwarded to the SDK query.
+     *   - `agentName` — name of a `.claude/agents/<name>.md` agent definition to use as identity.
+     *   - `mcpServers` — in-process MCP server instances injected as native `tool_use` tools.
+     *   - `systemPrompt` — appended to the `claude_code` preset system prompt.
+     *   - `resumeSessionId` — SDK session UUID to resume from a prior driver lifetime.
+     *   - `maxTurns` — maximum agentic turns per `prompt()` call (default: 15).
+     */
+    constructor(config: AgentConfig);
+    get runtimeSessionId(): string | undefined;
+    reconfigure(patch: Partial<Pick<AgentConfig, "model" | "thinking" | "effort">>): void;
+    getModel(): string | undefined;
+    /**
+     * Dynamically imports `@anthropic-ai/claude-agent-sdk`.
+     *
+     * @throws {Error} When the SDK package is not installed. Install it with
+     *   `bun add @anthropic-ai/claude-agent-sdk`.
+     */
+    start(): Promise<void>;
+    /**
+     * Sends a user message to the Claude Agent SDK and resolves when the turn completes.
+     *
+     * If a live SDK query already exists (from a prior turn in this session) the message
+     * is fed via `streamInput()` for efficient multi-turn continuity. Otherwise a new query
+     * is started applying the resume chain described in the class-level remarks.
+     *
+     * @param message - Plain-text user prompt.
+     * @throws {Error} When the SDK reports a fatal error that cannot be auto-recovered.
+     *
+     * @remarks
+     * A single automatic retry is performed when the SDK throws
+     * "No conversation found with session ID …" — a recoverable stale-resume error that
+     * occurs after a container crash that prevented the SDK from flushing its session file.
+     */
+    prompt(message: string, _retryCount?: number): Promise<void>;
+    private startQuery;
+    getSlashCommands(): SlashCommandInfo[];
+    /**
+     * Compose the MCP servers passed to the SDK query. Merges the legacy
+     * `config.mcpServers` (connectors / workspace plugin / declarative skaile.yaml
+     * entries) with a synthetic `skaile-capabilities` server built from the
+     * runner-provided {@link BridgeCapabilityHooks} when present.
+     *
+     * Returns an empty options patch when neither source is configured, so legacy
+     * v1 sessions remain unaffected.
+     */
+    private buildEffectiveMcpServers;
+    /**
+     * Build the synthetic MCP server that exposes registered capabilities to the
+     * Claude Agent SDK. Lazy-imports `createSdkMcpServer` from the SDK and `zod`
+     * (an SDK peer) since both are optional peers of this bridge.
+     *
+     * Returns null when the SDK or zod is unavailable, or when the registry
+     * exposes no tools — leaving the legacy `mcpServers` untouched.
+     */
+    private buildCapabilityMcpServer;
+    /** Fetch and cache slash commands from the SDK query. */
+    private fetchSlashCommands;
+    /**
+     * Background loop — consumes the query's async generator continuously.
+     * The generator stays alive between turns; streamInput() feeds new messages.
+     * If it ends unexpectedly, query is nulled so the next prompt() restarts.
+     */
+    private consumeMessages;
+    /**
+     * Signal the current turn as done — idempotent per turn.
+     *
+     * Same defensive ordering as {@link failTurn}: settle the turn promise
+     * before emitting `agent_end` so a misbehaving listener cannot trap the
+     * promise in a pending state. See failTurn's docblock for the production
+     * incident that motivated this pattern.
+     */
+    private completeTurn;
+    /**
+     * Signal the current turn as failed. When a structured `detail` is
+     * supplied, the AgentEvent carries the category + hint so downstream
+     * consumers (normalizer → runner → platform → frontend) can surface a
+     * useful diagnosis instead of the raw upstream string.
+     *
+     * Reject ordering: `turnReject()` runs FIRST, then the agent-event is
+     * emitted. `EventEmitter#emit` calls listeners synchronously; if any
+     * listener throws (transport.send on a closed socket, normalizer bug,
+     * compaction tracking error, etc.) the throw would otherwise propagate
+     * out of failTurn before `turnReject` can run, leaving `await
+     * turnPromise` pending forever and silently hanging `driver.prompt(...)`
+     * — which in turn prevents the runner's `onAuthError` callback from
+     * firing on stale-token 401s. Settling the promise first guarantees the
+     * caller transitions even if the listener chain misbehaves; the emit is
+     * wrapped in try/catch so a listener failure cannot leak out.
+     *
+     * Spec: `_devlog/specs/2026-05-07-unified-credential-mediation.md`
+     * § "Runner-side handling on 401" (the AI 401 mediation path that
+     * exposed this hang).
+     */
+    private failTurn;
+    private handleSdkMessage;
+    /** Build an SDKUserMessage for streamInput. */
+    private buildUserMessage;
+    /** Wrap a single value as an AsyncIterable that yields once. */
+    private singleItemIterable;
+    private mapAssistantMessage;
+    private mapToolResults;
+    /**
+     * Requests the current SDK query to stop processing via `query.interrupt()` and
+     * signals the underlying `AbortController`. The driver remains usable after abort.
+     *
+     * @remarks Best-effort: if `interrupt()` throws (e.g. query already ended) the
+     *   error is silently swallowed and the abort signal is still sent.
+     */
+    abort(): Promise<void>;
+    /** `true` while the driver is processing a `prompt()` call. */
+    get isRunning(): boolean;
+    /**
+     * Closes the active SDK query and resets all session state.
+     *
+     * The driver instance must not be reused after `kill()`. Session IDs are cleared,
+     * so a new `ClaudeSdkDriver` will start a fresh session.
+     */
+    kill(): void;
+    listModels(): Promise<ModelEntry[]>;
+    getTokenUsage(): TokenUsage | null;
+    getContextWindow(): number | null;
+    resetSession(): Promise<void>;
+    /**
+     * Build allowedTools / disallowedTools options from AgentConfig.tools.
+     *
+     * When an allowlist is active, automatically prepend a wildcard entry for
+     * every configured MCP server (e.g. `mcp__skaile-connectors__*`) so that
+     * connector tools are never silently blocked by agent.yaml restrictions.
+     */
+    private buildToolRestrictions;
+    /**
+     * Map the simple string thinking config to SDK ThinkingConfig objects.
+     * This keeps the platform-layer SDK-agnostic while the bridge handles the mapping.
+     */
+    private mapThinkingConfig;
+    /**
+     * Find the Claude Code CLI executable.
+     *
+     * Resolution order:
+     * 1. CLAUDE_CODE_PATH env var (set in Docker containers where cli.js is
+     *    extracted from the SDK during build — bun-compiled binaries can't
+     *    access the SDK's bundled cli.js via $bunfs)
+     * 2. `which claude` on PATH (dev machines with claude installed globally)
+     * 3. undefined — let the SDK resolve its own bundled cli.js (works when
+     *    not running inside a bun-compiled binary)
+     */
+    private findClaudeBinary;
+}
+//# sourceMappingURL=claude-sdk.d.ts.map

package/dist/bridge/src/drivers/claude-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-sdk.d.ts","sourceRoot":"","sources":["../../../../bridge/src/drivers/claude-sdk.ts"],"names":[],"mappings":"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"}

package/dist/bridge/src/drivers/codex.d.ts

@@ -0,0 +1,66 @@
+import type { TokenUsage } from "@skaile/workspaces/types";
+import { type ModelEntry } from "../models.js";
+import { type AgentConfig, AgentDriver, type DriverInfo } from "../types.js";
+/**
+ * Agent driver for the OpenAI Codex SDK.
+ *
+ * Creates or resumes a Codex thread via `@openai/codex-sdk` (lazy-imported in `start()`)
+ * and maps Codex SDK thread events to the unified {@link AgentEvent} stream.
+ * OpenAI models only — uses `OPENAI_API_KEY` from `apiKeys`, `env`, or the environment.
+ *
+ * @remarks
+ * **Event mapping** — Codex SDK items are translated: `agent_message` → `message_start/update/end`,
+ * `command_execution` → Bash-shaped tool events, `mcp_tool_call` → MCP tool events,
+ * `file_change` → `ApplyPatch`-shaped events, `web_search` → `WebSearch` events.
+ *
+ * **Sandbox** — The Codex sandbox mode, approval policy, and reasoning effort are
+ * controlled via `AgentConfig.driverOptions.codex`. See {@link CodexDriverOptions}.
+ *
+ * **Instructions file** — System prompt and pre-rendered agent identity are combined
+ * into a single instructions file written to `<cwd>/.codex/skaile-session-instructions.md`
+ * and passed to the Codex SDK as `model_instructions_file`.
+ *
+ * @docLink packages/bridge/drivers#codex-driver
+ */
+export declare class CodexDriver extends AgentDriver {
+    readonly driverInfo: DriverInfo;
+    private readonly log;
+    private config;
+    private thread;
+    private running;
+    private abortController;
+    private pendingToolResults;
+    private activeAssistantItemId;
+    private activeAssistantText;
+    private _runtimeSessionId;
+    /** Token usage from the most recent completed turn. */
+    private _lastTokens;
+    constructor(config: AgentConfig);
+    get runtimeSessionId(): string | undefined;
+    start(): Promise<void>;
+    prompt(message: string): Promise<void>;
+    abort(): Promise<void>;
+    get isRunning(): boolean;
+    kill(): void;
+    listModels(): Promise<ModelEntry[]>;
+    resetSession(): Promise<void>;
+    getTokenUsage(): TokenUsage | null;
+    /**
+     * Write a combined instructions file for Codex CLI's `model_instructions_file` config.
+     * Combines pre-rendered agent identity (from `skaile install`) with runtime context
+     * (resources, environment, prompt-extensions).
+     */
+    private writeInstructionsFile;
+    private handleThreadEvent;
+    private handleThreadItem;
+    private handleAgentMessage;
+    private handleCommandExecution;
+    private handleMcpToolCall;
+    private handleFileChange;
+    private handleWebSearch;
+    private flushToolResults;
+    private buildAssistantMessage;
+    private toObject;
+    private classifyErrorMessage;
+}
+//# sourceMappingURL=codex.d.ts.map

package/dist/bridge/src/drivers/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../bridge/src/drivers/codex.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAU,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAEnE,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AAEpE,OAAO,EACL,KAAK,WAAW,EAChB,WAAW,EAIX,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAiCrB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,WAAY,SAAQ,WAAW;IAC1C,QAAQ,CAAC,UAAU,EAAE,UAAU,CAK7B;IAEF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAoC;IACxD,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAgC;IACvD,OAAO,CAAC,kBAAkB,CAAsB;IAChD,OAAO,CAAC,qBAAqB,CAAuB;IACpD,OAAO,CAAC,mBAAmB,CAAM;IACjC,OAAO,CAAC,iBAAiB,CAAqB;IAC9C,uDAAuD;IACvD,OAAO,CAAC,WAAW,CAA2B;gBAElC,MAAM,EAAE,WAAW;IAK/B,IAAa,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAElD;IAEY,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwDtB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAiDtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,IAAW,SAAS,IAAI,OAAO,CAE9B;IAEM,IAAI,IAAI,IAAI;IAOJ,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAQ5C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAO1B,aAAa,IAAI,UAAU,GAAG,IAAI;IAI3C;;;;OAIG;IACH,OAAO,CAAC,qBAAqB;IAyB7B,OAAO,CAAC,iBAAiB;IAoEzB,OAAO,CAAC,gBAAgB;IAuCxB,OAAO,CAAC,kBAAkB;IAuC1B,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,iBAAiB;IAmCzB,OAAO,CAAC,gBAAgB;IA6BxB,OAAO,CAAC,eAAe;IA4BvB,OAAO,CAAC,gBAAgB;IASxB,OAAO,CAAC,qBAAqB;IAO7B,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,oBAAoB;CA0E7B"}

package/dist/bridge/src/drivers/echo.d.ts

@@ -0,0 +1,59 @@
+import { AgentDriver, type AgentConfig, type BridgeCapabilityTool, type DriverInfo } from "../types.js";
+/**
+ * Echo/mock driver for E2E testing in docker mode.
+ *
+ * Runs inside a real Docker container with real WebSocket transport and
+ * session lifecycle, but generates deterministic keyword-triggered responses
+ * instead of calling the Anthropic API. This lets E2E tests exercise the
+ * full infrastructure (containers, WebSocket, session management, message
+ * persistence) without needing real AI credentials.
+ *
+ * Keyword triggers match the MockAgentClient in
+ * `platform/backend/libs/agent-gateway/src/mock-agent-client.ts` — the
+ * same test messages ("test toolcall", "test question", etc.) produce
+ * the same events.
+ *
+ * Enable by setting `SKAILE_AGENT_DRIVER=echo` in the container env,
+ * or by passing `{ driver: 'echo' }` in the runner config.
+ *
+ * @docLink packages/bridge/drivers#echo-driver
+ */
+export declare class EchoDriver extends AgentDriver {
+    readonly driverInfo: DriverInfo;
+    private readonly log;
+    private running;
+    private readonly config;
+    constructor(config: AgentConfig);
+    /**
+     * Test surface: returns the tool list the LLM would see for this turn.
+     * Composition: the registry hooks (Protocol v2) take precedence; legacy
+     * `mcpServers` is not enumerated here (the echo driver never exposed MCP
+     * tools to the LLM by name).
+     */
+    listCapabilityTools(): BridgeCapabilityTool[];
+    /**
+     * Test surface: invoke a registered capability through the dispatch
+     * helper. Mirrors what a real driver would do when the LLM produced a
+     * tool_use for the given name — applies fire-and-forget, render emission,
+     * and fallback text. Returns the structured dispatch result so tests can
+     * assert immediate-vs-background resolution.
+     */
+    invokeCapabilityForTest(name: string, input: unknown): Promise<{
+        result: unknown;
+        background: boolean;
+    }>;
+    start(): Promise<void>;
+    prompt(message: string): Promise<void>;
+    /**
+     * Phase 7B helper — drive a single capability through the dispatcher and
+     * surface the structured outcome as a result event the LLM-side test code
+     * can assert against. Used exclusively by the `[test-cap:<name>]` prompt
+     * keyword above; never wired into normal chat flow.
+     */
+    private runCapabilityKeyword;
+    abort(): Promise<void>;
+    kill(): void;
+    resetSession(): Promise<void>;
+    get isRunning(): boolean;
+}
+//# sourceMappingURL=echo.d.ts.map

package/dist/bridge/src/drivers/echo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"echo.d.ts","sourceRoot":"","sources":["../../../../bridge/src/drivers/echo.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,WAAW,EACX,KAAK,WAAW,EAEhB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EAChB,MAAM,aAAa,CAAC;AAErB;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAW,SAAQ,WAAW;IACzC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAK7B;IAEF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAmC;IACvD,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;gBAEzB,MAAM,EAAE,WAAW;IAK/B;;;;;OAKG;IACH,mBAAmB,IAAI,oBAAoB,EAAE;IAI7C;;;;;;OAMG;IACG,uBAAuB,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,GACb,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IAa9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+C5C;;;;;OAKG;YACW,oBAAoB;IAqB5B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,IAAI,IAAI,IAAI;IAKN,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAInC,IAAI,SAAS,IAAI,OAAO,CAEvB;CACF"}

package/dist/bridge/src/drivers/omp.d.ts

@@ -0,0 +1,101 @@
+import type { ModelEntry } from "../models.js";
+import { type AgentConfig, AgentDriver, type DriverInfo } from "../types.js";
+/**
+ * Agent driver for the oh-my-pi (omp) coding agent.
+ *
+ * Spawns `omp --mode rpc` as a child process and communicates via newline-delimited
+ * JSON-RPC over stdin/stdout. Model-agnostic: supports any LLM provider.
+ *
+ * @see https://github.com/can1357/oh-my-pi
+ *
+ * @remarks
+ * **Session persistence** — omp writes JSONL session files to `<cwd>/.omp/sessions/`
+ * (via `--session-dir`). After each turn (`agent_end`), sends a `get_state` RPC to
+ * capture the native session ID and emits a `session_info` event so the forge layer
+ * can persist it. On the next spawn, callers pass `resumeSessionId` to restore omp's
+ * native context.
+ *
+ * **stderrBuffer** — collects the last 20 lines of stderr so they can be appended to
+ * crash error messages for diagnostics without blocking the stdout readline loop.
+ *
+ * **systemPrompt injection** — omp does not accept a system prompt string directly.
+ * The driver writes `AgentConfig.systemPrompt` to `<cwd>/.omp/system.md` and passes
+ * the path via `--append-system-prompt` before spawning.
+ *
+ * **agentDir** — maps to the `PI_CODING_AGENT_DIR` environment variable. omp reads the
+ * GitAgent directory at this path natively (agent.yaml, SOUL.md, RULES.md, knowledge/).
+ *
+ * @docLink packages/bridge/drivers#omp-driver
+ */
+export declare class OmpDriver extends AgentDriver {
+    readonly driverInfo: DriverInfo;
+    private readonly log;
+    private proc;
+    private rl;
+    private reqId;
+    private config;
+    private ready;
+    private startPromise;
+    private stderrBuffer;
+    private prevText;
+    /** OMP session ID captured via `get_state` after each turn. */
+    private _ompSessionId?;
+    get runtimeSessionId(): string | undefined;
+    getModel(): string | undefined;
+    /**
+     * @param config - Driver configuration. omp-relevant fields:
+     *   - `cwd` — working directory; omp session files are stored under `<cwd>/.omp/sessions/`.
+     *   - `model` / `provider` — forwarded as `--model [provider/]model`.
+     *   - `systemPrompt` — written to `<cwd>/.omp/system.md` and appended via `--append-system-prompt`.
+     *   - `agentDir` — sets `PI_CODING_AGENT_DIR`; omp reads agent identity from this directory.
+     *   - `sshKeyPath` — injected as `GIT_SSH_COMMAND` for authenticated git operations.
+     *   - `resumeSessionId` — omp session UUID to restore via `--session <id>`.
+     */
+    constructor(config: AgentConfig);
+    start(): Promise<void>;
+    private _start;
+    private extractMessageText;
+    private handleEvent;
+    /**
+     * Query OMP for the current session ID via `get_state` RPC.
+     * Emits a `session_info` event on success so the forge layer can persist the ID.
+     * Failures are silently swallowed — session tracking is best-effort.
+     */
+    private captureSessionId;
+    private nextId;
+    private send;
+    /**
+     * Sends a prompt to the omp process via JSON-RPC and returns immediately.
+     *
+     * The driver emits `agent-event` payloads as omp streams responses on stdout.
+     * Callers should await the `agent_end` event (or the `prompt()` resolution) to
+     * know when the turn is complete.
+     *
+     * @param message - Plain-text user prompt.
+     * @throws {Error} When the omp process is not running or its stdin is closed.
+     */
+    prompt(message: string): Promise<void>;
+    /**
+     * Sends an in-band abort RPC to the omp process, requesting it to stop the
+     * current turn without terminating the child process.
+     *
+     * @remarks This is a best-effort signal — omp may not honour the abort
+     *   immediately. The process remains alive after `abort()`.
+     */
+    abort(): Promise<void>;
+    /** `true` when the omp child process is alive and has not been killed. */
+    get isRunning(): boolean;
+    /**
+     * Sends SIGTERM to the omp child process and performs cleanup.
+     *
+     * The driver instance must not be reused after `kill()`. Create a new
+     * `OmpDriver` to start a fresh session.
+     */
+    kill(): void;
+    resetSession(): Promise<void>;
+    private classifyProcessError;
+    private classifyErrorMessage;
+    listModels(): Promise<ModelEntry[]>;
+    private cleanup;
+}
+//# sourceMappingURL=omp.d.ts.map

package/dist/bridge/src/drivers/omp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omp.d.ts","sourceRoot":"","sources":["../../../../bridge/src/drivers/omp.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,KAAK,WAAW,EAAE,WAAW,EAAmB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAyD9F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,SAAU,SAAQ,WAAW;IACxC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAK7B;IAEF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkC;IACtD,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,EAAE,CAA0B;IACpC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,YAAY,CAAgB;IACpC,OAAO,CAAC,QAAQ,CAAM;IACtB,+DAA+D;IAC/D,OAAO,CAAC,aAAa,CAAC,CAAS;IAE/B,IAAa,gBAAgB,IAAI,MAAM,GAAG,SAAS,CAElD;IAEQ,QAAQ,IAAI,MAAM,GAAG,SAAS;IAIvC;;;;;;;;OAQG;gBACS,MAAM,EAAE,WAAW;IAKlB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAOrB,MAAM;IAmKpB,OAAO,CAAC,kBAAkB;IAY1B,OAAO,CAAC,WAAW;IAgDnB;;;;OAIG;YACW,gBAAgB;IAqC9B,OAAO,CAAC,MAAM;IAId,OAAO,CAAC,IAAI;IAcZ;;;;;;;;;OASG;IACU,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMnD;;;;;;OAMG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMnC,0EAA0E;IAC1E,IAAW,SAAS,IAAI,OAAO,CAE9B;IAED;;;;;OAKG;IACH,IAAI,IAAI,IAAI;IAON,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAKnC,OAAO,CAAC,oBAAoB;IAyB5B,OAAO,CAAC,oBAAoB;IAuEb,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IA8BlD,OAAO,CAAC,OAAO;CAQhB"}

package/dist/bridge/src/error-classifier.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Error classification for the Claude Agent SDK driver.
+ *
+ * Wraps the Anthropic API error patterns surfaced through the bundled
+ * `claude-cli.js`. The CLI flattens upstream HTTP errors into terse strings
+ * like:
+ *
+ *   `Claude Code returned an error result: Failed to authenticate. API Error:
+ *    401 {"type":"error","error":{"type":"authentication_error","message":
+ *    "Invalid authentication credentials"}}`
+ *
+ * Word-for-word that reads as an auth failure, but in practice it also
+ * fires when a Claude Max OAuth subscription has exhausted its current
+ * quota window — Anthropic returns a non-200 that the CLI relabels as
+ * "Failed to authenticate" without preserving the original error type.
+ *
+ * The classifier here:
+ *   1. Parses an embedded JSON body when the upstream included one
+ *      (e.g. `{"type":"error","error":{"type":"rate_limit_error",...}}`)
+ *      so we believe the structured `error.type` over the surrounding
+ *      free-text wrapper.
+ *   2. Honours the SDK's `terminal_reason` when it explicitly indicates
+ *      a blocking-limit / rapid-refill / model-error condition — those
+ *      are authoritative even if the textual error reads as auth.
+ *   3. Falls back to keyword heuristics on the message text.
+ *   4. For OAuth-style credentials (Claude Code subscriptions), adds a
+ *      hint that bounces user attention to quota rather than credentials,
+ *      because that's overwhelmingly the cause when a CredentialsFile
+ *      provider that worked yesterday now returns "Invalid authentication
+ *      credentials" without anyone touching the file.
+ */
+import type { AgentError } from "./types.js";
+/**
+ * Error thrown by drivers when the upstream provider rejects the credential
+ * with an authentication-shaped failure (HTTP 401 / `authentication_error`
+ * structured body). Carries the structured {@link AgentError} produced by
+ * {@link classifyClaudeSdkError} so the runner can mediate without
+ * re-classifying string text.
+ *
+ * The runner's 401-mediation handler `instanceof`-discriminates on this
+ * subclass so the auth-vs-rate_limit fork stays in one place.
+ *
+ * Spec: `_devlog/specs/2026-05-07-unified-credential-mediation.md`
+ * § "Runner-side handling on 401".
+ *
+ * @category Errors
+ * @since 3.3.0
+ */
+export declare class AuthError extends Error {
+    readonly detail: AgentError;
+    constructor(detail: AgentError);
+}
+/**
+ * Input shape for {@link classifyClaudeSdkError} when decoding an `SDKResultError`.
+ *
+ * All fields are optional; `classifyClaudeSdkError` also accepts a plain `string`
+ * (a thrown exception message) for the common non-SDK code paths.
+ *
+ * @docLink packages/bridge/api-reference#error-classifier
+ */
+export interface ClaudeSdkResultErrorInput {
+    /** `errors` array from `SDKResultError`. Empty when not provided. */
+    errors?: string[];
+    /**
+     * `terminal_reason` from `SDKResultError`. Authoritative when set to a
+     * blocking/rapid-refill value, regardless of message text.
+     */
+    terminalReason?: string;
+    /** `subtype` from `SDKResultError` — `error_max_turns` etc. */
+    subtype?: string;
+    /**
+     * `true` when the configured Anthropic credential is a Claude Code
+     * subscription (`CredentialsFile` provider) rather than a raw API key.
+     * Changes the hint copy because `Invalid authentication credentials`
+     * on an OAuth subscription almost always means quota.
+     */
+    oauthCredential?: boolean;
+}
+/**
+ * Classify a Claude SDK result-error or thrown error into a structured
+ * {@link AgentError}. Pure function — safe to call from any layer.
+ *
+ * @param input - Either a free-text error message (from a thrown exception)
+ *   or a partially-decoded `SDKResultError` shape with `errors[]`,
+ *   `terminal_reason`, and `subtype`.
+ * @returns A category, retryable flag, and human-readable hint.
+ * @docLink packages/bridge/api-reference#error-classifier
+ */
+export declare function classifyClaudeSdkError(input: string | ClaudeSdkResultErrorInput): AgentError;
+//# sourceMappingURL=error-classifier.d.ts.map

package/dist/bridge/src/error-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-classifier.d.ts","sourceRoot":"","sources":["../../../bridge/src/error-classifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;gBAChB,MAAM,EAAE,UAAU;CAK/B;AAcD;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACxC,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB,GAAG,UAAU,CAuN5F"}

package/dist/bridge/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./capability-dispatch.js";
+export { AuthError, type ClaudeSdkResultErrorInput, classifyClaudeSdkError, } from "./error-classifier.js";
+export * from "./logger.js";
+export * from "./models.js";
+export * from "./normalizer.js";
+export * from "./registry.js";
+export * from "./runtime.js";
+export * from "./types.js";
+export * from "./validation.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/bridge/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../bridge/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,OAAO,EACL,SAAS,EACT,KAAK,yBAAyB,EAC9B,sBAAsB,GACvB,MAAM,uBAAuB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC"}

package/dist/bridge/src/logger.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Bridge-layer logger factory.
+ *
+ * Each driver creates its own Logger via `getBridgeLogger(subkind)` at
+ * construction time. Falls back to an off-mode Logger (stdout only) when
+ * no LogStore is registered — see @skaile/workspaces/core/logging for details.
+ */
+import type { Logger } from "@skaile/workspaces/types";
+/**
+ * Construct a bridge-scoped Logger for a given driver subkind.
+ *
+ * Creates a `Logger` with `kind: "bridge"` and the specified `subkind`. Falls back to
+ * an off-mode Logger (stdout only) when no `LogStore` is registered — see
+ * `@skaile/workspaces/core/logging` for details. Each driver calls this once at construction
+ * time; never re-construct per call.
+ *
+ * @param subkind - Driver id, e.g. `"claude-sdk"`, `"omp"`, `"echo"`, `"codex"`.
+ * @returns A `Logger` scoped to `bridge:<subkind>`.
+ * @docLink packages/bridge/api-reference#logger
+ */
+export declare function getBridgeLogger(subkind: string): Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/bridge/src/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../bridge/src/logger.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD"}