autodev-cli 1.4.189 → 1.4.191

package/out/providers/acp/AcpSession.js

@@ -0,0 +1,683 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// AcpSession — a PROVIDER-AGNOSTIC persistent Agent Client Protocol process.
+//
+// This is the generalization of the grok-only GrokAcpSession (shipped 1.4.188)
+// into a single client that can drive ANY agent that speaks ACP over stdio —
+// grok (`grok agent … stdio`), opencode (`opencode acp`), and later copilot
+// (`copilot --acp`) / claude (via a third-party adapter). One long-lived process
+// per workspace root, fed turn-by-turn, kept alive between turns:
+//
+//   spawn once → `initialize` → `session/new` (or `session/load` to RESTORE a
+//   prior session's context at (re)start) → per turn `session/prompt`, awaiting
+//   the turn's completion, KEEPING THE PROCESS ALIVE between turns.
+//
+// Wire protocol (identical across grok + opencode; captured live against
+// grok 1.0.13 and opencode 1.14.22):
+//   - Framing: line-delimited JSON-RPC 2.0 (NOT LSP Content-Length).
+//   - initialize  {protocolVersion:1, clientCapabilities:{}} ->
+//                 {protocolVersion, agentCapabilities:{loadSession, sessionCapabilities:{resume,…}}}
+//   - session/new {cwd, mcpServers:[]}  -> {sessionId, …}
+//     (the agent STILL loads its OWN config MCP servers even with mcpServers:[],
+//      so office/operate MCP keeps working — verified for grok AND opencode.)
+//   - session/load {sessionId, cwd, mcpServers:[]} -> replays the conversation as
+//     session/update notifications, then resolves — restores in-process context.
+//   - session/prompt {sessionId, prompt:[{type:'text',text}]} ->
+//                 {stopReason:'end_turn'|'cancelled'|…}  (resolves at turn end).
+//   - session/update NOTIFICATIONS stream during a turn (agent_message_chunk,
+//     agent_thought_chunk, tool_call, tool_call_update, …).
+//   - session/cancel {sessionId} (notification) cancels the running turn; the
+//     process STAYS ALIVE. A second session/prompt mid-turn is QUEUED (FIFO) by
+//     the agent and run after the current turn — this is how a mid-run STEER
+//     reaches the live process without exiting it.
+//
+// With EMPTY client capabilities the agent performs its OWN fs/terminal I/O
+// (verified for grok + opencode) — so the client stays tiny. We still answer any
+// agent→client request defensively (auto-allow permission) so nothing wedges.
+//
+// The ONLY provider-specific bits are captured in `AcpLaunchSpec`:
+//   - buildArgs(model, extra): the argv after the binary
+//     (grok: `agent --always-approve [-m M] --no-leader … stdio`;
+//      opencode: `[-m M] acp`)
+//   - decodeUpdate: how this provider's session/update maps to AcpUpdate
+//     (grok reads the real tool name from `_meta['x.ai/tool']`; opencode uses the
+//      standard ACP `title`) — defaults to the standard-ACP decoder below.
+//   - narrationTitle: the label attached to narration hooks ('grok' / 'opencode').
+//   - narrateReasoning: whether agent_thought_chunk is forwarded as narration
+//     (default false — keeps reasoning out of the office chat).
+// ---------------------------------------------------------------------------
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcpSession = void 0;
+exports.decodeAcpUpdateStandard = decodeAcpUpdateStandard;
+exports.extractToolOutput = extractToolOutput;
+exports.classifyAcpResult = classifyAcpResult;
+const child_process = __importStar(require("child_process"));
+/**
+ * STANDARD-ACP decoder (opencode, and the generic default). Handles the ACP-spec
+ * session/update shapes:
+ *   agent_message_chunk {content:{type:'text',text}}       -> assistant
+ *   agent_thought_chunk {content:{type:'text',text}}       -> reasoning
+ *   tool_call           {toolCallId,title,rawInput}        -> tool_call (name=title)
+ *   tool_call_update    {toolCallId,status,content|rawOutput} -> tool_result
+ * Anything else (available_commands_update, usage_update, plan, …) -> other. PURE.
+ */
+function decodeAcpUpdateStandard(msg) {
+    const m = msg;
+    if (!m || m.method !== 'session/update' || !m.params || !m.params.update) {
+        return { kind: 'other' };
+    }
+    const u = m.params.update;
+    const su = u['sessionUpdate'];
+    if (su === 'agent_message_chunk') {
+        const content = u['content'];
+        if (content && content.type === 'text' && typeof content.text === 'string') {
+            return { kind: 'assistant', text: content.text };
+        }
+        return { kind: 'other' };
+    }
+    if (su === 'agent_thought_chunk') {
+        const content = u['content'];
+        if (content && content.type === 'text' && typeof content.text === 'string') {
+            return { kind: 'reasoning', text: content.text };
+        }
+        return { kind: 'other' };
+    }
+    if (su === 'tool_call') {
+        const id = String(u['toolCallId'] ?? '');
+        // Standard ACP puts a human title on the tool call; some agents also carry a
+        // machine tool id under _meta — prefer an explicit name, fall back to title.
+        const meta = u['_meta'];
+        const metaName = _metaToolName(meta);
+        const name = String(metaName || u['title'] || u['kind'] || '').trim();
+        return { kind: 'tool_call', id, name, input: u['rawInput'] };
+    }
+    if (su === 'tool_call_update') {
+        const status = String(u['status'] ?? '');
+        // Only TERMINAL statuses close a tool call; in_progress/pending are interim.
+        if (status !== 'completed' && status !== 'failed' && status !== 'cancelled') {
+            return { kind: 'other' };
+        }
+        const id = String(u['toolCallId'] ?? '');
+        return { kind: 'tool_result', id, status, outputText: extractToolOutput(u) };
+    }
+    return { kind: 'other' };
+}
+/** Pull a machine tool name out of a provider `_meta` blob if present. PURE. */
+function _metaToolName(meta) {
+    if (!meta || typeof meta !== 'object') {
+        return '';
+    }
+    // grok: _meta['x.ai/tool'].name ; opencode: _meta['opencode']?.tool (defensive)
+    const xai = meta['x.ai/tool'];
+    if (xai?.name) {
+        return String(xai.name);
+    }
+    const oc = meta['opencode'];
+    if (oc?.tool || oc?.toolID) {
+        return String(oc.tool || oc.toolID);
+    }
+    return '';
+}
+/** Best-effort flatten of a tool_call_update's output into a short string. PURE. */
+function extractToolOutput(u) {
+    const raw = u['rawOutput'];
+    if (typeof raw === 'string') {
+        return raw;
+    }
+    if (raw && typeof raw === 'object') {
+        try {
+            return JSON.stringify(raw);
+        }
+        catch { /* ignore */ }
+    }
+    const content = u['content'];
+    if (Array.isArray(content)) {
+        const parts = [];
+        for (const c of content) {
+            const cc = c;
+            if (cc?.type === 'text' && typeof cc.text === 'string') {
+                parts.push(cc.text);
+            }
+            else if (cc?.type === 'diff' && typeof cc.newText === 'string') {
+                parts.push(cc.newText);
+            }
+            else if (cc?.content && typeof cc.content.text === 'string') {
+                parts.push(cc.content.text);
+            }
+        }
+        if (parts.length) {
+            return parts.join('\n');
+        }
+    }
+    return '';
+}
+/**
+ * Classify a session/prompt RESULT into clean-vs-error for the exit file. PURE.
+ * - end_turn / max_tokens / max_turn_requests → clean (exit 0)
+ * - cancelled → clean (an intentional interrupt, not a failure)
+ * - a JSON-RPC error, or any other stopReason → error (exit 1)
+ */
+function classifyAcpResult(result) {
+    if (result.error) {
+        return { clean: false, stopReason: 'error', error: String(result.error.message || 'jsonrpc error') };
+    }
+    const sr = String(result.result?.stopReason ?? '');
+    const CLEAN = new Set(['end_turn', 'max_tokens', 'max_turn_requests', 'cancelled']);
+    return { clean: CLEAN.has(sr), stopReason: sr || 'unknown' };
+}
+/**
+ * One persistent ACP process for a workspace root. Not a singleton — the host
+ * keeps a Map<root, AcpSession> and reuses it. Provider behaviour is injected via
+ * the `spec`.
+ */
+class AcpSession {
+    root;
+    model;
+    bin;
+    hooks;
+    extraArgs;
+    spec;
+    /** Extra env vars merged into the child's environment (e.g. OPENCODE_CONFIG). */
+    extraEnv;
+    _decode;
+    child = null;
+    buf = '';
+    nextId = 1;
+    pending = new Map();
+    _sessionId;
+    _wantSessionId; // id to session/load on (re)start
+    _ready = null;
+    _busy = false;
+    _startCount = 0;
+    earlyStderr = '';
+    /** True WHILE session/load is replaying prior history — every session/update
+     *  during the replay is dropped (emits ZERO hooks) so a (re)start never
+     *  re-spams historical narration + tool_calls to the office feed (Layer A.1). */
+    _loading = false;
+    /** The active PRIMARY turn's stdout sink (assistant text). Null between turns. */
+    _sink = null;
+    /** Tool-call names by id, so a tool_result can carry the originating name. */
+    _toolNames = new Map();
+    /** Accumulates assistant chunks so Notification hooks are line-granular. */
+    _narrationBuf = '';
+    /** The current tool activity label (set on tool_call, cleared on result). */
+    _activity;
+    /** Did the active turn produce ANY assistant text or tool call? (empty-turn guard) */
+    _turnHadOutput = false;
+    /** ALL outstanding session/prompt promises — the primary turn AND any steered
+     *  (queued) continuation prompts. The turn is not "done" until this drains, so
+     *  the loop keeps the agent WORKING through steers instead of going idle while
+     *  the agent runs an untracked queued turn (Bug A). */
+    _inflight = new Set();
+    constructor(opts) {
+        this.root = opts.root;
+        this.model = opts.model;
+        this.bin = opts.bin;
+        this.hooks = opts.hooks;
+        this.spec = opts.spec;
+        this._decode = opts.spec.decodeUpdate ?? decodeAcpUpdateStandard;
+        this._wantSessionId = opts.initialSessionId;
+        this.extraArgs = opts.extraArgs ?? [];
+        this.extraEnv = opts.extraEnv ?? {};
+    }
+    /** Per-turn watchdog budget (ms). Env: AUTODEV_ACP_MAX_RUN_MS, else GROK_MAX_RUN_MS
+     *  (parity with the headless path), else 20 minutes. A 0/negative value disables. */
+    static maxRunMs() {
+        const raw = process.env['AUTODEV_ACP_MAX_RUN_MS'] ?? process.env['GROK_MAX_RUN_MS'] ?? '';
+        const n = Number.parseInt(String(raw), 10);
+        if (Number.isFinite(n) && n > 0) {
+            return n;
+        }
+        if (Number.isFinite(n) && n <= 0 && String(raw).trim() !== '') {
+            return 2147483647;
+        } // disabled
+        return 20 * 60 * 1000;
+    }
+    get pid() { return this.child?.pid; }
+    get sessionId() { return this._sessionId; }
+    get activity() { return this._activity; }
+    /** Busy while the primary turn is running OR any steered/queued prompt is still
+     *  in-flight — so the loop never treats the agent as idle mid-queue (Bug A). */
+    isBusy() { return this._busy || this._inflight.size > 0; }
+    isAlive() { return !!this.child && this.child.exitCode === null && !this.child.killed; }
+    /** Spawn + initialize + session/new|load, once. Respawns transparently if dead. */
+    async ensureReady() {
+        if (this.isAlive() && this._sessionId) {
+            return;
+        }
+        if (this._ready) {
+            return this._ready;
+        }
+        this._ready = this._startup().catch((err) => { this._ready = null; throw err; });
+        return this._ready;
+    }
+    async _startup() {
+        this._spawnChild();
+        await this._request('initialize', { protocolVersion: 1, clientCapabilities: {} });
+        const want = this._wantSessionId;
+        if (want) {
+            // Layer A.1: suppress hook emission for the whole session/load replay so a
+            // reload restores context QUIETLY (no re-spammed historical narration/tools).
+            this._loading = true;
+            try {
+                const r = await this._request('session/load', { sessionId: want, cwd: this.root, mcpServers: [] });
+                if (!r.error) {
+                    this._sessionId = want;
+                    this.hooks.log(`ACP: restored session ${want.slice(0, 8)}… (session/load, quiet) — context intact`);
+                }
+            }
+            catch (err) {
+                this.hooks.log(`ACP: session/load ${want.slice(0, 8)}… failed (${err?.message ?? err}); starting fresh`);
+            }
+            finally {
+                this._loading = false;
+                this._narrationBuf = ''; // drop any partial replayed narration
+                this._toolNames.clear(); // drop replayed open tool ids (never emitted)
+            }
+        }
+        if (!this._sessionId) {
+            const sn = await this._request('session/new', { cwd: this.root, mcpServers: [] });
+            const sid = sn.result?.sessionId;
+            if (!sid) {
+                const em = sn.error?.message ? ` (${sn.error.message})` : '';
+                throw new Error(`session/new returned no sessionId${em}`);
+            }
+            this._sessionId = sid;
+            this.hooks.log(`ACP: new persistent session ${sid.slice(0, 8)}…`);
+        }
+        this._wantSessionId = this._sessionId;
+        this.hooks.emitHook('SessionStart', { source: this._startCount > 1 ? 'resume' : 'startup' });
+    }
+    _spawnChild() {
+        this._startCount++;
+        const args = this.spec.buildArgs(this.model, this.extraArgs);
+        const child = child_process.spawn(this.bin, args, {
+            cwd: this.root,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, TERM: process.env['TERM'] || 'xterm-256color', ...this.extraEnv },
+        });
+        this.child = child;
+        this.buf = '';
+        this.earlyStderr = '';
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => this._onStdout(chunk));
+        child.stderr?.on('data', (chunk) => {
+            const s = chunk.toString();
+            if (this.earlyStderr.length < 4000) {
+                this.earlyStderr += s;
+            }
+        });
+        child.on('exit', (code, sig) => this._onExit(code, sig));
+        child.on('error', (err) => this.hooks.log(`ACP: child error: ${err.message}`));
+    }
+    _onExit(code, sig) {
+        this.hooks.log(`ACP: agent process exited (code=${code} sig=${sig})`);
+        this.child = null;
+        this._ready = null;
+        this._sink = null;
+        this._busy = false;
+        this._activity = undefined;
+        this._flushOpenTools('interrupted'); // Bug B: close any tools open when the agent dies
+        const err = { error: { message: `acp agent exited (code=${code} sig=${sig})` } };
+        for (const [, p] of this.pending) {
+            try {
+                p.resolve(err);
+            }
+            catch { /* ignore */ }
+        }
+        this.pending.clear();
+        this._inflight.clear();
+    }
+    _onStdout(chunk) {
+        this.buf += chunk;
+        let nl;
+        while ((nl = this.buf.indexOf('\n')) >= 0) {
+            const line = this.buf.slice(0, nl).trim();
+            this.buf = this.buf.slice(nl + 1);
+            if (!line) {
+                continue;
+            }
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            this._handle(msg);
+        }
+    }
+    _handle(msg) {
+        const id = msg['id'];
+        if (typeof id === 'number' && (msg['result'] !== undefined || msg['error'] !== undefined) && this.pending.has(id)) {
+            const p = this.pending.get(id);
+            this.pending.delete(id);
+            p.resolve(msg);
+            return;
+        }
+        // Request FROM the agent (we are the client). With empty caps the agent does
+        // its own fs/terminal, but answer defensively so nothing ever wedges.
+        if (msg['method'] && id !== undefined) {
+            const method = String(msg['method']);
+            if (method === 'session/request_permission') {
+                const params = msg['params'];
+                const opts = params?.options ?? [];
+                const allow = opts.find((o) => /allow|once|always/i.test(o.optionId || o.kind || '')) || opts[0];
+                this._send({ jsonrpc: '2.0', id, result: { outcome: { outcome: 'selected', optionId: allow?.optionId } } });
+            }
+            else {
+                this._send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'client capability not provided' } });
+            }
+            return;
+        }
+        if (msg['method'] === 'session/update') {
+            this._onUpdate(this._decode(msg));
+        }
+    }
+    _onUpdate(u) {
+        if (this._loading) {
+            return;
+        } // Layer A.1: drop session/load replay silently
+        if (u.kind === 'assistant') {
+            this._turnHadOutput = true;
+            if (this._sink) {
+                try {
+                    this._sink(u.text);
+                }
+                catch { /* ignore */ }
+            }
+            this._narrationBuf += u.text;
+            this._flushNarration(false);
+            return;
+        }
+        if (u.kind === 'reasoning') {
+            if (!this.spec.narrateReasoning) {
+                return;
+            } // reasoning kept out of the feed by default
+            this._narrationBuf += u.text;
+            this._flushNarration(false);
+            return;
+        }
+        if (u.kind === 'tool_call') {
+            if (!u.name || u.name.startsWith('mcp__')) {
+                return;
+            } // office logs MCP tools server-side
+            this._turnHadOutput = true;
+            this._activity = u.name;
+            this._toolNames.set(u.id, u.name);
+            this.hooks.emitHook('PreToolUse', { tool_name: u.name, tool_input: u.input, tool_use_id: u.id });
+            return;
+        }
+        if (u.kind === 'tool_result') {
+            const name = this._toolNames.get(u.id);
+            if (!name) {
+                return;
+            } // no matching Pre (skipped mcp tool / replay) — don't emit orphan
+            this._toolNames.delete(u.id);
+            this._activity = undefined;
+            if (u.status === 'failed' || u.status === 'cancelled') {
+                this.hooks.emitHook('PostToolUseFailure', { tool_name: name, tool_use_id: u.id, outcome: u.status === 'cancelled' ? 'cancelled' : 'error', tool_output: { text: u.outputText.slice(0, 2000) } });
+            }
+            else {
+                this.hooks.emitHook('PostToolUse', { tool_name: name, tool_use_id: u.id, tool_output: { text: u.outputText.slice(0, 2000) } });
+            }
+        }
+    }
+    /**
+     * Bug B invariant: every forwarded tool-START must get a matching tool-END. On
+     * turn end / cancel / teardown, FLUSH any tool_call ids still open (never got a
+     * terminal tool_call_update) as ended, so pixel-office (which pairs start→end)
+     * never shows a tool stuck "running" after the agent is idle.
+     */
+    _flushOpenTools(outcome) {
+        if (this._toolNames.size === 0) {
+            return;
+        }
+        for (const [id, name] of this._toolNames) {
+            try {
+                this.hooks.emitHook('PostToolUseFailure', { tool_name: name, tool_use_id: id, outcome, tool_output: { text: `[${outcome}]` } });
+            }
+            catch { /* ignore */ }
+        }
+        this._toolNames.clear();
+        this._activity = undefined;
+    }
+    /** Emit completed narration lines as Notification hooks. `final` flushes the
+     *  trailing partial line (turn end). Keeps the office feed line-granular. */
+    _flushNarration(final) {
+        let nl;
+        while ((nl = this._narrationBuf.indexOf('\n')) >= 0) {
+            const line = this._narrationBuf.slice(0, nl);
+            this._narrationBuf = this._narrationBuf.slice(nl + 1);
+            if (line.trim()) {
+                this.hooks.emitHook('Notification', { message: line, title: this.spec.narrationTitle, tool_name: this.spec.narrationTitle });
+            }
+        }
+        if (final && this._narrationBuf.trim()) {
+            this.hooks.emitHook('Notification', { message: this._narrationBuf, title: this.spec.narrationTitle, tool_name: this.spec.narrationTitle });
+        }
+        if (final) {
+            this._narrationBuf = '';
+        }
+    }
+    /**
+     * Run ONE primary turn: send the prompt and await turn end. Streams assistant
+     * text to `sink`. Emits Stop/StopFailure + SessionEnd. The process stays alive.
+     */
+    async runTurn(promptText, sink) {
+        await this.ensureReady();
+        this._busy = true;
+        this._sink = sink;
+        this._turnHadOutput = false;
+        // Layer A.3: per-turn watchdog — a wedged always-open turn must never hang the
+        // loop forever. If the turn (primary + drained steers) blows the budget we
+        // cancel + reconnect and surface it as a FAILURE (never a false success).
+        const budget = AcpSession.maxRunMs();
+        let timedOut = false;
+        let timer;
+        const watchdog = new Promise((resolve) => { timer = setTimeout(() => { timedOut = true; resolve('timeout'); }, budget); });
+        let res;
+        try {
+            const outcome = await Promise.race([
+                (async () => {
+                    const r = await this._promptRequest(promptText);
+                    const c = classifyAcpResult(r);
+                    // Bug A: drain any STEERED (queued) continuation prompts before declaring
+                    // the turn done — the agent stays WORKING until the ACP queue is empty.
+                    try {
+                        await this._drainInflight();
+                    }
+                    catch { /* resolve on exit */ }
+                    return c;
+                })(),
+                watchdog,
+            ]);
+            if (outcome === 'timeout') {
+                this.hooks.log(`ACP: turn exceeded ${budget}ms watchdog — cancelling + reconnecting`);
+                try {
+                    this.cancel();
+                }
+                catch { /* ignore */ }
+                try {
+                    this.close();
+                }
+                catch { /* ignore */ } // next turn respawns + session/load restores context
+                res = { clean: false, stopReason: 'timeout', error: `turn exceeded ${budget}ms watchdog` };
+            }
+            else {
+                res = outcome;
+            }
+        }
+        catch (err) {
+            res = { clean: false, stopReason: 'exception', error: err?.message ?? String(err) };
+        }
+        finally {
+            if (timer) {
+                clearTimeout(timer);
+            }
+        }
+        this._flushNarration(true);
+        if (!timedOut) {
+            this._flushOpenTools('interrupted');
+        } // Bug B (close() already flushed on timeout)
+        this._sink = null;
+        this._busy = false;
+        this._activity = undefined;
+        res.emptyOutput = res.clean && !this._turnHadOutput;
+        if (res.clean) {
+            this.hooks.emitHook('Stop', {});
+            this.hooks.emitHook('SessionEnd', { reason: 'completed' });
+        }
+        else {
+            this.hooks.emitHook('StopFailure', { exit_code: 1 });
+            this.hooks.emitHook('SessionEnd', { reason: 'error' });
+        }
+        return res;
+    }
+    /**
+     * Deliver a mid-run STEER: send an additional session/prompt the agent QUEUES
+     * (FIFO) and runs next — without exiting. The prompt is TRACKED in `_inflight`
+     * so the in-progress runTurn drains it before finishing (Bug A) — the steered
+     * turn's session/update hooks are forwarded like a normal turn and the loop
+     * stays WORKING until it completes. Returns true if handed to the live agent.
+     */
+    steer(text) {
+        if (!this.isAlive() || !this._sessionId) {
+            return false;
+        }
+        const t = text.trim();
+        if (!t) {
+            return false;
+        }
+        void this._promptRequest(t); // tracked; drained by the active runTurn
+        return true;
+    }
+    /** Send a tracked session/prompt (primary or steer) and register it in
+     *  `_inflight` until it resolves. */
+    _promptRequest(text) {
+        const p = this._request('session/prompt', { sessionId: this._sessionId, prompt: [{ type: 'text', text }] });
+        this._inflight.add(p);
+        void p.then(() => { this._inflight.delete(p); }, () => { this._inflight.delete(p); });
+        return p;
+    }
+    /** Wait until every in-flight/queued prompt has resolved. */
+    async _drainInflight() {
+        let guard = 0;
+        while (this._inflight.size > 0 && guard++ < 10000) {
+            try {
+                await Promise.race([...this._inflight]);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    /**
+     * Send a QUIET prompt (e.g. `/compact`) and await it WITHOUT emitting the
+     * Stop/SessionEnd turn-boundary hooks — used for maintenance commands so they
+     * don't register as a task turn. Best-effort.
+     */
+    async sendQuiet(text) {
+        if (!this.isAlive() || !this._sessionId) {
+            return;
+        }
+        try {
+            await this._request('session/prompt', { sessionId: this._sessionId, prompt: [{ type: 'text', text }] });
+        }
+        catch { /* ignore */ }
+    }
+    /** Cancel the running turn (process stays alive). */
+    cancel() {
+        if (!this.isAlive() || !this._sessionId) {
+            return;
+        }
+        this._send({ jsonrpc: '2.0', method: 'session/cancel', params: { sessionId: this._sessionId } });
+        this._flushOpenTools('cancelled'); // Bug B: close any tools open at cancel
+    }
+    /** Kill the persistent process. Preserves the known session id for a later load. */
+    close() {
+        const c = this.child;
+        this.child = null;
+        this._ready = null;
+        this._sink = null;
+        this._busy = false;
+        this._activity = undefined;
+        this._flushOpenTools('interrupted'); // Bug B: close any tools open at teardown
+        for (const [, p] of this.pending) {
+            try {
+                p.resolve({ error: { message: 'closed' } });
+            }
+            catch { /* ignore */ }
+        }
+        this.pending.clear();
+        this._inflight.clear();
+        if (c) {
+            try {
+                c.stdin?.end();
+            }
+            catch { /* ignore */ }
+            try {
+                c.kill('SIGKILL');
+            }
+            catch { /* ignore */ }
+        }
+    }
+    _request(method, params) {
+        const id = this.nextId++;
+        return new Promise((resolve) => {
+            this.pending.set(id, { resolve });
+            const ok = this._send({ jsonrpc: '2.0', id, method, params });
+            if (!ok) {
+                this.pending.delete(id);
+                resolve({ error: { message: 'stdin write failed (agent not running)' } });
+            }
+        });
+    }
+    _send(obj) {
+        const c = this.child;
+        if (!c || !c.stdin || c.stdin.destroyed) {
+            return false;
+        }
+        try {
+            c.stdin.write(JSON.stringify(obj) + '\n');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    get stderrSnapshot() { return this.earlyStderr; }
+}
+exports.AcpSession = AcpSession;
+//# sourceMappingURL=AcpSession.js.map