@cerebriline/core 4.100.240

package/dist/extensions/context/work-digest.d.ts

@@ -0,0 +1,92 @@
+/**
+ * One artifact for two jobs: what a swarm worker reports, and what compaction
+ * writes.
+ *
+ * These were always going to be the same thing and the reference implementation
+ * says so outright -- reuse the fan-out digest schema per compacted turn-span,
+ * so a fan-out digest and a compaction summary read identically to the model.
+ * The reason is concrete rather than tidy: a swarm round frequently returns
+ * while the lead is already over its compaction watermark, and if the two are
+ * different artifacts the round's result *adds* to the pressure it was spawned
+ * to relieve. Sharing the form means the commit-back can be fed straight to
+ * compaction instead.
+ *
+ * The sections are the ones `DEFAULT_COMPACTION_PROMPT` already names, because
+ * that prompt is in production and its output is what has to keep parsing.
+ *
+ * **Free-form JSON in a fence, read tolerantly -- not a grammar.** This is the
+ * reference implementation's own resolved decision and it is the right one: a
+ * worker made to satisfy a schema spends its turn satisfying the schema. So the
+ * parser takes a fenced block if there is one, the markdown headings if there
+ * is not, and the prose itself if there is neither. A worker that breaks the
+ * contract entirely is still represented, because the reducer cannot otherwise
+ * tell "nothing to report" from "lost", and a silently absent worker is exactly
+ * the failure this path exists to avoid.
+ */
+/** One heading, and the field behind it. */
+export interface WorkDigestSection {
+    heading: string;
+    key: keyof WorkDigest;
+    /** A single paragraph, or a list of lines. */
+    list: boolean;
+}
+export interface WorkDigest {
+    /** Who wrote it. Absent on the lead's own compaction note. */
+    agent?: string;
+    goal?: string;
+    done?: readonly string[];
+    inProgress?: readonly string[];
+    ruledOut?: readonly string[];
+    keyFacts?: readonly string[];
+    next?: readonly string[];
+    /**
+     * Everything that did not fit the form.
+     *
+     * A worker that wrote prose still reported; this is where that lands, and
+     * it is why nothing is ever dropped for being off-contract.
+     */
+    notes?: string;
+    /** What went wrong, when something did. */
+    error?: string;
+    /**
+     * The reasoning tail of a turn that produced no content.
+     *
+     * A worker that spends its whole budget thinking returns
+     * `finish_reason: "length"` with an empty content channel and a full
+     * reasoning one. In that case the chain of thought *is* the requested
+     * output, and discarding the turn discards the work -- so it is carried
+     * here rather than lost with the transcript when the pool is released.
+     */
+    reasoning?: string;
+}
+/** The sections, in the order the compaction note writes them. */
+export declare const WORK_DIGEST_SECTIONS: readonly WorkDigestSection[];
+/**
+ * Read whatever a worker wrote into a digest.
+ *
+ * Three readings in order -- a fenced block, the markdown headings, then the
+ * prose -- and the last one never fails, which is the point: an off-contract
+ * worker is reported as itself rather than as an absence.
+ */
+export declare function parseWorkDigest(text: string | undefined): WorkDigest | undefined;
+/**
+ * Write a digest in the form the compaction note uses.
+ *
+ * Empty sections are omitted rather than written blank: a heading with nothing
+ * under it reads to the model as "this was considered and there is nothing",
+ * which is a claim, and one the worker did not make.
+ */
+export declare function renderWorkDigest(digest: WorkDigest): string;
+/**
+ * Fold several workers' digests into one.
+ *
+ * This is what the reducer does without a model, and what it falls back to when
+ * the model call fails. A single digest passes through untouched: with one
+ * worker there is nothing to reduce, and a model call there spends a round trip
+ * rewriting the answer it was given.
+ *
+ * Two workers on one prefix reach the same conclusion often, so an identical
+ * line is said once with both names on it -- repeating it makes the round look
+ * like twice the work it was.
+ */
+export declare function mergeWorkDigests(digests: readonly WorkDigest[]): WorkDigest;

