@sayknow-cli/coding-agent 0.3.13 → 0.3.16

package/dist/types/memory-backend/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./local-backend";
+export * from "./off-backend";
+export * from "./resolve";
+export * from "./types";

package/dist/types/memory-backend/local-backend.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryBackend } from "./types";
+/**
+ * Wraps the existing `memories/` module as a `MemoryBackend`.
+ *
+ * The local pipeline owns rollout summarisation, SQLite retention, and
+ * `memory_summary.md`. Prompt reads use the live session cwd when available so
+ * manual enqueue/rebuild and startup hydration address the same memory root.
+ */
+export declare const localBackend: MemoryBackend;

package/dist/types/memory-backend/off-backend.d.ts

@@ -0,0 +1,7 @@
+import type { MemoryBackend } from "./types";
+/**
+ * No-op memory backend.
+ *
+ * Selected when `memory.backend` is `"off"`.
+ */
+export declare const offBackend: MemoryBackend;

package/dist/types/memory-backend/resolve.d.ts

@@ -0,0 +1,15 @@
+import type { Settings } from "../config/settings";
+import type { MemoryBackend } from "./types";
+/**
+ * Pick the active memory backend for a Settings instance.
+ *
+ * Selection rules (single source of truth — every memory consumer routes
+ * through this):
+ *   - `memory.backend === "hindsight"`  → Hindsight remote memory
+ *   - `memory.backend === "local"`      → local pipeline
+ *   - everything else                   → no-op
+ *
+ * `memories.enabled` remains accepted only as a legacy migration input. Once
+ * a config is loaded, `memory.backend` is the sole runtime selector.
+ */
+export declare function resolveMemoryBackend(settings: Settings): MemoryBackend;

