@lucascouts/claude-agent-tui 0.1.0

package/dist/acp-agent.d.ts

@@ -0,0 +1,594 @@
+import { Agent, AgentSideConnection, AuthenticateRequest, CancelNotification, ClientCapabilities, ForkSessionRequest, ForkSessionResponse, InitializeRequest, InitializeResponse, ListSessionsRequest, ListSessionsResponse, LoadSessionRequest, LoadSessionResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse, ReadTextFileRequest, ReadTextFileResponse, ResumeSessionRequest, ResumeSessionResponse, SessionConfigOption, SessionModelState, SessionModeState, SessionNotification, SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, SetSessionModelRequest, SetSessionModelResponse, SetSessionModeRequest, SetSessionModeResponse, CloseSessionRequest, CloseSessionResponse, DeleteSessionRequest, DeleteSessionResponse, TerminalHandle, TerminalOutputResponse, WriteTextFileRequest, WriteTextFileResponse } from "@agentclientprotocol/sdk";
+import { ModelInfo, Options, PermissionMode, PermissionUpdate, SDKMessageOrigin, SDKPartialAssistantMessage } from "@anthropic-ai/claude-agent-sdk";
+import { ContentBlockParam } from "@anthropic-ai/sdk/resources";
+import { BetaContentBlock, BetaRawContentBlockDelta } from "@anthropic-ai/sdk/resources/beta.mjs";
+import { SettingsManager } from "./settings.js";
+import { TaskState } from "./tools.js";
+import { type Engine } from "./engine.js";
+import type { IPty } from "node-pty";
+import { SessionEngine } from "./engine-lifecycle.js";
+import type { SessionWatcher } from "./engine-lifecycle.js";
+import type { JsonlWatcher, GetMessages, SessionMessage } from "./engine-watcher.js";
+import type { LocateOptions } from "./jsonl.js";
+import type { DiffEnrichedReaderOptions } from "./diff-enriched-reader.js";
+import type { ListSubagents, GetSubagentMessages } from "./subagent-source.js";
+import type { SubagentWatcher } from "./subagent-watcher.js";
+import type { DetectorSchedule, EndOfTurnDetector } from "./end-of-turn.js";
+import type { SessionGate, SessionGateOptions } from "./permissions/gate-wiring.js";
+export declare const CLAUDE_CONFIG_DIR: string;
+/**
+ * Logger interface for customizing logging output
+ */
+export interface Logger {
+    log: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+type AccumulatedUsage = {
+    inputTokens: number;
+    outputTokens: number;
+    cachedReadTokens: number;
+    cachedWriteTokens: number;
+};
+type Session = {
+    /** The live PTY handle (story 013/014) running the subscription `claude` TUI for this session. */
+    pty: IPty;
+    /**
+     * The per-session JSONL tail watcher (story 015); the single source of truth for state (§2).
+     * OPTIONAL (story 028, sub-task 2.1): a FRESH session returns BEFORE its transcript exists, so the
+     * watcher is armed later — out of band — once the transcript appears on the user's first
+     * interaction. It is `undefined` between create and that first appearance.
+     */
+    watcher?: JsonlWatcher | SessionWatcher;
+    /** Emit-once guard: uuids already surfaced to the client (Group 2 wires the pump that fills it). */
+    emitted: Set<string>;
+    /**
+     * Story 041 (R2.3) — emit-once guard for NESTED sub-agent (sidechain) rows, kept PARALLEL to and
+     * DECOUPLED from `emitted`. The nested pass dedups per sub-agent row uuid here so a late-arriving
+     * sidechain row still emits after its spawning turn's uuid is already in `emitted` (the parent turn
+     * was surfaced in an earlier pump). Per-session — sub-agent row uuids are session-scoped.
+     */
+    emittedNested: Set<string>;
+    /** The managed engine that owns the PTY + watcher; used for idempotent teardown (story 014). */
+    engine?: SessionEngine;
+    cancelled: boolean;
+    cwd: string;
+    /** Serialized snapshot of session-defining params (cwd, mcpServers) used to
+     *  detect when loadSession/resumeSession is called with changed values. */
+    sessionFingerprint: string;
+    settingsManager: SettingsManager;
+    accumulatedUsage: AccumulatedUsage;
+    modes: SessionModeState;
+    models: SessionModelState;
+    modelInfos: ModelInfo[];
+    configOptions: SessionConfigOption[];
+    /** Context window size of the last top-level assistant model, carried across
+     *  prompts so mid-stream usage_update notifications report a correct `size`
+     *  before the turn's first result message arrives. Defaults to
+     *  DEFAULT_CONTEXT_WINDOW, refreshed from each result's modelUsage, and
+     *  invalidated when the user switches the session's model. */
+    contextWindowSize: number;
+    /** Accumulated task list for the session, keyed by task ID. Task IDs are
+     *  per-session, so this state must not be shared across sessions. */
+    taskState: TaskState;
+    /** Per-session tool_use cache so the pump's tool_call→tool_call_update lifecycle stays correct
+     *  across LIVE re-reads (story 023 Groups 2-3). Per-session — tool_use ids are session-scoped. */
+    toolUseCache: ToolUseCache;
+    /** Set once the §10 billing guard-rail (story 022) has inspected the first batch (Group 4.1). */
+    guardChecked: boolean;
+    /** Story 025 (R3.3, R8) — latched true once the client rejects a usage_update; suppresses all
+     *  further usage_update emission for the session (the surrounding stream keeps flowing). */
+    usageDisabled: boolean;
+    /**
+     * Story 030 (R5.1) — the in-flight turn's end-of-turn detector for the current `session/prompt`.
+     * `prompt()` sets it (via {@link createTurnResolver}) for the duration of one turn so the live pump
+     * can feed raw JSONL messages to it and the cancel path can reach it; cleared in `prompt()`'s
+     * `finally`. The detector — never the writer — resolves the pending prompt (R5.1).
+     */
+    turnDetector?: EndOfTurnDetector;
+    /**
+     * Story 031 (R2.1, R2.2) — the in-flight turn's cancel handle from {@link createTurnResolver}.
+     * `prompt()` sets it for the turn's duration so the cancel path resolves the pending prompt as
+     * `cancelled` through the story-024 latch; cleared in `prompt()`'s catch + finally. Undefined when
+     * no turn is in flight (cancel is then a no-op).
+     */
+    turnCancel?: () => void;
+    /**
+     * Story 030 (R5.1) — per-session high-water cursor into the monotonic ordered superset
+     * {@link readOrderedMessages} returns, so each raw message is fed to {@link turnDetector} exactly
+     * once and a prior turn's terminal boundary is never re-observed.
+     */
+    detectorCursor?: number;
+    /**
+     * Story 034 (§9 / R3.3) — the per-session HYBRID permission-gate runtime: loopback `PreToolUse`
+     * hook server + scratch `--settings` backup + `tool_use.id` correlator. Present only when the
+     * gate is enabled AND the session spawned fresh (resume/replay paths carry no gate). The live
+     * pump REGISTERS every JSONL `tool_use` id into `gate.correlator`; `teardownSession` and the PTY
+     * `onExit` hook both call `gate.teardown()` (idempotent).
+     */
+    gate?: SessionGate;
+    /**
+     * Story 044 (R2.2/R2.3) — the per-session Option-B sub-agent watcher: polls the story-041 SDK
+     * sidechain readers while a `Task`/`Agent` spawn is OPEN on the main chain, feeding turn liveness
+     * + the incremental nested render. Armed by the pump ONLY while such a spawn is open AND the
+     * `liveSubagentWatch` flag is ON; stopped when every spawn id closes (R2.2), when the turn ends
+     * (prompt finally), and on session teardown (R2.3). Undefined whenever no watcher is armed.
+     */
+    subagentWatcher?: SubagentWatcher;
+    /**
+     * Story 044 (R3.1) — the latest main chain the pump read. The watcher's `onActivity` re-emits
+     * from it, so an incremental nested render needs NO main-chain re-read: the sidechain rows are
+     * sourced fresh inside `emitLinearizedWithNested`; the main chain is whatever the last pump saw.
+     */
+    lastMessages?: SessionMessage[];
+};
+/** What {@link StartEngine} returns: the authoritative session id (engine-spawn-generated for a
+ *  fresh session, the resumed id otherwise), the live PTY, the started watcher, the owning engine,
+ *  and the runtime cwd discovered from inside the JSONL (may be undefined until the first line). */
+export interface StartedEngine {
+    sessionId: string;
+    pty: IPty;
+    /**
+     * The started watcher. OPTIONAL (story 028, sub-task 2.1): the FRESH path now returns BEFORE the
+     * transcript exists, so it returns `watcher: undefined` and arms the watcher in the background
+     * once the transcript appears (it sets `engine.watcher` then). The RESUME path still returns the
+     * armed watcher synchronously.
+     */
+    watcher?: JsonlWatcher | SessionWatcher;
+    engine?: SessionEngine;
+    cwd?: string;
+}
+/** Arguments passed to {@link StartEngine}. `sessionId` is the requested id for resume/fork; for a
+ *  fresh session it is undefined and the engine's spawn generates the authoritative id. */
+export interface StartEngineArgs {
+    /** Requested session id (resume/fork). Undefined for a fresh session (engine generates it). */
+    sessionId?: string;
+    /** Host working directory the TUI spawns in. */
+    cwd: string;
+    /** True when reattaching to a prior session (story 014 robust resume argv). */
+    resume?: boolean;
+    /** Base environment to sanitize (defaults to process.env in the production wiring). */
+    baseEnv?: Record<string, string | undefined>;
+    /** The live session registry the engine registers into / deletes from on cleanup. */
+    sessions?: Map<string, SessionEngine>;
+    /**
+     * Group 2 pump trigger: invoked with the RESOLVED session id on every watcher signal so the
+     * tail-driven update pump re-reads the JSONL and emits. Absent in pure-spawn unit tests.
+     */
+    onEvent?: (sessionId: string) => void;
+    /**
+     * Story 027 (live-acceptance regression): Degrau-1 read-only loadSession path. When true, the
+     * engine LOCATES the existing transcript for replay but does NOT spawn a live `claude --resume`
+     * (no PTY, no tail watcher, no live engine). A live resume would (a) re-emit the whole history
+     * through the tail pump (double render in the Agent Panel) and (b) run with the fork process cwd
+     * (≠ the session cwd), writing a duplicate-basename transcript that makes the sessionId glob
+     * ambiguous → resourceNotFound on the next load. Default false: fresh/resume spawn is unchanged.
+     */
+    replayOnly?: boolean;
+    /**
+     * Story 028 (sub-task 2.1): injectable node-pty spawn. Forwarded to {@link createSessionEngine}
+     * (fresh) and {@link spawnResumePty} (resume) so a test can drive the REAL {@link
+     * defaultStartEngine} without launching a real `claude` TUI. Production passes nothing → the real
+     * `pty.spawn`.
+     */
+    spawn?: typeof import("node-pty").spawn;
+    /**
+     * Story 028 (sub-task 2.1): injectable transcript-discovery seams (glob/clock/etc.) forwarded to
+     * the internal {@link resolveWatchTarget} calls so a test injects ONLY the `glob` (and, in a Red
+     * probe, a finite `watchdogMs`) without re-masking the bug by stubbing discovery wholesale. On the
+     * FRESH path the internal `watchdogMs: Infinity` and `signal` are applied AROUND this (signal last,
+     * so the cancellation handle always wins). Production passes nothing → real glob + real clock.
+     */
+    locateOptions?: LocateOptions;
+    /**
+     * Story 034 (§9 hybrid gate): the per-session SCRATCH settings file (story-032 `injectHook`)
+     * carrying the fork's `PreToolUse` hook, appended to the FRESH spawn as `--settings "<file>"`.
+     * Already written BEFORE startEngine is called (blocker c ordering). Absent → ungated spawn.
+     * Fresh-path only — mirroring the story-029 `planMode` precedent, the resume argv
+     * (`buildResumeArgv`) is NOT extended here; the replay-only load path spawns nothing.
+     */
+    settingsFile?: string;
+}
+/** The createSession injection seam: spawn the PTY engine + JSONL watcher + locate the transcript. */
+export type StartEngine = (args: StartEngineArgs) => Promise<StartedEngine> | StartedEngine;
+/** Optional bundle of injectable dependencies for {@link ClaudeAcpAgent} (Degrau-1 PTY engine). */
+export interface AgentDeps {
+    /** Override the PTY-engine + JSONL-watcher start (production default: {@link defaultStartEngine}). */
+    startEngine?: StartEngine;
+    /** Override the live JSONL reader the pump re-reads on each signal (default: SDK getSessionMessages). */
+    getMessages?: GetMessages;
+    /**
+     * Story 041 — override the sidechain readers the pump sources nested sub-agent rows from
+     * (defaults: SDK `listSubagents` / `getSubagentMessages` via {@link defaultListSubagents} /
+     * {@link defaultGetSubagentMessages}). Injected by the deterministic unit tests as stubs/spies.
+     */
+    listSubagents?: ListSubagents;
+    getSubagentMessages?: GetSubagentMessages;
+    /**
+     * Story 025 / Task 3.1 (R3.1) — opt IN to the UNSTABLE `usage_update` notification. Defaults
+     * OFF: the pump constructs and emits no usage_update at all, so the session/update stream is
+     * byte-for-byte unaffected. Kept OFF in production until the live-Zed acceptance probe
+     * (Task 3.3, R8) confirms the user's Zed tolerates it.
+     */
+    usageUpdate?: boolean;
+    /**
+     * Story 043 (R2.1/R2.2/R5.1) — opt IN to the live Edit/Write diff. When ON, `this.getMessages` is
+     * wrapped in the diff-enriched reader (getSessionMessages + uuid→`toolUseResult` hydration), which
+     * restores the story-021 structuredPatch diff on BOTH the live pump and the session/load replay
+     * (both read `this.getMessages` once). Defaults OFF at THIS constructor seam (the story-038
+     * `usageUpdate` two-layer pattern) so directly-constructed test agents get the byte-for-byte pre-043
+     * reduced reader for determinism; the entrypoint (index.ts) is what defaults it ON (LIVE_DIFF, ON
+     * unless `LIVE_DIFF=0`/`false`). OFF → byte-for-byte the pre-043 reduced reader (R5.1).
+     */
+    liveDiff?: boolean;
+    /**
+     * Story 043 — test seam: the injectable {@link DiffEnrichedReaderOptions} forwarded to the
+     * diff-enriched reader when `liveDiff` is ON, so a unit test drives the reader's
+     * `findTranscript`/`readRawLines` deterministically WITHOUT touching the real `~/.claude` transcript
+     * tree (without it the pump-integration test would hit the real filesystem). Production passes
+     * nothing → the reader uses its billing-free `~/.claude` glob + `fs` read defaults.
+     */
+    diffEnrichOptions?: DiffEnrichedReaderOptions;
+    /**
+     * Story 044 (R4.1/R4.2) — opt IN to the live sub-agent watcher: the Option-B 2nd watcher that
+     * POLLs the SDK sidechain readers while a turn is in flight, feeding the story-024 detector's
+     * `noteActivity()` seam + the incremental nested render so a long-running sub-agent (rows in
+     * subagents/*.jsonl, MAIN transcript silent) no longer false-stalls the turn watchdog. Defaults
+     * OFF at THIS constructor seam (the story-038 `usageUpdate` two-layer pattern) so
+     * directly-constructed test agents arm no 2nd watcher for determinism; the entrypoint (index.ts)
+     * is what defaults it ON (FORK_LIVE_SUBAGENT_WATCH, ON unless "0"/"false"). OFF → byte-for-byte
+     * today's pull-only path: NO 2nd watcher armed (R4.2).
+     */
+    liveSubagentWatch?: boolean;
+    /**
+     * Story 030 (R1.2, R5.1) — the single timer seam shared by `sendPrompt` (the §8 write→\r delay)
+     * and `createTurnResolver` (the detector's Δt + watchdog). Injecting ONE schedule lets a unit test
+     * drive both with one fake clock. Defaults to a `setTimeout`/`clearTimeout` wrapper.
+     */
+    schedule?: DetectorSchedule;
+    /**
+     * Story 031 (R1.2) — the short LOCAL escalation window (ms) between cancel-ladder rungs:
+     * Ctrl+C → wait → Esc → wait → kill. DISTINCT from the 5583 ms turn watchdog (story 024), which
+     * is NOT re-derived here. Injected so a unit test drives the ladder with a fake clock; defaults to
+     * a conservative production value. Live in-Zed cancel tuning is out of scope (story 031).
+     */
+    cancelEscalationMs?: number;
+    /**
+     * Story 034 (§9 / R3.3) — enable the per-session HYBRID permission gate wiring: free loopback
+     * port + `PreToolUse` hook server + scratch `--settings` inject on every FRESH spawn, with the
+     * decider raising ACP `session/request_permission` correlated by `tool_use.id`. Resolved by the
+     * production bootstrap (index.ts) from `FORK_GATE` — ON unless `FORK_GATE=off` (the v1 policy is
+     * the hybrid gate, PERMISSIONS.md §1; the env var is the diagnostic escape hatch). Defaults OFF
+     * at THIS constructor seam (the story-038 `usageUpdate` two-layer pattern) so directly-constructed
+     * test agents spin no servers and write no files unless they opt in.
+     */
+    gate?: boolean;
+    /**
+     * Story 034 — gate timing/placement knobs forwarded to {@link setupSessionGate} (correlation
+     * wait, #52822 sweep windows, scratch dir, port allocator). `client`/`onWarn` are agent-owned and
+     * cannot be overridden. Tests inject short windows here; production passes nothing.
+     */
+    gateOptions?: Omit<SessionGateOptions, "client" | "onWarn">;
+}
+/**
+ * Production default for the {@link StartEngine} seam. Spawns the subscription `claude` TUI under a
+ * managed PTY engine (story 013/014), starts the read-only JSONL tail watcher (story 015) bound to
+ * that PTY, then locates the transcript by sessionId glob and reads the runtime cwd from INSIDE it
+ * (story 015 jsonl.ts; the cwd→dir encoding is irreversible, so we never decode the dir name).
+ *
+ * Fresh session: {@link createSessionEngine} spawns the PTY and generates the authoritative session
+ * id internally (story 013) — that id becomes the session key. Resume/fork: {@link spawnResumePty}
+ * reattaches to the requested id with the §5 robust-resume argv, wrapped in a {@link SessionEngine}.
+ *
+ * The watcher's `onEvent` is a no-op placeholder in Group 1 — the ACP pump that forwards new JSONL
+ * messages to the client is Group 2. NO SDK `query()` is reachable here.
+ */
+export declare function defaultStartEngine(args: StartEngineArgs): Promise<StartedEngine>;
+type BackgroundTerminal = {
+    handle: TerminalHandle;
+    status: "started";
+    lastOutput: TerminalOutputResponse | null;
+} | {
+    status: "aborted" | "exited" | "killed" | "timedOut";
+    pendingOutput: TerminalOutputResponse;
+};
+export type SDKMessageFilter = {
+    type: string;
+    subtype?: string;
+    origin?: SDKMessageOrigin["kind"];
+};
+/**
+ * Extra metadata that can be given when creating a new session.
+ */
+export type NewSessionMeta = {
+    claudeCode?: {
+        /**
+         * Options forwarded to Claude Code when starting a new session.
+         * Those parameters will be ignored and managed by ACP:
+         *   - cwd
+         *   - includePartialMessages
+         *   - allowDangerouslySkipPermissions
+         *   - permissionMode
+         *   - canUseTool
+         *   - executable
+         * Those parameters will be used and updated to work with ACP:
+         *   - hooks (merged with ACP's hooks)
+         *   - mcpServers (merged with ACP's mcpServers)
+         *   - disallowedTools (merged with ACP's disallowedTools)
+         *   - tools (passed through; defaults to claude_code preset if not provided)
+         */
+        options?: Options;
+        /**
+         * When set, raw SDK messages are emitted as extNotification("_claude/sdkMessage", message)
+         * in addition to normal processing.
+         * - true: emit all messages
+         * - false/undefined: emit nothing (default)
+         * - SDKMessageFilter[]: emit only messages matching at least one filter
+         */
+        emitRawSDKMessages?: boolean | SDKMessageFilter[];
+    };
+    additionalRoots?: string[];
+};
+/**
+ * Extra metadata for 'gateway' authentication requests.
+ */
+type GatewayAuthMeta = {
+    /**
+     * These parameters are mapped to environment variables to:
+     * - Redirect API calls via baseUrl
+     * - Inject custom headers
+     * - Bypass the default Claude login requirement
+     */
+    gateway: {
+        baseUrl: string;
+        headers: Record<string, string>;
+    };
+};
+type GatewayAuthRequest = AuthenticateRequest & {
+    _meta?: GatewayAuthMeta;
+};
+/**
+ * Extra metadata that the agent provides for each tool_call / tool_update update.
+ */
+export type ToolUpdateMeta = {
+    claudeCode?: {
+        toolName: string;
+        toolResponse?: unknown;
+    };
+    terminal_info?: {
+        terminal_id: string;
+    };
+    terminal_output?: {
+        terminal_id: string;
+        data: string;
+    };
+    terminal_exit?: {
+        terminal_id: string;
+        exit_code: number;
+        signal: string | null;
+    };
+};
+export type ToolUseCache = {
+    [key: string]: {
+        type: "tool_use" | "server_tool_use" | "mcp_tool_use";
+        id: string;
+        name: string;
+        input: unknown;
+    };
+};
+/**
+ * Return user-message content with local-command marker tags removed, or
+ * `null` if nothing meaningful remains (caller should skip the message).
+ * Preserves real prose that's mixed in alongside the markers — e.g. a
+ * message like `<command-name>…</command-name>hi` becomes `hi`.
+ */
+export declare function stripLocalCommandMetadata(content: unknown): unknown | null;
+export declare function isLocalCommandMetadata(content: unknown): boolean;
+export declare function resolvePermissionMode(defaultMode?: unknown, logger?: Logger): PermissionMode;
+/**
+ * Builds the label for the "Always Allow" permission option so the user can see
+ * the exact scope they are committing to. Uses the SDK-provided suggestions
+ * when available (e.g. `Bash(npm test:*)`) and falls back to naming the whole
+ * tool so "Always Allow" is never a blank check without disclosure.
+ */
+export declare function describeAlwaysAllow(suggestions: PermissionUpdate[] | undefined, toolName: string): string;
+export declare class ClaudeAcpAgent implements Agent {
+    sessions: {
+        [key: string]: Session;
+    };
+    client: AgentSideConnection;
+    toolUseCache: ToolUseCache;
+    backgroundTerminals: {
+        [key: string]: BackgroundTerminal;
+    };
+    clientCapabilities?: ClientCapabilities;
+    logger: Logger;
+    gatewayAuthRequest?: GatewayAuthRequest;
+    engine: Engine;
+    private readonly startEngine;
+    /** Override for the live JSONL reader the pump re-reads (default: SDK getSessionMessages). */
+    private readonly getMessages?;
+    /** Story 041 — the sidechain readers the pump sources nested sub-agent rows from; default to the
+     *  SDK's pure `listSubagents` / `getSubagentMessages` (tests inject stubs). */
+    private readonly listSubagents;
+    private readonly getSubagentMessages;
+    /** Story 025 (R3.1) — UNSTABLE usage_update feature flag; defaults OFF. */
+    private readonly usageUpdate;
+    /** Story 044 (R4.1/R4.2) — live sub-agent watcher flag; see {@link AgentDeps.liveSubagentWatch}. */
+    private readonly liveSubagentWatch;
+    /**
+     * Story 030 (R1.2, R5.1) — the single timer seam shared by `sendPrompt` (the §8 write→\r delay)
+     * and `createTurnResolver` (Δt + watchdog), so one injected fake clock drives both in unit tests.
+     */
+    private readonly schedule;
+    /** Story 031 (R1.2) — cancel-ladder escalation window (ms); see {@link AgentDeps.cancelEscalationMs}. */
+    private readonly cancelEscalationMs;
+    /** Story 034 (§9) — hybrid permission-gate wiring flag; see {@link AgentDeps.gate}. */
+    private readonly gateEnabled;
+    /** Story 034 — gate tuning knobs forwarded to setupSessionGate; see {@link AgentDeps.gateOptions}. */
+    private readonly gateOptions?;
+    /** Live PTY-engine registry shared with the per-session engines (story 014 cleanup map). */
+    private readonly engines;
+    constructor(client: AgentSideConnection, logger?: Logger, engine?: Engine, deps?: AgentDeps);
+    initialize(request: InitializeRequest): Promise<InitializeResponse>;
+    newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    unstable_forkSession(params: ForkSessionRequest): Promise<ForkSessionResponse>;
+    resumeSession(params: ResumeSessionRequest): Promise<ResumeSessionResponse>;
+    loadSession(params: LoadSessionRequest): Promise<LoadSessionResponse>;
+    listSessions(params: ListSessionsRequest): Promise<ListSessionsResponse>;
+    authenticate(_params: AuthenticateRequest): Promise<void>;
+    prompt(params: PromptRequest): Promise<PromptResponse>;
+    cancel(params: CancelNotification): Promise<void>;
+    /** Cleanly tear down a session: cancel in-flight work, dispose resources,
+     *  and remove it from the session map. */
+    private teardownSession;
+    /** Tear down all active sessions. Called when the ACP connection closes. */
+    dispose(): Promise<void>;
+    closeSession(params: CloseSessionRequest): Promise<CloseSessionResponse>;
+    unstable_deleteSession(params: DeleteSessionRequest): Promise<DeleteSessionResponse>;
+    unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse | void>;
+    setSessionMode(params: SetSessionModeRequest): Promise<SetSessionModeResponse>;
+    setSessionConfigOption(params: SetSessionConfigOptionRequest): Promise<SetSessionConfigOptionResponse>;
+    private applySessionMode;
+    private replaySessionHistory;
+    /**
+     * Shared per-turn ACP emission used by BOTH the `session/load` replay ({@link replaySessionHistory})
+     * and the live tail pump ({@link pumpUpdates}). Emits the message's `toAcpNotifications` updates with
+     * `registerHooks:false`; when the turn carries a `toolUseResult`, the story-021 structuredPatch diff
+     * (`{type:'diff'}`) attached to the open tool call; and finally the optional, default-OFF UNSTABLE
+     * `usage_update` (story 025) with its R8 per-session reject latch. Factoring all three here is what
+     * guarantees a LOADED thread renders byte-for-byte like a LIVE one (story 026 R3.3/R4.2): the
+     * validate-026 gap was the diff-emission block living only in pumpUpdates, so a replay-only load (no
+     * live pump) rendered Edit/Write WITHOUT a diff; story 038 moved usage_update HERE for the SAME
+     * reason (loaded==live for usage). Only dedup and the billing guard-rail stay with the callers.
+     */
+    private emitTurnUpdates;
+    /**
+     * Story 041 (R2.1, R2.2) — build the ACP `tool_call_update`(s) that render ONE nested sub-agent
+     * row UNDER its spawning Task tool_call. The nested row's `parent_tool_use_id` is the SPAWNING
+     * Task's `tool_use.id`; Zed merges `tool_call_update`s by `tool_call_id` and APPENDS their content
+     * (ZED-CLIENT-STUDY §Q2 ev.6: tool calls correlate by id with field-by-field merge, `ContentBlock::append`
+     * is pure concatenation), so emitting on the parent id nests the sub-agent's output under the Task.
+     *
+     * The block→content mapping is NOT re-implemented here: it REUSES the story-018/019/020 translator
+     * `toAcpNotifications` (text → agent_message_chunk, thinking → agent_thought_chunk, the sub-agent's
+     * own tool_use → tool_call, its tool_result → tool_call_update). We then RE-TARGET that translated
+     * output as `ToolCallContent` items on the PARENT id. Consequently the sub-agent's own tool_use /
+     * tool_result render as summarized markdown content WITHIN the parent Task tool_call (the tool's
+     * title/translated content), NOT as separate top-level `tool_call`s.
+     *
+     * Returns `[]` (no emission) when `parent_tool_use_id` is missing/null — there is no parent to nest
+     * under (a non-sidechain or malformed row). The caller does the dedup / arrival ordering (story 017's
+     * uuid-sorted `Turn.nested`); this is a pure builder.
+     */
+    private nestedUpdatesFor;
+    /**
+     * Story 041 (R2.2) — fold one translated nested update into `ToolCallContent[]` for nesting under
+     * the parent Task. Message/thought chunks contribute their ContentBlock directly. The sub-agent's
+     * OWN tool_use/tool_result (a `tool_call`/`tool_call_update` from the translator) are SUMMARIZED as
+     * markdown content within the parent — never re-emitted as a separate top-level tool_call: we take
+     * the tool's human-readable `title` (a bold markdown line) plus any `content` the story-019 translator
+     * already produced. `plan` and other non-content updates carry nothing renderable as nested content
+     * and are dropped.
+     */
+    private toNestedContent;
+    /**
+     * Tail-driven update pump (story 023 Groups 2-3). Fired on each watcher signal: re-reads the
+     * transcript LIVE via getSessionMessages (E5 REUSE-live, billing-free), linearizes via story 017,
+     * and emits each not-yet-emitted turn through the reused `toAcpNotifications` (Edit/Write diffs are
+     * sourced from `structuredPatch` by tools.ts — story 021). Ordering is the linear order story 017
+     * returns (no re-ordering); idempotency across overlapping/prefix re-reads comes from the
+     * per-session `emitted` uuid set (R3.3/R3.4). The JSONL tail is the single source of truth — there
+     * is NO SDK message stream. The end-of-turn predicate is story 024; this only consumes the signal.
+     */
+    private pumpUpdates;
+    /**
+     * Story 041 (R3.1, R3.2) — the SHARED source+merge+linearize+emit loop run by BOTH the live tail pump
+     * ({@link pumpUpdates}) and the `session/load` replay ({@link replaySessionHistory}), so a LOADED
+     * thread emits the nested sub-agent rows BYTE-IDENTICALLY to a LIVE one (no replay-only divergence —
+     * the validate-026 lesson: any emit path living only in the pump silently diverges on a replay-only
+     * load). Steps:
+     *
+     *   1. `sourceSubagentRows` — GUARDED (R5.2): returns `[]` WITHOUT touching disk when the main chain
+     *      carries no `Task`/`Agent` `tool_use`, so the common no-subagent turn pays nothing and
+     *      `forLinearize === messages` (identical-to-pre-change behavior).
+     *   2. Merge the sidechain rows onto the main chain ONLY for linearization — story 017 groups each
+     *      sub-agent row onto its spawning turn's uuid-sorted `Turn.nested`.
+     *   3. Per turn: emit the main content behind the UNCHANGED `emitted` gate (a not-yet-emitted
+     *      top-level turn renders through `emitTurnUpdates` — toAcpNotifications + structuredPatch diff +
+     *      the optional usage_update); then the DECOUPLED nested pass (per-row `emittedNested` dedup, R2.3)
+     *      emits each sub-agent row's `tool_call_update`s on the spawning Task's id (R3.1) — this runs EVEN
+     *      when the parent uuid is already in `emitted`, so a late-arriving sub-agent row still surfaces.
+     *
+     * The detector / §10 guard / §9 gate feed is NOT part of this helper — it is pump-only and stays on the
+     * un-merged main chain in the caller (sub-agent rows must never advance the detector cursor or register
+     * as gate tool_uses). The replay caller has no detector/gate feed, so it simply does not run one.
+     */
+    private emitLinearizedWithNested;
+    readTextFile(params: ReadTextFileRequest): Promise<ReadTextFileResponse>;
+    writeTextFile(params: WriteTextFileRequest): Promise<WriteTextFileResponse>;
+    private sendAvailableCommandsUpdate;
+    private updateConfigOption;
+    private applyConfigOptionValue;
+    private getOrCreateSession;
+    private createSession;
+}
+/**
+ * Inline-vs-reference threshold for an embedded `resource` block, in characters
+ * of `resource.text`.
+ *
+ * Content at or above this size is referenced by `@<path>` so the TUI re-reads
+ * the file from disk instead of receiving its bytes over the PTY (avoids
+ * flooding the terminal with a large paste). Content below it is inlined so a
+ * tiny snippet of context is not lost when there is no point round-tripping
+ * through the filesystem.
+ *
+ * This is the SINGLE source of truth: both the `@<path>` and the inline outcomes
+ * key off this one constant — no duplicated magic numbers.
+ */
+export declare const EMBEDDED_RESOURCE_INLINE_THRESHOLD = 2048;
+/**
+ * Convert an ACP ContentBlock[] (session/prompt) into a PTY text payload string.
+ *
+ * Reverse-flow (IMPLEMENTACAO-FORK-ACP.md §8): instead of constructing an
+ * SDKUserMessage for the core SDK, we assemble the text the TUI should receive
+ * over the PTY. Each block yields a fragment; empty fragments are dropped and the
+ * survivors are joined with a single space.
+ *
+ *   - text          → injected verbatim (with the legacy /mcp: slash-command
+ *                     normalization preserved, since the TUI understands it).
+ *   - resource_link → `@<path>` for file:// URIs (the TUI re-reads the file), or a
+ *                     `[name](uri)` markdown link for any non-path URI.
+ *   - resource (text) → large content (≥ EMBEDDED_RESOURCE_INLINE_THRESHOLD) with
+ *                     a file:// path becomes `@<path>` so the TUI re-reads it;
+ *                     anything below the threshold — or large but path-less — is
+ *                     inlined directly so the context is not lost.
+ *
+ * `resource` (blob) / `image` / `audio` blocks are SILENT no-ops here (R4.1): they
+ * emit no PTY bytes and are NOT logged — they are expected-but-unsupported media in
+ * v1, not errors. An UNKNOWN block `type` (the `default` branch) and any block whose
+ * mapping THROWS are treated as malformed: skipped, recorded via the `logger`, and the
+ * remaining valid blocks still map — one bad block never aborts the whole prompt (R1.3).
+ */
+export declare function promptToClaude(prompt: PromptRequest, logger?: Logger): string;
+/**
+ * Convert an SDKAssistantMessage (Claude) to a SessionNotification (ACP).
+ * Only handles text, image, and thinking chunks for now.
+ */
+export declare function toAcpNotifications(content: string | ContentBlockParam[] | BetaContentBlock[] | BetaRawContentBlockDelta[], role: "assistant" | "user", sessionId: string, toolUseCache: ToolUseCache, client: AgentSideConnection, logger: Logger, options?: {
+    registerHooks?: boolean;
+    clientCapabilities?: ClientCapabilities;
+    parentToolUseId?: string | null;
+    cwd?: string;
+    taskState?: TaskState;
+}): SessionNotification[];
+export declare function streamEventToAcpNotifications(message: SDKPartialAssistantMessage, sessionId: string, toolUseCache: ToolUseCache, client: AgentSideConnection, logger: Logger, options?: {
+    clientCapabilities?: ClientCapabilities;
+    cwd?: string;
+    taskState?: TaskState;
+}): SessionNotification[];
+export declare function runAcp(deps?: AgentDeps): {
+    connection: AgentSideConnection;
+    agent: ClaudeAcpAgent;
+};
+export {};
+//# sourceMappingURL=acp-agent.d.ts.map

package/dist/acp-agent.d.ts.map

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