package/dist/extensions/index.d.ts

@@ -0,0 +1,7 @@
+export type { AgentPluginPackageDiagnostic, AgentPluginPackageDiagnosticScope, AgentPluginPackageLoadReport, AgentPluginPackageManifest, AgentPluginPackageMcpServer, AgentPluginPackageSkill, AgentSkillMetadata, LoadAgentPluginPackagesOptions, LoadedAgentPluginPackage, ParsedAgentSkill, } from "./agent-plugin";
+export { AGENT_PLUGINS_V1_MANIFEST_SCHEMA, AGENT_PLUGINS_V1_MCP_SCHEMA, loadAgentPluginPackages, parseAgentSkillMarkdown, } from "./agent-plugin";
+export type { ResolveAgentPluginPathsOptions } from "./plugin/plugin-config-loader";
+export { discoverPluginModulePaths, getPluginDisplayName, resolveAgentPluginPaths, resolveAndLoadAgentPlugins, resolvePluginConfigSearchPaths, resolvePluginSkillDirectoriesFromPaths, } from "./plugin/plugin-config-loader";
+export type { PluginInitializationFailure, PluginInitializationWarning, PluginLoadDiagnostics, } from "./plugin/plugin-load-report";
+export type { LoadAgentPluginFromPathOptions } from "./plugin/plugin-loader";
+export { loadAgentPluginFromPath, loadAgentPluginsFromPaths, loadAgentPluginsFromPathsWithDiagnostics, } from "./plugin/plugin-loader";

package/dist/extensions/mcp/client.d.ts

@@ -0,0 +1,28 @@
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { McpServerClientFactory } from "./types";
+export declare const DEFAULT_MCP_CONNECT_TIMEOUT_MS = 3000;
+export declare const DEFAULT_HTTP_MCP_CONNECT_TIMEOUT_MS = 10000;
+export interface DefaultMcpServerClientFactoryOptions {
+    settingsPath?: string;
+    clientName?: string;
+    clientVersion?: string;
+    fetch?: FetchLike;
+    /** Keep literal configured headers on the declared MCP origin only. */
+    restrictConfiguredHeadersToOrigin?: boolean;
+}
+export interface ProbeMcpServerConnectionOptions extends Omit<DefaultMcpServerClientFactoryOptions, "settingsPath"> {
+    serverName: string;
+    filePath?: string;
+}
+export interface ProbeMcpServerConnectionResult {
+    serverName: string;
+    connected: boolean;
+    authorizationRequired: boolean;
+    error?: string;
+}
+export declare function createDefaultMcpServerClientFactory(options?: DefaultMcpServerClientFactoryOptions): McpServerClientFactory;
+/**
+ * Passively verifies a configured remote MCP endpoint. This may use or refresh
+ * existing credentials, but it never starts an interactive OAuth redirect.
+ */
+export declare function probeMcpServerConnection(options: ProbeMcpServerConnectionOptions): Promise<ProbeMcpServerConnectionResult>;

package/dist/extensions/mcp/config-loader.d.ts