package/dist/types/memory-backend/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Memory backend abstraction.
+ *
+ * Backends are mutually exclusive — `resolveMemoryBackend(settings)` returns
+ * exactly one. Implementations MUST be self-contained: they own the per-session
+ * state they create in `start()` and tear it down on `clear()`.
+ */
+import type { AgentMessage } from "@sayknow-cli/agent-core";
+import type { ModelRegistry } from "../config/model-registry";
+import type { Settings } from "../config/settings";
+import type { HindsightSessionState } from "../hindsight/state";
+import type { AgentSession } from "../session/agent-session";
+export type MemoryBackendId = "off" | "local" | "hindsight";
+export interface MemoryBackendStartOptions {
+    session: AgentSession;
+    settings: Settings;
+    modelRegistry: ModelRegistry;
+    agentDir: string;
+    taskDepth: number;
+    parentHindsightSessionState?: HindsightSessionState;
+}
+export interface MemoryBackend {
+    readonly id: MemoryBackendId;
+    /**
+     * Wire any background work or session subscriptions for this backend.
+     *
+     * Called once per agent session at startup. Implementations MUST be
+     * non-throwing: failures should be logged and swallowed so a misconfigured
+     * memory backend cannot break the agent loop.
+     */
+    start(options: MemoryBackendStartOptions): void | Promise<void>;
+    /**
+     * Markdown injected as the system-prompt append section.
+     * Returned on every prompt rebuild via `refreshBaseSystemPrompt()`.
+     */
+    buildDeveloperInstructions(agentDir: string, settings: Settings, session?: AgentSession): Promise<string | undefined>;
+    /** Wipe all persisted state for this backend (slash `/memory clear`). */
+    clear(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /** Force consolidation/retain to happen now (slash `/memory enqueue`). */
+    enqueue(agentDir: string, cwd: string, session?: AgentSession): Promise<void>;
+    /**
+     * Optional hook to inject a backend-specific block into the current turn's
+     * system prompt before the agent starts generating.
+     *
+     * This is the only place a backend can affect the very first answer of a
+     * fresh session. The returned text is appended to the already-built base
+     * system prompt for this turn only; callers may separately cache it and
+     * surface it through `buildDeveloperInstructions()` on later rebuilds.
+     */
+    beforeAgentStartPrompt?(session: AgentSession, promptText: string): Promise<string | undefined>;
+    /**
+     * Optional hook to splice extra context into a compaction summarization.
+     *
+     * Called from the compaction call site before the LLM summary is requested.
+     * Returning a string appends one entry to the compaction's `extraContext`
+     * list (which becomes part of the summarization prompt). Return `undefined`
+     * to inject nothing — the local backend takes this branch because its
+     * summary is already part of the system prompt.
+     */
+    preCompactionContext?(messages: AgentMessage[], settings: Settings, session?: AgentSession): Promise<string | undefined>;
+}

package/dist/types/migrate/action-planner.d.ts

@@ -0,0 +1,11 @@
+import type { AdapterResult, MigrateAction, MigrateDestinations, MigrateWarning } from "./types";
+export interface PlanInput {
+    results: AdapterResult[];
+    destinations: MigrateDestinations;
+    force: boolean;
+}
+export interface PlanOutput {
+    actions: MigrateAction[];
+    warnings: MigrateWarning[];
+}
+export declare function planMigration(input: PlanInput): Promise<PlanOutput>;

package/dist/types/migrate/adapters/claude-code.d.ts

@@ -0,0 +1,2 @@
+import { type Adapter } from "./index";
+export declare const claudeCodeAdapter: Adapter;

package/dist/types/migrate/adapters/codex.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Codex adapter: reads `~/.codex/config.toml` ([mcp_servers]) and `~/.codex/prompts`.
+ */
+import { type Adapter } from "./index";
+export declare const codexAdapter: Adapter;

package/dist/types/migrate/adapters/index.d.ts

@@ -0,0 +1,45 @@
+import type { AdapterResult, MigrateSource, SkillCandidate, SourceDiagnostic } from "../types";
+export interface AdapterOptions {
+    /** Home directory root; overridable for tests. */
+    homeDir: string;
+}
+export interface Adapter {
+    source: MigrateSource;
+    collect(options: AdapterOptions): Promise<AdapterResult>;
+}
+export declare function getAdapter(source: MigrateSource): Adapter;
+/** Read a text file, classifying absence/IO errors into source diagnostics. */
+export declare function readSourceText(filePath: string, source: MigrateSource, type: SourceDiagnostic["type"]): Promise<{
+    text: string;
+} | {
+    diagnostic: SourceDiagnostic;
+}>;
+/** Parse JSON text, classifying parse errors into a `failed_invalid_source` diagnostic. */
+export declare function parseSourceJson(text: string, filePath: string, source: MigrateSource, type: SourceDiagnostic["type"]): {
+    data: Record<string, unknown>;
+} | {
+    diagnostic: SourceDiagnostic;
+};
+/**
+ * Collect skill candidates from a directory of `<name>/SKILL.md` entries.
+ * A missing directory yields a `skipped_absent_source` diagnostic.
+ */
+export declare function collectSkillDir(dir: string, source: MigrateSource): Promise<{
+    candidates: SkillCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;
+/**
+ * Collect skill candidates from a flat directory of `*.md` prompt/command files.
+ */
+export declare function collectMarkdownPrompts(dir: string, source: MigrateSource): Promise<{
+    candidates: SkillCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;
+/**
+ * Recursively collect skill candidates from any `**​/SKILL.md` under `root`.
+ * The slug derives from the directory that directly contains the `SKILL.md`.
+ */
+export declare function collectSkillTree(root: string, source: MigrateSource): Promise<{
+    candidates: SkillCandidate[];
+    diagnostics: SourceDiagnostic[];
+}>;

package/dist/types/migrate/adapters/opencode.d.ts

@@ -0,0 +1,2 @@
+import { type Adapter } from "./index";
+export declare const opencodeAdapter: Adapter;

package/dist/types/migrate/executor.d.ts

@@ -0,0 +1,2 @@
+import type { MigrateAction } from "./types";
+export declare function executeActions(actions: MigrateAction[]): Promise<MigrateAction[]>;

package/dist/types/migrate/mcp-mapper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Map raw source MCP server entries onto SKC `MCPServerConfig`.
+ *
+ * Implements the source-schema compatibility matrix from the consensus plan:
+ * preserved (P), transformed (T), omitted-with-warning (OW), skipped (S,
+ * `skipped_unmappable`), and failed (F, `failed_invalid_source`). Secret-indirection
+ * fields are always omitted-with-warning; their values are never read or emitted.
+ */
+import type { MCPServerConfig } from "../runtime-mcp/types";
+import type { MigrateSource } from "./types";
+export type McpMapOutcome = {
+    ok: true;
+    config: MCPServerConfig;
+    warnings: string[];
+} | {
+    ok: false;
+    status: "skipped_unmappable" | "failed_invalid_source";
+    reason: string;
+};
+export declare function mapMcpEntry(source: MigrateSource, name: string, raw: unknown): McpMapOutcome;

package/dist/types/migrate/report.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Build the human-readable and `--json` reports for `skc migrate`.
+ *
+ * Secret values are never read upstream, so the report only ever contains field
+ * names in warnings — but rendering still treats action/warning text as opaque.
+ */
+import { type MigrateAction, type MigrateDestinations, type MigrateReport, type MigrateSource, type MigrateWarning } from "./types";
+export interface BuildReportInput {
+    actions: MigrateAction[];
+    warnings: MigrateWarning[];
+    sources: MigrateSource[];
+    destinations: MigrateDestinations;
+    dryRun: boolean;
+    project: boolean;
+    force: boolean;
+}
+export declare function buildReport(input: BuildReportInput): MigrateReport;
+export declare function renderHuman(report: MigrateReport): string;

package/dist/types/migrate/skill-normalizer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Normalize a skill from another agent into a native SKC `SKILL.md`.
+ *
+ * SKC derives a skill's loaded name from its directory (`<slug>/SKILL.md`) when no
+ * frontmatter `name` is present, and requires a `description`. To guarantee the
+ * effective loaded name equals the lowercase-hyphen slug, we drop any frontmatter
+ * `name` and place the file at `<slug>/SKILL.md`, synthesizing a `description`
+ * when the source lacks one.
+ */
+export interface NormalizeSkillInput {
+    /** Raw name from the source (filename stem, frontmatter name, etc.). */
+    rawName: string;
+    /** Full source markdown (may or may not have frontmatter). */
+    content: string;
+}
+export interface NormalizedSkill {
+    slug: string;
+    content: string;
+    warnings: string[];
+}
+/** Convert an arbitrary name into a lowercase-hyphen slug. */
+export declare function slugify(name: string): string;
+/**
+ * Produce a `{ slug, content }` pair whose effective SKC-loaded name equals `slug`.
+ * Throws only on an unusable name (cannot produce a slug).
+ */
+export declare function normalizeSkill(input: NormalizeSkillInput): NormalizedSkill;

package/dist/types/migrate/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Shared types for `skc migrate`.
+ *
+ * Imports MCP servers and skills from other coding agents (Claude Code, Codex,
+ * OpenCode) into native SKC config. See the consensus plan under
+ * `.skc/plans/ralplan/` for the full taxonomy and force/collision semantics.
+ */
+import type { MCPServerConfig } from "../runtime-mcp/types";
+/** Supported migration sources. */
+export type MigrateSource = "claude-code" | "codex" | "opencode";
+export declare const MIGRATE_SOURCES: readonly MigrateSource[];
+/** Canonical, deterministic ordering used when expanding `--from all` / repeated `--from`. */
+export declare const CANONICAL_SOURCE_ORDER: readonly MigrateSource[];
+/** What kind of thing an action/coverage row is about. */
+export type MigrateItemType = "mcp" | "skill" | "source";
+/**
+ * Per-item outcome taxonomy.
+ *
+ * `skipped_*` outcomes are non-fatal (exit 0). Any `failed_*` outcome sets
+ * `ok=false` and a non-zero process exit code.
+ */
+export type MigrationStatus = "imported" | "updated" | "skipped_exists" | "skipped_absent_source" | "skipped_unmappable" | "failed_invalid_source" | "failed_invalid_destination" | "failed_io";
+export declare const MIGRATION_STATUSES: readonly MigrationStatus[];
+/** Statuses that represent a hard failure (drive `ok=false` + non-zero exit). */
+export declare const FAILURE_STATUSES: ReadonlySet<MigrationStatus>;
+export declare function isFailureStatus(status: MigrationStatus): boolean;
+/** Operation the planner decided for an item. */
+export type MigrateOperation = "create" | "update" | "skip" | "fail";
+/** A raw MCP server candidate parsed from a source, before mapping/destination planning. */
+export interface McpCandidate {
+    source: MigrateSource;
+    name: string;
+    /** The raw, unmapped server entry from the source config (mapped by the planner). */
+    raw: unknown;
+}
+/** A raw skill candidate parsed from a source, before normalization/destination planning. */
+export interface SkillCandidate {
+    source: MigrateSource;
+    /** Slug used as the destination directory and effective loaded name. */
+    slug: string;
+    /** Full SKILL.md content (frontmatter already normalized so loaded name == slug). */
+    content: string;
+    warnings: string[];
+}
+/**
+ * Source-level diagnostic for a single source/type pair (e.g. "codex mcp config
+ * was malformed"). Distinct from per-item actions so absent/unreadable sources
+ * are reported once instead of per item.
+ */
+export interface SourceDiagnostic {
+    source: MigrateSource;
+    type: Exclude<MigrateItemType, "source"> | "source";
+    status: Extract<MigrationStatus, "skipped_absent_source" | "failed_invalid_source" | "failed_io">;
+    message: string;
+}
+/** Normalized candidates + diagnostics returned by an adapter. */
+export interface AdapterResult {
+    mcpCandidates: McpCandidate[];
+    skillCandidates: SkillCandidate[];
+    diagnostics: SourceDiagnostic[];
+}
+/** A single planned action consumed identically by dry-run and live execution. */
+export interface MigrateAction {
+    source: MigrateSource;
+    type: MigrateItemType;
+    name?: string;
+    /** For skills: the effective SKC-loaded name (== slug). */
+    effectiveName?: string;
+    /** Absolute destination path (mcp.json for MCP, <skillsDir>/<slug>/SKILL.md for skills). */
+    destination?: string;
+    operation: MigrateOperation;
+    status: MigrationStatus;
+    reason?: string;
+    warnings?: string[];
+    /** Resolved payload the executor needs; never serialized to the report. */
+    mcp?: {
+        config: MCPServerConfig;
+        force: boolean;
+    };
+    skill?: {
+        content: string;
+    };
+}
+export interface MigrateWarning {
+    source: MigrateSource;
+    type: string;
+    name?: string;
+    message: string;
+}
+export type StatusCounts = Record<MigrationStatus, number>;
+export interface MigrateDestinations {
+    mcpConfigPath: string;
+    skillsDir: string;
+}
+/** The full machine-readable report emitted with `--json`. */
+export interface MigrateReport {
+    ok: boolean;
+    dryRun: boolean;
+    project: boolean;
+    force: boolean;
+    sources: MigrateSource[];
+    destinations: MigrateDestinations;
+    summary: {
+        total: StatusCounts;
+        byType: {
+            mcp: StatusCounts;
+            skill: StatusCounts;
+            source: StatusCounts;
+        };
+        bySource: Record<MigrateSource, StatusCounts>;
+    };
+    actions: Array<{
+        source: MigrateSource;
+        type: MigrateItemType;
+        name?: string;
+        effectiveName?: string;
+        destination?: string;
+        operation: MigrateOperation;
+        status: MigrationStatus;
+        reason?: string;
+        warnings?: string[];
+    }>;
+    warnings: MigrateWarning[];
+}
+/** Create a zeroed status-count record. */
+export declare function emptyStatusCounts(): StatusCounts;

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

@@ -0,0 +1,78 @@
+import { type Agent, type AgentSideConnection, type AuthenticateRequest, type AuthenticateResponse, type ClientCapabilities, type CloseSessionRequest, type CloseSessionResponse, type DeleteSessionRequest, type DeleteSessionResponse, type ForkSessionRequest, type ForkSessionResponse, type InitializeRequest, type InitializeResponse, type ListSessionsRequest, type ListSessionsResponse, type LoadSessionRequest, type LoadSessionResponse, type NewSessionRequest, type NewSessionResponse, type PromptRequest, type PromptResponse, type ResumeSessionRequest, type ResumeSessionResponse, type SetSessionConfigOptionRequest, type SetSessionConfigOptionResponse, type SetSessionModeRequest, type SetSessionModeResponse } from "@agentclientprotocol/sdk";
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+/**
+ * Delay between `session/new` (or `session/load` / `session/resume` /
+ * `unstable_session/fork`) returning and the agent firing the first
+ * notifications against the new session id. Mitigates Zed's
+ * `Received session notification for unknown session` race — see
+ * `#scheduleBootstrapUpdates`. Exported so the ACP test harness can
+ * wait past this guard without hard-coding the literal.
+ */
+export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+type CreateAcpSession = (cwd: string) => Promise<AgentSession>;
+/**
+ * Build an {@link ExtensionUIContext} that translates skill/extension UI
+ * requests into ACP elicitations against `connection` for the session
+ * returned by `getSessionId()`. The id is read lazily at each elicitation
+ * because `AgentSession.sessionId` is a getter over `sessionManager` state
+ * that mutates when an extension command calls `ctx.newSession` /
+ * `ctx.switchSession` — snapshotting it once at factory time would route
+ * later elicitations to the pre-switch id. Live reads keep the bridge
+ * symmetric with every other `sessionUpdate` call in this file
+ * (`record.session.sessionId` is always evaluated at emit time).
+ *
+ * The non-elicitation surface (custom components, editor, theming,
+ * terminal input) remains stubbed — ACP clients render those themselves
+ * or not at all. Capability gating respects the client's `initialize`
+ * advertisement.
+ */
+export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, clientCapabilities: ClientCapabilities | undefined): ExtensionUIContext;
+export declare class AcpAgent implements Agent {
+    #private;
+    constructor(connection: AgentSideConnection, createSession: CreateAcpSession, initialSession?: AgentSession);
+    setCancelCleanupTimeoutForTesting(timeoutMs: number): void;
+    initialize(params: InitializeRequest): Promise<InitializeResponse>;
+    authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
+    /**
+     * Hard delete an ACP session. `DeleteSessionRequest` carries only `sessionId`;
+     * the server owns authorization through the immutable canonical cwd scope and
+     * the complete strict scoped inventory snapshot.
+     *
+     * - No scope / unknown / already-deleted id → lookup-free `{}`.
+     * - Duplicate/conflict id → visible error; neither transcript nor artifacts change.
+     * - Active session → reserve `deleting`, drain/cancel prompt, flush, strict
+     *   dispose/close, recheck identity/state, then verified artifact-first deletion.
+     * - Concurrent delete callers join the terminal promise.
+     */
+    deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: {
+        sessionId: string;
+    }): Promise<void>;
+    extMethod(method: string, params: {
+        [key: string]: unknown;
+    }): Promise<{
+        [key: string]: unknown;
+    }>;
+    extNotification(_method: string, _params: {
+        [key: string]: unknown;
+    }): Promise<void>;
+    get signal(): AbortSignal;
+    get closed(): Promise<void>;
+    /**
+     * Connection-local shutdown promise. Resolves once all terminal work (dispose,
+     * active deletes, abort cleanup) has settled. `acp-mode.ts` awaits this after
+     * transport closure so `process.exit` never kills in-flight deletion/disposal.
+     */
+    get shutdownPromise(): Promise<void>;
+}
+export {};

package/dist/types/modes/acp/acp-client-bridge.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ACP-side `ClientBridge` implementation. Wraps `AgentSideConnection` so the
+ * `read`/`write`/`bash`/`monitor`/`edit` tools (and the permission gate in
+ * `AgentSession`) can route through the client when it advertises the
+ * relevant capabilities at `initialize` time.
+ */
+import type { AgentSideConnection, ClientCapabilities } from "@agentclientprotocol/sdk";
+import type { ClientBridge } from "../../session/client-bridge";
+export declare function createAcpClientBridge(connection: AgentSideConnection, sessionId: string, clientCapabilities: ClientCapabilities | undefined): ClientBridge;

package/dist/types/modes/acp/acp-event-mapper.d.ts

@@ -0,0 +1,36 @@
+import type { SessionNotification, SessionUpdate, ToolKind } from "@agentclientprotocol/sdk";
+import type { AgentSessionEvent } from "../../session/agent-session";
+import type { AgentWireEventPayload } from "../shared/agent-wire/event-contract";
+interface MessageProgress {
+    textEmitted: boolean;
+    thoughtEmitted: boolean;
+}
+interface AcpEventMapperOptions {
+    getMessageId?: (message: unknown) => string | undefined;
+    getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+    getToolArgs?: (toolCallId: string) => unknown;
+    /**
+     * Session cwd. Tool call locations sent to ACP clients must be absolute
+     * (the editor host needs them to open or focus files). When provided,
+     * the mapper resolves raw `path`/`file`/etc. args against this cwd
+     * before emitting `ToolCallLocation` entries.
+     */
+    cwd?: string;
+    /** Phase to expose after compaction ends. Prompt-bound compaction resumes responding; idle maintenance returns idle. */
+    compactionEndPhase?: "responding" | "idle";
+}
+export declare function mapToolKind(toolName: string): ToolKind;
+export declare function mapAgentWireEventPayloadToAcpSessionUpdates(payload: AgentWireEventPayload, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
+export declare function mapAgentSessionEventToAcpSessionUpdates(event: AgentSessionEvent, sessionId: string, options?: AcpEventMapperOptions): SessionNotification[];
+export declare function buildToolCallStartUpdate(input: {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+    intent?: string;
+    cwd?: string;
+    status?: "pending" | "completed";
+}): SessionUpdate;
+export declare function normalizeReplayToolArguments(value: unknown): {
+    args: unknown;
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { AgentSideConnection, type Stream } from "@agentclientprotocol/sdk";
+import type { AgentSession } from "../../session/agent-session";
+import { AcpAgent } from "./acp-agent";
+export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
+export interface AcpConnectionHandle {
+    connection: AgentSideConnection;
+    agent: AcpAgent;
+}
+export declare function createAcpConnection(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AgentSideConnection;
+/**
+ * Create an ACP connection and return both the {@link AgentSideConnection} and the
+ * underlying {@link AcpAgent}. Callers that need to await agent shutdown (terminal
+ * delete/dispose work) after transport closure should use this instead of
+ * {@link createAcpConnection}.
+ */
+export declare function createAcpConnectionWithAgent(transport: Stream, createSession: AcpSessionFactory, initialSession?: AgentSession): AcpConnectionHandle;
+export declare function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never>;

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

@@ -0,0 +1,2 @@
+export * from "./acp-agent";
+export * from "./acp-mode";

package/dist/types/modes/acp/terminal-auth.d.ts

@@ -0,0 +1,6 @@
+export declare const ACP_TERMINAL_AUTH_FLAG = "--acp-terminal-auth";
+export interface AcpTerminalAuthArgs {
+    args: string[];
+    terminalAuth: boolean;
+}
+export declare function prepareAcpTerminalAuthArgs(rawArgs: readonly string[]): AcpTerminalAuthArgs;

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

@@ -0,0 +1,12 @@
+export interface BridgeAuthConfig {
+    token: string;
+}
+export interface BridgeBindConfig {
+    hostname: string;
+    port: number;
+    tlsConfigured: boolean;
+}
+export declare function extractBearerToken(authorization: string | null | undefined): string | undefined;
+export declare function isBridgeTokenAuthorized(authorization: string | null | undefined, config: BridgeAuthConfig): boolean;
+export declare function isLoopbackHost(hostname: string): boolean;
+export declare function assertSafeBridgeBind(config: BridgeBindConfig): void;

package/dist/types/modes/bridge/bridge-client-bridge.d.ts

@@ -0,0 +1,9 @@
+import type { ClientBridge, ClientBridgePermissionOption, ClientBridgePermissionOutcome, ClientBridgePermissionToolCall } from "../../session/client-bridge";
+import type { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+export interface BridgePermissionRequestPayload {
+    kind: "permission";
+    toolCall: ClientBridgePermissionToolCall;
+    options: ClientBridgePermissionOption[];
+}
+export type BridgePermissionBroker = UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+export declare function createBridgeClientBridge(broker: BridgePermissionBroker): ClientBridge;

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

@@ -0,0 +1,47 @@
+import type { ExtensionUIContext } from "../../extensibility/extensions";
+import type { AgentSession } from "../../session/agent-session";
+import type { ClientBridgePermissionOutcome } from "../../session/client-bridge";
+import type { RpcCommand, RpcResponse } from "../rpc/rpc-types";
+import { RpcHostToolBridge } from "../shared/agent-wire/host-tool-bridge";
+import { RpcHostUriBridge } from "../shared/agent-wire/host-uri-bridge";
+import { type BridgeCommandScope } from "../shared/agent-wire/scopes";
+import { UiRequestBroker } from "../shared/agent-wire/ui-request-broker";
+import type { BridgeUiResult } from "../shared/agent-wire/ui-result";
+import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
+import { type BridgePermissionRequestPayload } from "./bridge-client-bridge";
+import { type BridgeUiRequestPayload } from "./bridge-ui-context";
+import { BridgeEventStream } from "./event-stream";
+interface BridgeEndpointMatrix {
+    events: boolean;
+    commands: boolean;
+    control: boolean;
+    uiResponses: boolean;
+    hostToolResults: boolean;
+    hostUriResults: boolean;
+}
+interface BridgeFetchHandlerOptions {
+    sessionId: string;
+    token: string;
+    eventStream?: BridgeEventStream;
+    commandDispatcher?: (command: RpcCommand) => Promise<RpcResponse>;
+    commandScopes?: readonly BridgeCommandScope[];
+    idempotencyCache?: BridgeIdempotencyCache;
+    permissionBroker?: UiRequestBroker<BridgePermissionRequestPayload, ClientBridgePermissionOutcome>;
+    uiBroker?: UiRequestBroker<BridgeUiRequestPayload, BridgeUiResult<unknown>>;
+    hostToolBridge?: RpcHostToolBridge;
+    hostUriBridge?: RpcHostUriBridge;
+    endpointMatrix?: Partial<BridgeEndpointMatrix>;
+    unattendedControlPlane?: UnattendedSessionControlPlane;
+}
+interface BridgeIdempotencyRecord {
+    route: string;
+    ownerToken?: string;
+    body: string | Promise<string>;
+    response: unknown | Promise<unknown>;
+    pending?: boolean;
+}
+type BridgeIdempotencyCache = Map<string, BridgeIdempotencyRecord>;
+export declare function parseBridgeEndpoints(value: string | undefined): Partial<BridgeEndpointMatrix> | undefined;
+export declare function createBridgeFetchHandler(options: BridgeFetchHandlerOptions): (request: Request) => Promise<Response>;
+export declare function runBridgeMode(session: AgentSession, setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void): Promise<never>;
+export {};