@gajae-code/coding-agent 0.10.1 → 0.11.0

package/dist/types/harness-control-plane/operate.d.ts

@@ -1,16 +1,16 @@
 import { type FinalizeChecks, type FinalizeResult, type ValidationCommandSpec } from "./finalize";
 import { type PreserveResult } from "./preserve";
-import { type HarnessRpc } from "./rpc-adapter";
+import { type HarnessSessionTransport } from "./session-transport";
 import { type HarnessLifecycle, type Observation, type RecoveryClassification, type RetryBudget, type Severity } from "./types";
 export interface OperateOptions {
     root: string;
     sessionId: string;
     workspace: string;
     branch: string;
-    rpc: HarnessRpc;
-    /** Factory used to (re)create the RPC subprocess on restart recovery. Defaults to reusing `rpc`. */
-    rpcFactory?: () => HarnessRpc;
-    /** Bounded observation provider (scripted in tests; real = git + rpc state). */
+    transport: HarnessSessionTransport;
+    /** Factory used to recreate an SDK transport on restart recovery. Defaults to reusing `transport`. */
+    transportFactory?: () => HarnessSessionTransport;
+    /** Bounded observation provider (scripted in tests; real = git + SDK session state). */
     observe: () => Promise<Observation>;
     /** Real dirty-worktree preservation; injectable for tests. Defaults to git stash/diff capture. */
     preserve?: (workspace: string) => PreserveResult;

package/dist/types/harness-control-plane/owner.d.ts

@@ -3,20 +3,22 @@
  *
  * Responsibilities:
  *  - hold the {@link SessionLease} (single writer),
- *  - own the {@link HarnessRpc} subprocess (injected; real `GajaeCodeRpc` in prod, fake in tests),
+ *  - own an injected SDK session transport,
  *  - serve owner-routed primitives over the {@link ControlServer} endpoint,
  *  - be the SOLE writer of the severity event stream,
  *  - heartbeat the lease.
  *
  * Stateless `gjc harness` CLI calls reach the owner via {@link resolveOwner} + the endpoint.
  */
+import { ControlServer, type EndpointHandler } from "./control-endpoint";
 import { type FinalizeChecks, type ValidationCommandSpec } from "./finalize";
-import { type HarnessRpc } from "./rpc-adapter";
-import { type SessionLease } from "./session-lease";
+import { releaseLease, type SessionLease } from "./session-lease";
+import { type HarnessSessionTransport } from "./session-transport";
+import { appendEvent, writeSessionState } from "./storage";
 export interface OwnerOptions {
     root: string;
     sessionId: string;
-    rpc: HarnessRpc;
+    transport: HarnessSessionTransport;
     ownerId?: string;
     ttlMs?: number;
     heartbeatMs?: number;
@@ -24,6 +26,18 @@ export interface OwnerOptions {
     clock?: () => number;
     finalizeChecks?: FinalizeChecks;
     validationCommands?: ValidationCommandSpec[];
+    /** Test seam for deterministic control-endpoint teardown failures. */
+    controlServerFactory?: (socketPath: string, handler: EndpointHandler) => ControlServer;
+    /** Test seam for deterministic lease-release teardown failures. */
+    leaseRelease?: typeof releaseLease;
+    /** Test seams for frame persistence failures. */
+    framePersistence?: {
+        appendEvent?: typeof appendEvent;
+        writeSessionState?: typeof writeSessionState;
+    };
+    /** Test seams; production retries verified shutdown without a finite limit. */
+    cleanupRetryMs?: number;
+    cleanupRetryLimit?: number;
 }
 export interface OwnerStartInfo {
     ownerId: string;

package/dist/types/harness-control-plane/receipts.d.ts

@@ -57,7 +57,6 @@ export interface VanishEvidence {
 }
 export interface PromptAcceptanceEvidence {
     promptSha256: string;
-    rpcCommandId: string;
     preSubmitState: {
         isStreaming: boolean;
         steeringQueueDepth: number;

package/dist/types/harness-control-plane/sdk-transport.d.ts

@@ -0,0 +1,43 @@
+import { SdkClient } from "../sdk/client";
+import type { HarnessSessionTransport } from "./session-transport";
+export declare class HarnessSdkTransportError extends Error {
+    readonly code: "endpoint_unavailable" | "invalid_response";
+    readonly cause?: unknown;
+    constructor(code: "endpoint_unavailable" | "invalid_response", message: string, cause?: unknown);
+}
+export interface SpawnedHarnessSession {
+    stop(): Promise<void>;
+}
+export interface CreateSdkSessionTransportOptions {
+    repo: string;
+    sessionId: string;
+    /** Starts the normal GJC session before discovery. Test callers may provide a deterministic SDK host. */
+    spawn?: () => SpawnedHarnessSession | Promise<SpawnedHarnessSession>;
+    discoveryTimeoutMs?: number;
+    /** Test seam: inject SDK client/endpoint resolution to avoid a process-global module mock. */
+    connect?: typeof SdkClient.connect;
+    readEndpoint?: (repo: string, sessionId: string) => Promise<{
+        url: string;
+        token: string;
+    } | null>;
+}
+/**
+ * Connects an owner to the child session's public SDK endpoint. The SDK client owns
+ * hello-gated reconnects; this adapter only owns the bounded discovery wait and child
+ * lifecycle.
+ */
+export declare function createSdkSessionTransport(options: CreateSdkSessionTransportOptions): Promise<HarnessSessionTransport>;
+export interface ReapableHarnessChild {
+    kill(signal?: number | NodeJS.Signals): void;
+    readonly exited: Promise<number>;
+    readonly exitCode: number | null;
+}
+export declare function spawnNormalHarnessSession(repo: string, sessionId: string, options?: {
+    termGraceMs?: number;
+    killVerifyMs?: number;
+}): SpawnedHarnessSession;
+/** Test hook for exact-child stop serialization and retry semantics. */
+export declare function ownedHarnessSessionForTest(child: ReapableHarnessChild, options?: {
+    termGraceMs?: number;
+    killVerifyMs?: number;
+}): SpawnedHarnessSession;

package/dist/types/harness-control-plane/session-transport.d.ts

@@ -0,0 +1,48 @@
+export interface SessionStateSnapshot {
+    isStreaming: boolean;
+    steeringQueueDepth: number;
+    followupQueueDepth: number;
+}
+export interface HarnessSessionTransportCloseContext {
+    /**
+     * Immediate cycle-break acknowledgment for the exact direct close path.
+     *
+     * Invoke this method synchronously before an async close() reaches its first await
+     * (or before a non-async close() returns its promise); the returned promise may be
+     * awaited later. It does NOT signal that RuntimeOwner teardown has completed.
+     */
+    acknowledgeDirectOwnerStopReentry(): Promise<void>;
+}
+/** SDK-backed transport contract for a live harness session. */
+export interface HarnessSessionTransport {
+    getState(): Promise<SessionStateSnapshot>;
+    sendPrompt(prompt: string): Promise<{
+        commandId: string;
+        ack: boolean;
+    }>;
+    eventCursor(): number;
+    waitForAgentStart(afterCursor: number, timeoutMs: number): Promise<{
+        cursor: number;
+    } | null>;
+    /**
+     * Await every transport-owned cleanup step. close() MUST NOT call public
+     * RuntimeOwner.stop(), which would circularly await this close and hang. A transport
+     * that needs that direct cycle break must synchronously invoke
+     * `context.acknowledgeDirectOwnerStopReentry()` before its first await.
+     */
+    close(context?: HarnessSessionTransportCloseContext): Promise<void>;
+    /** Return a synchronous disposer that fully severs this event subscription. */
+    onEventFrame?(listener: (frame: Record<string, unknown>) => void): () => void;
+    isLive?(): boolean;
+    lastFrameAt?(): string | null;
+    getLastAssistantText?(): Promise<string | null>;
+}
+export interface AcceptanceResult {
+    accepted: boolean;
+    reason: string;
+    commandId: string | null;
+    preSubmitCursor: number;
+    agentStartCursor: number | null;
+    preSubmitState: SessionStateSnapshot;
+}
+export declare function singleFlightAccept(transport: HarnessSessionTransport, prompt: string, timeoutMs: number): Promise<AcceptanceResult>;

package/dist/types/harness-control-plane/types.d.ts

@@ -81,10 +81,9 @@ export interface SessionHandle {
         ownerId: string | null;
         pid: number | null;
     };
-    rpcHandle: {
-        kind: "rpc-subprocess";
-        pid: number | null;
-        sessionDir: string;
+    sdkHandle: {
+        kind: "sdk-session-endpoint";
+        sessionId: string;
     };
     ownerHandle: {
         leasePath: string;

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

@@ -9,7 +9,7 @@ export type { LspServerStatus } from "./client";
 export type { LspToolDetails } from "./types";
 export interface LspStartupServerInfo {
     name: string;
-    status: "connecting" | "ready" | "error";
+    status: "idle" | "connecting" | "ready" | "error";
     fileTypes: string[];
     error?: string;
 }

package/dist/types/main.d.ts

@@ -9,20 +9,20 @@ import type { Args } from "./cli/args";
 import { ModelRegistry } from "./config/model-registry";
 import { Settings } from "./config/settings";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
+import type { AcpStartupOptions } from "./modes/acp/startup-options";
 import type { SessionSelectionResult } from "./modes/components/session-selector";
 import type { InteractiveMode } from "./modes/interactive-mode";
 import type { PrintModeOptions } from "./modes/print-mode";
 import { initTheme } from "./modes/theme/theme";
 import type { SubmittedUserInput } from "./modes/types";
 import type { MCPManager } from "./runtime-mcp";
-import { type CreateAgentSessionOptions, type CreateAgentSessionResult, createAgentSession, discoverAuthStorage } from "./sdk";
+import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
-import type { AuthStorage } from "./session/auth-storage";
 import { type ResumeSessionIdentity, type SessionInfo, SessionManager, type StrictSessionOpenResult } from "./session/session-manager";
 import { runStartupCredentialAutoImportIfNeeded } from "./setup/credential-auto-import";
 import type { LspStartupServerInfo } from "./tools";
 import type { EventBus } from "./utils/event-bus";
-export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "rpc" | "rpc-ui" | "acp" | "bridge";
+export type StartupUpdateRoute = "interactive" | "print" | "text" | "json" | "acp";
 export declare function classifyStartupUpdateRoute(parsed: Pick<Args, "print" | "mode">, autoPrint: boolean): StartupUpdateRoute;
 /** Coordinates the non-blocking update check around the interactive UI lifecycle. */
 export declare class StartupUpdateOrchestrator {
@@ -36,46 +36,44 @@ export interface StartupUpdateInteractiveMode {
     showNewVersionNotification: (version: string) => void;
 }
 export declare function initializeInteractiveModeWithStartupUpdate(mode: StartupUpdateInteractiveMode, startupUpdate: StartupUpdateOrchestrator): Promise<void>;
+/**
+ * Translate only ACP startup settings with a canonical SDK control carrier.
+ * Every other local-session flag is rejected so the broker-backed ACP host
+ * never appears to accept options it cannot apply to its remote session.
+ */
+export declare function resolveAcpStartupOptions(parsed: Pick<Args, "allowHome" | "apiKey" | "appendSystemPrompt" | "credential" | "continue" | "default" | "cwd" | "fileArgs" | "fork" | "hooks" | "messages" | "mpreset" | "mcpConfig" | "model" | "models" | "noLsp" | "noPty" | "noRules" | "noSession" | "noSkills" | "noTitle" | "noTools" | "pluginDirs" | "print" | "provider" | "providerSessionId" | "resume" | "sessionDir" | "skills" | "slow" | "smol" | "plan" | "systemPrompt" | "thinking" | "tmux" | "tools" | "extensions" | "unknownFlags">, sessionOptions: Pick<CreateAgentSessionOptions, "model" | "modelPattern" | "thinkingLevel">): AcpStartupOptions;
 declare function readPipedInput(): Promise<string | undefined>;
 export interface InteractiveModeNotify {
     kind: "warn" | "error" | "info";
     message: string;
 }
 export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
-type CreateSessionForMain = (options: CreateAgentSessionOptions, context?: {
-    skipPostCreateModelRefresh?: boolean;
-}) => Promise<CreateAgentSessionResult>;
-type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
-export interface AcpSessionFactoryOptions {
-    baseOptions: CreateAgentSessionOptions;
-    settings: Settings;
-    sessionDir?: string;
-    authStorage: AuthStorage;
-    modelRegistry: ModelRegistry;
-    parsedArgs: Pick<Args, "apiKey" | "default" | "model" | "mpreset" | "thinking">;
-    rawArgs: string[];
-    createSession: CreateSessionForMain;
-}
-export declare function applyStartupModelProfiles(args: {
+type StartupModelProfileArgs = {
     session: AgentSession;
     settings: Settings;
     modelRegistry: ModelRegistry;
     parsedArgs: Pick<Args, "default" | "model" | "mpreset" | "thinking">;
     startupModel?: CreateAgentSessionOptions["model"];
     startupThinkingLevel?: CreateAgentSessionOptions["thinkingLevel"];
-}): Promise<void>;
-export declare function applyStartupModelProfilesOrExit(args: Parameters<typeof applyStartupModelProfiles>[0]): Promise<void>;
-/**
- * Build the per-`session/new` factory used by ACP mode.
- *
- * MCP servers in ACP sessions are owned exclusively by the ACP client, which
- * supplies them through `session/new.mcpServers` and re-applies them via
- * {@link AcpAgent#configureMcpServers}. We therefore force `enableMCP: false`
- * on every session created here so {@link createAgentSession} skips the on-disk
- * `.mcp.json` discovery path — otherwise host MCP tools land in the session's
- * tool registry and shadow the client-supplied servers (issue #1234).
- */
-export declare function createAcpSessionFactory(args: AcpSessionFactoryOptions): AcpSessionFactory;
+};
+export declare function applyStartupModelProfiles(args: StartupModelProfileArgs): Promise<void>;
+export declare function applyStartupModelProfilesOrExit(args: StartupModelProfileArgs): Promise<void>;
+export declare function isStartupModelProfileCredentialRecoveryEligible(options: {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): boolean;
+export declare function applyStartupModelProfilesForRoot(args: StartupModelProfileArgs & {
+    isInteractive: boolean;
+    hasInteractiveTerminal: boolean;
+    initialMessage: string | undefined;
+    initialMessages: readonly string[];
+    resumeAction: "continue-tail" | "open-idle" | undefined;
+}): Promise<{
+    recoverableErrors: string[];
+}>;
 interface InteractiveModeFactoryOptions {
     session: AgentSession;
     version: string;
@@ -105,15 +103,13 @@ export interface RlmPreset {
     applyOptions: (options: CreateAgentSessionOptions, settings: Settings) => void;
     onSessionCreated?: (session: AgentSession) => void | Promise<void>;
 }
-type RunRpcMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"], options?: {
-    listen?: string;
-}) => Promise<void>;
-type RunBridgeMode = (session: AgentSession, setToolUIContext?: CreateAgentSessionResult["setToolUIContext"]) => Promise<void>;
 type RunPrintMode = (session: AgentSession, options: PrintModeOptions) => Promise<void>;
 export interface RunRootCommandDependencies {
     createAgentSession?: typeof createAgentSession;
     discoverAuthStorage?: typeof discoverAuthStorage;
-    runAcpMode?: (createSession: AcpSessionFactory) => Promise<void>;
+    runAcpMode?: (options?: {
+        agentDir?: string;
+    }) => Promise<void>;
     settings?: Settings;
     rlmPreset?: RlmPreset;
     suppressProcessExit?: boolean;
@@ -124,8 +120,6 @@ export interface RunRootCommandDependencies {
     readPipedInput?: typeof readPipedInput;
     runStartupCredentialAutoImportIfNeeded?: typeof runStartupCredentialAutoImportIfNeeded;
     getChangelogForDisplay?: typeof getChangelogForDisplay;
-    runRpcMode?: RunRpcMode;
-    runBridgeMode?: RunBridgeMode;
     createInteractiveMode?: CreateInteractiveMode;
     runPrintMode?: RunPrintMode;
     isResumePickerTerminal?: ResumePickerTerminalCheck;

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

@@ -1,56 +1,239 @@
 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";
+import { type AcpProviderRegistration, AcpSdkAdapter } from "../../sdk/acp";
+import type { AcpStartupOptions } from "./startup-options";
+export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
+type JsonObject = Record<string, unknown>;
+/** Applies ACP's offset cursor after narrowing the broker listing to the requested cwd. */
+export declare function paginateAcpSessions(listed: unknown[], cwd: string | undefined, offset: number): ListSessionsResponse;
+export type TranscriptReplayBlock = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+};
 /**
- * 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.
+ * The production transcript query exposes durable `{ body, textSummary }`
+ * entries, not an ACP-shaped `content` array. Historical session JSONL has no
+ * recoverable image bytes, so replay exposes that boundary rather than
+ * pretending images were restored.
  */
-export declare const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
-type CreateAcpSession = (cwd: string) => Promise<AgentSession>;
+export interface TranscriptReplayContent {
+    blocks: TranscriptReplayBlock[];
+    images: {
+        available: false;
+        reason: "historical_transcript_images_unavailable";
+    };
+}
+export declare function transcriptReplayContent(entry: unknown): TranscriptReplayContent;
+/** Maps live canonical SDK config and model queries into the ACP 1.2.1 session state surface. */
+export declare function acpSessionStateFromConfig(query: unknown, modelsQuery?: unknown): {
+    configOptions: ({
+        id: string;
+        name: string;
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[];
+    } | {
+        id: "model";
+        name: "Model";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "thinking";
+        name: "Thinking";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "steeringMode";
+        name: "Steering queue";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "followUpMode";
+        name: "Follow-up queue";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    } | {
+        id: "interruptMode";
+        name: "Interrupt mode";
+        type: "select";
+        currentValue: string;
+        options: {
+            value: string;
+            name: string;
+        }[] | ({
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "all";
+            readonly name: "All";
+        } | {
+            readonly value: "one-at-a-time";
+            readonly name: "One at a time";
+        } | {
+            readonly value: "immediate";
+            readonly name: "Immediate";
+        } | {
+            readonly value: "wait";
+            readonly name: "Wait";
+        })[];
+    })[];
+    modes: {
+        availableModes: {
+            id: string;
+            name: string;
+        }[];
+        currentModeId: string;
+    };
+};
+/** Convert every ACP prompt block the agent advertises without silently discarding context. */
+export declare function acpPromptPayload(blocks: PromptRequest["prompt"]): {
+    text: string;
+    images: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+};
+/** Registers a permission provider only when the ACP client requires prompts. */
+export declare function acpProviderRegistrations(capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): AcpProviderRegistration[];
+/** Maps ACP permission handling to the session's canonical SDK policy. */
+export declare function applyAcpPermissionMode(adapter: Pick<AcpSdkAdapter, "control">, capabilities: ClientCapabilities | undefined, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Applies CLI-provided ACP startup settings through SDK controls before session exposure. */
+export declare function applyAcpStartupOptions(adapter: Pick<AcpSdkAdapter, "setModel" | "control">, options: AcpStartupOptions | undefined): Promise<void>;
+/** ACP form elicitation uses the client-facing reverse surface without owning a session runtime. */
+export declare function createAcpExtensionUiContext(connection: AgentSideConnection, getSessionId: () => string, capabilities: ClientCapabilities | undefined): {
+    select: (message: string, options: string[], dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+    confirm: (message: string, detail?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<boolean>;
+    input: (message: string, placeholder?: string, dialog?: {
+        signal?: AbortSignal;
+        timeout?: number;
+        onTimeout?: () => void;
+    }) => Promise<string | undefined>;
+};
 /**
- * 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.
+ * ACP is a pure SDK client. Session processes are created and resumed by the
+ * broker, while all per-session operations use that session's authenticated SDK
+ * endpoint. This class deliberately imports neither AgentSession nor any local
+ * runtime host component.
  */
-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;
+    constructor(connection: AgentSideConnection, options?: {
+        agentDir?: string;
+        startupOptions?: AcpStartupOptions;
+    } | unknown);
     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>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
     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>;
@@ -58,21 +241,9 @@ export declare class AcpAgent implements Agent {
     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>;
+    extMethod(method: string, params: JsonObject): Promise<JsonObject>;
+    extNotification(_method: string, _params: JsonObject): 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

@@ -6,4 +6,5 @@
  */
 import type { AgentSideConnection, ClientCapabilities } from "@agentclientprotocol/sdk";
 import type { ClientBridge } from "../../session/client-bridge";
+export { type AcpPermissionMode, resolveAcpPermissionMode } from "./permission-mode";
 export declare function createAcpClientBridge(connection: AgentSideConnection, sessionId: string, clientCapabilities: ClientCapabilities | undefined): ClientBridge;

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

@@ -1,17 +1,8 @@
 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;
+import type { AcpStartupOptions } from "./startup-options";
+export interface AcpModeOptions {
+    agentDir?: string;
+    startupOptions?: AcpStartupOptions;
 }
-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>;
+export declare function createAcpConnection(transport: Stream, options?: AcpModeOptions): AgentSideConnection;
+export declare function runAcpMode(options?: AcpModeOptions): Promise<never>;