@@ -0,0 +1,102 @@
+import type { BasicLogger } from "@cerebriline/shared";
+import type { McpManager, McpServerOAuthClientConfig, McpServerOAuthState, McpServerOAuthStatus, McpServerRegistration } from "./types";
+export interface McpSettingsFile {
+    mcpServers: Record<string, Omit<McpServerRegistration, "name">>;
+}
+export interface LoadMcpSettingsOptions {
+    filePath?: string;
+}
+export interface UpdateMcpServerOAuthStateOptions extends LoadMcpSettingsOptions {
+    /**
+     * When present, only update OAuth state while the server still has this
+     * configured client. `null` asserts that dynamic registration is still in use.
+     */
+    expectedOAuthClient?: McpServerOAuthClientConfig | null;
+}
+export interface RegisterMcpServersFromSettingsOptions {
+    filePath?: string;
+}
+export interface SetMcpServerDisabledOptions {
+    filePath?: string;
+    name: string;
+    disabled: boolean;
+}
+export interface McpSettingsLockOptions {
+    /** Maximum time to wait for the lock before failing. Defaults to 10 seconds. */
+    timeoutMs?: number;
+    /** Optional host logger; stale-lock takeover is logged as severity=warn. */
+    logger?: BasicLogger;
+}
+export type McpSettingsMutator<T> = (settings: Record<string, unknown>) => T;
+export declare class McpSettingsUpdateSkippedError extends Error {
+    constructor(message: string);
+}
+export declare class McpOAuthClientChangedError extends Error {
+    constructor(serverName: string);
+}
+export declare class McpSettingsLockTimeoutError extends Error {
+    constructor(message: string);
+}
+export declare class McpSettingsMutatorPurityError extends Error {
+    constructor(message: string);
+}
+export declare function resolveDefaultMcpSettingsPath(): string;
+/**
+ * Locked MCP settings read-modify-write that blocks the event loop (via
+ * `Atomics.wait`) while acquiring the lock.
+ *
+ * Prefer {@link updateMcpSettingsFile}: async acquisition keeps the event loop
+ * free and behaves identically otherwise.
+ *
+ * TODO: Delete once all callers migrate to {@link updateMcpSettingsFile}.
+ *
+ * The mutator is synchronous and may be called more than once with the same
+ * input to verify it is pure/deterministic. Compute any I/O, logging, network,
+ * timestamp, or random values before calling and close over them. Return a value
+ * only for a successful update; throw McpSettingsUpdateSkippedError to skip.
+ */
+export declare function updateMcpSettingsFileSync<T>(filePath: string, mutator: McpSettingsMutator<T>, options?: McpSettingsLockOptions): T;
+/**
+ * Locked MCP settings read-modify-write that yields the event loop while
+ * acquiring the lock, so concurrent work on the same loop keeps running.
+ *
+ * The mutator is synchronous and may be called more than once with the same
+ * input to verify it is pure/deterministic. Compute any I/O, logging, network,
+ * timestamp, or random values before calling and close over them. The lock is
+ * held only across the synchronous mutation, never across an `await`. Return a
+ * value only for a successful update; throw McpSettingsUpdateSkippedError to skip.
+ */
+export declare function updateMcpSettingsFile<T>(filePath: string, mutator: McpSettingsMutator<T>, options?: McpSettingsLockOptions): Promise<T>;
+export declare function loadMcpSettingsFile(options?: LoadMcpSettingsOptions): McpSettingsFile;
+export declare function normalizeMcpServerOAuthState(value: McpServerOAuthState | undefined): McpServerOAuthState | undefined;
+export declare function hasMcpSettingsFile(options?: LoadMcpSettingsOptions): boolean;
+export declare function resolveMcpServerRegistrations(options?: LoadMcpSettingsOptions): McpServerRegistration[];
+/**
+ * Parses one raw MCP settings entry without requiring sibling entries to be
+ * valid. Hosts with an editable settings UI can use this to keep healthy and
+ * repairable entries visible when a hand-edited sibling is malformed.
+ */
+export declare function parseMcpServerRegistration(name: string, value: unknown): McpServerRegistration;
+/** Resolves one configured server without requiring sibling entries to parse. */
+export declare function resolveMcpServerRegistration(serverName: string, options?: LoadMcpSettingsOptions): McpServerRegistration | undefined;
+export declare function setMcpServerDisabled(options: SetMcpServerDisabledOptions): void;
+export declare function getMcpServerOAuthState(serverName: string, options?: LoadMcpSettingsOptions): McpServerOAuthState | undefined;
+/**
+ * Scoped read-modify-write of one server's `oauth` block that blocks the event
+ * loop while acquiring the lock.
+ *
+ * Prefer {@link updateMcpServerOAuthStateAsync}.
+ *
+ * TODO: Delete once all callers migrate to {@link updateMcpServerOAuthStateAsync}.
+ */
+export declare function updateMcpServerOAuthState(serverName: string, updater: (current: McpServerOAuthState) => McpServerOAuthState, options?: UpdateMcpServerOAuthStateOptions): McpServerOAuthState;
+/**
+ * Scoped read-modify-write of one server's `oauth` block that yields the event
+ * loop while acquiring the lock. The updater is synchronous and pure; it
+ * receives the server's current OAuth state and returns the next state.
+ */
+export declare function updateMcpServerOAuthStateAsync(serverName: string, updater: (current: McpServerOAuthState) => McpServerOAuthState, options?: UpdateMcpServerOAuthStateOptions): Promise<McpServerOAuthState>;
+export declare function listMcpServerOAuthStatuses(options?: LoadMcpSettingsOptions): McpServerOAuthStatus[];
+/** Calculates OAuth status for one already-parsed registration. */
+export declare function getMcpServerOAuthStatus(registration: McpServerRegistration): McpServerOAuthStatus;
+export declare function registerMcpServersFromSettingsFile(manager: Pick<McpManager, "registerServer">, options?: RegisterMcpServersFromSettingsOptions): Promise<McpServerRegistration[]>;

package/dist/extensions/mcp/index.d.ts

@@ -0,0 +1,15 @@
+export type { DefaultMcpServerClientFactoryOptions, ProbeMcpServerConnectionOptions, ProbeMcpServerConnectionResult, } from "./client";
+export { createDefaultMcpServerClientFactory, DEFAULT_MCP_CONNECT_TIMEOUT_MS, probeMcpServerConnection, } from "./client";
+export type { LoadMcpSettingsOptions, McpSettingsFile, McpSettingsLockOptions, McpSettingsMutator, RegisterMcpServersFromSettingsOptions, SetMcpServerDisabledOptions, UpdateMcpServerOAuthStateOptions, } from "./config-loader";
+export { getMcpServerOAuthState, getMcpServerOAuthStatus, hasMcpSettingsFile, listMcpServerOAuthStatuses, loadMcpSettingsFile, McpOAuthClientChangedError, McpSettingsLockTimeoutError, McpSettingsMutatorPurityError, McpSettingsUpdateSkippedError, parseMcpServerRegistration, registerMcpServersFromSettingsFile, resolveDefaultMcpSettingsPath, resolveMcpServerRegistration, resolveMcpServerRegistrations, setMcpServerDisabled, updateMcpServerOAuthState, updateMcpServerOAuthStateAsync, updateMcpSettingsFile, updateMcpSettingsFileSync, } from "./config-loader";
+export { InMemoryMcpManager } from "./manager";
+export { defaultMcpToolNameTransform } from "./name-transform";
+export type { AuthorizeMcpServerOAuthOptions, AuthorizeMcpServerOAuthResult, CreateMcpOAuthProviderContextOptions, McpOAuthProviderContext, } from "./oauth";
+export { authorizeMcpServerOAuth } from "./oauth";
+export type { PluginMcpServerResolution } from "./plugin-server-registration";
+export { normalizePluginMcpServerRegistration, resolvePluginMcpServerRegistrations, } from "./plugin-server-registration";
+export type { CreateDisabledMcpToolPoliciesOptions, CreateDisabledMcpToolPolicyOptions, } from "./policies";
+export { createDisabledMcpToolPolicies, createDisabledMcpToolPolicy, } from "./policies";
+export { augmentMcpTimeoutError } from "./timeout";
+export { createMcpTools } from "./tools";
+export type { CreateMcpToolsOptions, McpConnectionStatus, McpManager, McpManagerOptions, McpServerClient, McpServerClientFactory, McpServerOAuthClientConfig, McpServerOAuthState, McpServerOAuthStatus, McpServerRegistration, McpServerSnapshot, McpServerTransportConfig, McpSseTransportConfig, McpStdioTransportConfig, McpStreamableHttpTransportConfig, McpToolCallRequest, McpToolCallResult, McpToolDescriptor, McpToolNameTransform, McpToolProvider, } from "./types";

package/dist/extensions/mcp/manager.d.ts

@@ -0,0 +1,23 @@
+import type { McpManager, McpManagerOptions, McpServerRegistration, McpServerSnapshot, McpToolCallRequest, McpToolCallResult, McpToolDescriptor } from "./types";
+export declare class InMemoryMcpManager implements McpManager {
+    private readonly toolsCacheTtlMs;
+    private readonly clientFactory;
+    private readonly servers;
+    private readonly operationLocks;
+    constructor(options: McpManagerOptions);
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+    private ensureConnectedClient;
+    private connectState;
+    private disconnectState;
+    private requireServer;
+    private runExclusive;
+}

package/dist/extensions/mcp/name-transform.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolNameTransform } from "./types";
+export declare const defaultMcpToolNameTransform: McpToolNameTransform;

package/dist/extensions/mcp/oauth.d.ts

@@ -0,0 +1,68 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { OAuthClientInformationMixed } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { FetchLike } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { type OAuthServerCloseInfo, type OAuthServerListeningInfo } from "../../auth/server";
+import type { McpServerOAuthClientConfig, McpServerRegistration } from "./types";
+export type McpSdkAuthCapableTransport = SSEClientTransport | StreamableHTTPClientTransport;
+export declare function createOriginBoundMcpHeadersFetch(input: {
+    endpointUrl: string;
+    configuredHeaders: Record<string, string>;
+    baseFetch?: FetchLike;
+}): FetchLike;
+export interface CreateMcpOAuthProviderContextOptions {
+    settingsPath?: string;
+    serverName: string;
+    redirectUrl: string;
+    onAuthorizationUrl?: (url: string) => void | Promise<void>;
+    clientInformation?: OAuthClientInformationMixed;
+}
+export interface McpOAuthProviderContext {
+    provider: OAuthClientProvider;
+    getLastAuthorizationUrl(): string | undefined;
+    getLastOAuthState(): string | undefined;
+    resetInteractiveState(): Promise<void>;
+    markError(errorMessage: string): Promise<void>;
+    markConnectionError(errorMessage: string): Promise<void>;
+    markAuthorizationRequired(errorMessage: string): Promise<void>;
+    clearError(): Promise<void>;
+}
+export interface AuthorizeMcpServerOAuthOptions {
+    serverName: string;
+    filePath?: string;
+    clientName?: string;
+    clientVersion?: string;
+    fetch?: FetchLike;
+    openUrl?: (url: string) => void | Promise<void>;
+    callbackHost?: string;
+    callbackPorts?: number[];
+    callbackPath?: string;
+    timeoutMs?: number;
+    successHtml?: string;
+    onServerListening?: (info: OAuthServerListeningInfo) => void | Promise<void>;
+    onServerClose?: (info: OAuthServerCloseInfo) => void | Promise<void>;
+    signal?: AbortSignal;
+}
+export interface AuthorizeMcpServerOAuthResult {
+    serverName: string;
+    authorized: true;
+    message: string;
+}
+export declare function createMcpOAuthClientInformation(config: McpServerOAuthClientConfig | undefined): OAuthClientInformationMixed | undefined;
+export declare function createMcpOAuthProviderContext(options: CreateMcpOAuthProviderContextOptions): McpOAuthProviderContext;
+export declare function createMcpSdkTransport(input: {
+    registration: McpServerRegistration;
+    oauthProvider?: OAuthClientProvider;
+    fetch?: FetchLike;
+    restrictConfiguredHeadersToOrigin?: boolean;
+}): McpSdkAuthCapableTransport;
+/**
+ * Recognizes a 401 from a remote MCP server across transports. The streamable
+ * HTTP transport (and SSE message POSTs) reject with the typed
+ * UnauthorizedError raised at the fetch boundary, but the SSE stream request
+ * runs inside EventSource, which consumes the response and reports the HTTP
+ * status only through SseError's code.
+ */
+export declare function isMcpUnauthorizedError(error: unknown): boolean;
+export declare function authorizeMcpServerOAuth(options: AuthorizeMcpServerOAuthOptions): Promise<AuthorizeMcpServerOAuthResult>;

package/dist/extensions/mcp/plugin-server-registration.d.ts

@@ -0,0 +1,18 @@
+import type { AgentExtensionMcpServer } from "@cerebriline/shared";
+import type { McpServerRegistration } from "./types";
+export interface PluginMcpServerResolution<TOwner> {
+    owner: TOwner;
+    name: string;
+    registration?: McpServerRegistration;
+    loadError?: string;
+}
+export declare function normalizePluginMcpServerRegistration(server: AgentExtensionMcpServer): {
+    name: string;
+    registration?: McpServerRegistration;
+    loadError?: string;
+};
+export declare function resolvePluginMcpServerRegistrations<TOwner>(servers: readonly {
+    server: AgentExtensionMcpServer;
+    owner: TOwner;
+    ownerLabel?: string;
+}[]): PluginMcpServerResolution<TOwner>[];

package/dist/extensions/mcp/policies.d.ts

@@ -0,0 +1,14 @@
+import type { ToolPolicy } from "@cerebriline/shared";
+import type { McpToolNameTransform } from "./types";
+export interface CreateDisabledMcpToolPolicyOptions {
+    serverName: string;
+    toolName: string;
+    nameTransform?: McpToolNameTransform;
+}
+export interface CreateDisabledMcpToolPoliciesOptions {
+    serverName: string;
+    toolNames: readonly string[];
+    nameTransform?: McpToolNameTransform;
+}
+export declare function createDisabledMcpToolPolicy(options: CreateDisabledMcpToolPolicyOptions): Record<string, ToolPolicy>;
+export declare function createDisabledMcpToolPolicies(options: CreateDisabledMcpToolPoliciesOptions): Record<string, ToolPolicy>;

package/dist/extensions/mcp/remote-proxy.d.ts

@@ -0,0 +1,9 @@
+import type { McpServerTransportConfig, McpStdioTransportConfig, McpStreamableHttpTransportConfig } from "./types";
+/**
+ * Recognizes the exact no-option `npx mcp-remote <url>` proxy shape emitted by
+ * older marketplace entries. Cline has a native Streamable HTTP transport, so
+ * spawning the proxy would duplicate OAuth handling and let the child process
+ * open a browser as a side effect of merely enabling the server.
+ */
+export declare function resolveMcpRemoteProxyTransport(transport: McpStdioTransportConfig): McpStreamableHttpTransportConfig | undefined;
+export declare function resolveNativeMcpTransport(transport: McpServerTransportConfig): McpServerTransportConfig;

package/dist/extensions/mcp/timeout.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveMcpRequestTimeoutMs(timeoutSeconds: unknown): number;
+export declare function augmentMcpTimeoutError(error: unknown, serverName: string, timeoutMs: number): unknown;

package/dist/extensions/mcp/tools.d.ts

@@ -0,0 +1,3 @@
+import { type AgentTool } from "@cerebriline/shared";
+import type { CreateMcpToolsOptions } from "./types";
+export declare function createMcpTools(options: CreateMcpToolsOptions): Promise<AgentTool[]>;

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

@@ -0,0 +1,133 @@
+import type { AgentToolContext } from "@cerebriline/shared";
+export interface McpToolDescriptor {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+    /** The server's `annotations.readOnlyHint`: the tool does not modify its environment. */
+    readOnlyHint?: boolean;
+}
+export interface McpToolCallRequest {
+    serverName: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    context?: AgentToolContext;
+}
+export type McpToolCallResult = unknown;
+export interface McpToolProvider {
+    listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+}
+export type McpToolNameTransform = (input: {
+    serverName: string;
+    toolName: string;
+}) => string;
+export interface CreateMcpToolsOptions {
+    serverName: string;
+    provider: McpToolProvider;
+    nameTransform?: McpToolNameTransform;
+    timeoutMs?: number;
+    retryable?: boolean;
+    maxRetries?: number;
+}
+export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
+export interface McpStdioTransportConfig {
+    type: "stdio";
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export interface McpSseTransportConfig {
+    type: "sse";
+    url: string;
+    headers?: Record<string, string>;
+}
+export interface McpStreamableHttpTransportConfig {
+    type: "streamableHttp";
+    url: string;
+    headers?: Record<string, string>;
+}
+export type McpServerTransportConfig = McpStdioTransportConfig | McpSseTransportConfig | McpStreamableHttpTransportConfig;
+export interface McpServerOAuthState {
+    clientInformation?: Record<string, unknown>;
+    tokens?: Record<string, unknown>;
+    codeVerifier?: string;
+    discoveryState?: Record<string, unknown>;
+    redirectUrl?: string;
+    lastError?: string;
+    lastAuthenticatedAt?: number;
+    authorizationRequired?: boolean;
+}
+export interface McpServerOAuthClientConfig {
+    clientId: string;
+    clientSecret?: string;
+}
+export interface McpServerOAuthClientConfig {
+    clientId: string;
+    clientSecret?: string;
+}
+export interface McpServerRegistration {
+    name: string;
+    transport: McpServerTransportConfig;
+    disabled?: boolean;
+    /**
+     * Per-server request timeout in seconds, from the `timeout` field in
+     * cline_mcp_settings.json. Undefined means the shared default for ordinary
+     * requests; the stdio client uses its default connect budget for
+     * initialize until a finite timeout is explicitly configured. Registrations are
+     * resolved when the runtime is built, so changes take effect on the next
+     * session.
+     */
+    timeoutSeconds?: number;
+    metadata?: Record<string, unknown>;
+    oauthClient?: McpServerOAuthClientConfig;
+    oauth?: McpServerOAuthState;
+}
+export interface McpServerSnapshot {
+    name: string;
+    status: McpConnectionStatus;
+    disabled: boolean;
+    lastError?: string;
+    toolCount: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface McpServerClient {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    listTools(): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: {
+        name: string;
+        arguments?: Record<string, unknown>;
+        context?: AgentToolContext;
+    }): Promise<McpToolCallResult>;
+}
+export type McpServerClientFactory = (registration: McpServerRegistration) => Promise<McpServerClient> | McpServerClient;
+export interface McpServerOAuthStatus {
+    serverName: string;
+    oauthSupported: boolean;
+    oauthConfigured: boolean;
+    authorizationRequired: boolean;
+    lastError?: string;
+    lastAuthenticatedAt?: number;
+}
+export interface McpManagerOptions {
+    clientFactory: McpServerClientFactory;
+    /**
+     * Cache TTL for tools/list responses.
+     * A short cache avoids repeated list requests while keeping server metadata fresh.
+     * @default 5000
+     */
+    toolsCacheTtlMs?: number;
+}
+export interface McpManager extends McpToolProvider {
+    registerServer(registration: McpServerRegistration): Promise<void>;
+    unregisterServer(serverName: string): Promise<void>;
+    connectServer(serverName: string): Promise<void>;
+    disconnectServer(serverName: string): Promise<void>;
+    setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
+    listServers(): readonly McpServerSnapshot[];
+    refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
+    callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
+    dispose(): Promise<void>;
+}

package/dist/extensions/plugin/plugin-config-loader.d.ts

@@ -0,0 +1,44 @@
+import type { AgentConfig, PluginSetupContext, WorkspaceInfo } from "@cerebriline/shared";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
+import type { PluginTargeting } from "./plugin-targeting";
+export { getPluginDisplayName } from "@cerebriline/shared/storage";
+type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
+export declare function resolvePluginConfigSearchPaths(workspacePath?: string): string[];
+export declare function discoverPluginModulePaths(directoryPath: string): string[];
+export interface ResolveAgentPluginPathsOptions {
+    pluginPaths?: ReadonlyArray<string>;
+    workspacePath?: string;
+    cwd?: string;
+    includeDisabled?: boolean;
+}
+export declare function resolveAgentPluginPaths(options?: ResolveAgentPluginPathsOptions): string[];
+export declare function resolvePluginSkillDirectoriesFromPaths(pluginPaths: ReadonlyArray<string>): string[];
+export declare function resolveAgentPluginSkillDirectories(options?: ResolveAgentPluginPathsOptions): string[];
+export interface ResolveAndLoadAgentPluginsOptions extends ResolveAgentPluginPathsOptions, PluginTargeting {
+    mode?: "sandbox" | "in_process";
+    exportName?: string;
+    importTimeoutMs?: number;
+    hookTimeoutMs?: number;
+    contributionTimeoutMs?: number;
+    onEvent?: (event: {
+        name: string;
+        payload?: unknown;
+    }) => void;
+    /**
+     * Structured workspace and git metadata. Forwarded to sandboxed plugins
+     * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+     * in the extension context.
+     */
+    workspaceInfo?: WorkspaceInfo;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function resolveAndLoadAgentPlugins(options?: ResolveAndLoadAgentPluginsOptions): Promise<{
+    extensions: AgentPlugin[];
+    pluginPaths: string[];
+    shutdown?: () => Promise<void>;
+} & PluginLoadDiagnostics>;

package/dist/extensions/plugin/plugin-load-report.d.ts

@@ -0,0 +1,18 @@
+export interface PluginInitializationFailure {
+    pluginPath: string;
+    pluginName?: string;
+    phase: "load" | "setup";
+    message: string;
+    stack?: string;
+}
+export interface PluginInitializationWarning {
+    type: "duplicate_plugin_override";
+    pluginPath: string;
+    pluginName: string;
+    overriddenPluginPath: string;
+    message: string;
+}
+export interface PluginLoadDiagnostics {
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}

package/dist/extensions/plugin/plugin-loader.d.ts

@@ -0,0 +1,23 @@
+import type { AgentExtension, PluginSetupContext } from "@cerebriline/shared";
+import type { PluginInitializationFailure, PluginInitializationWarning } from "./plugin-load-report";
+import { type PluginTargeting } from "./plugin-targeting";
+export interface LoadAgentPluginFromPathOptions {
+    exportName?: string;
+    cwd?: string;
+    useCache?: boolean;
+    session?: PluginSetupContext["session"];
+    client?: PluginSetupContext["client"];
+    user?: PluginSetupContext["user"];
+    workspaceInfo?: PluginSetupContext["workspaceInfo"];
+    automation?: PluginSetupContext["automation"];
+    logger?: PluginSetupContext["logger"];
+    telemetry?: PluginSetupContext["telemetry"];
+}
+export declare function loadAgentPluginFromPath(pluginPath: string, options?: LoadAgentPluginFromPathOptions): Promise<AgentExtension>;
+export declare function loadAgentPluginsFromPaths(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<AgentExtension[]>;
+export declare function loadAgentPluginsFromPathsWithDiagnostics(pluginPaths: string[], options?: LoadAgentPluginFromPathOptions & PluginTargeting): Promise<{
+    plugins: AgentExtension[];
+    pluginPaths: string[];
+    failures: PluginInitializationFailure[];
+    warnings: PluginInitializationWarning[];
+}>;

package/dist/extensions/plugin/plugin-module-import.d.ts

@@ -0,0 +1,4 @@
+export interface ImportPluginModuleOptions {
+    useCache?: boolean;
+}
+export declare function importPluginModule(pluginPath: string, options?: ImportPluginModuleOptions): Promise<Record<string, unknown>>;