@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/agent/cli-session.js

@@ -1,465 +1,538 @@
-/**
- * Persistent CLI session manager — eliminates cold-start delay by keeping
- * the Claude CLI process alive between messages.
- *
- * Instead of spawning a new CLI process per message (~5s cold start + MCP
- * handshake), we spawn once with `--input-format stream-json` and feed
- * messages via stdin. The CLI maintains conversation context internally.
- *
- * KEY LEARNINGS (Claude Code CLI v2.1.76):
- *
- * 1. Stdin message format (NDJSON):
- *    {"type":"user","message":{"role":"user","content":"..."},"parent_tool_use_id":null}
- *
- * 2. The CLI stays alive between messages when stdin is kept open.
- *    Each message gets its own system/init → stream_events → result cycle.
- *
- * 3. Turn boundary: the `result` event marks the end of a CLI turn, NOT
- *    `message_stop` from stream_event.
- *
- * 4. The CLI uses NDJSON for MCP stdio transport (not Content-Length framing).
- */
-import { randomUUID } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { spawn as nodeSpawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { StreamJsonParser } from './streaming.js';
-const DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
-// Package version included in session fingerprint so cached sessions
-// auto-invalidate when the core is updated (e.g. npm update).
-let CORE_VERSION = 'unknown';
-try {
-    const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json');
-    CORE_VERSION = JSON.parse(readFileSync(pkgPath, 'utf-8')).version;
-}
-catch { /* non-fatal */ }
-export class CliSession {
-    sessionId = randomUUID();
-    child = null;
-    alive = false;
-    stderrBuf = '';
-    stdoutBuffer = '';
-    activeTurn = null;
-    idleTimer = null;
-    cleanupFn = null;
-    parser;
-    log;
-    spawnFn;
-    idleTimeout;
-    opts;
-    constructor(options) {
-        this.opts = options;
-        this.log = options.logger;
-        this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
-        this.idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT_MS;
-        // Parser delegates to pushEvent which routes to activeTurn
-        this.parser = new StreamJsonParser((event) => this.pushEvent(event));
+// src/agent/cli-session.ts
+import { randomUUID } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { spawn as nodeSpawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+// src/agent/streaming.ts
+var StreamJsonParser = class {
+  constructor(pushEvent) {
+    this.pushEvent = pushEvent;
+  }
+  pushEvent;
+  hasAssistantText = false;
+  insideToolUse = false;
+  activeToolJsonChunks = /* @__PURE__ */ new Map();
+  /** Reset per-turn state. Call before starting a new turn in persistent sessions. */
+  reset() {
+    this.hasAssistantText = false;
+    this.insideToolUse = false;
+    this.activeToolJsonChunks.clear();
+  }
+  /** Whether any text_delta events have been emitted this turn. */
+  get hasText() {
+    return this.hasAssistantText;
+  }
+  /**
+   * Feed a single NDJSON line (without trailing newline).
+   * Parses and emits StreamEvent(s) via the callback.
+   */
+  feed(line) {
+    if (!line.trim()) return;
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      if (line.trim() && !this.hasAssistantText) {
+        this.pushEvent({ type: "text_delta", text: line });
+      }
+      return;
     }
-    get ready() {
-        return this.alive;
+    if (event.type === "stream_event" && event.event) {
+      event = event.event;
     }
-    /**
-     * Check if this session was created with equivalent CLI-relevant options.
-     * Used by the session cache to detect option drift.
-     */
-    matchesOptions(other) {
-        return CliSession.fingerprint(this.opts) === CliSession.fingerprint(other);
+    this.processEvent(event);
+  }
+  processEvent(event) {
+    const block = event.content_block;
+    const delta = event.delta;
+    if (event.type === "content_block_start" && block?.type === "tool_use") {
+      this.insideToolUse = true;
+      const id = block.id || `cli-tool-${Date.now()}`;
+      const name = block.name || "unknown";
+      this.pushEvent({ type: "tool_use_start", id, name });
+      this.activeToolJsonChunks.set(id, { name, chunks: [] });
+      return;
     }
-    /**
-     * Inject a mock child process for testing.
-     * @internal — test only
-     */
-    _injectForTest(child) {
-        this.child = child;
-        this.alive = true;
-        this.stderrBuf = '';
-        this.stdoutBuffer = '';
-        child.stdout.on('data', (chunk) => {
-            this.onStdoutData(chunk.toString());
-        });
-        child.on('exit', () => this.markDead());
-        child.on('error', () => this.markDead());
+    if (event.type === "content_block_start" && block?.type === "text") {
+      this.insideToolUse = false;
+      return;
     }
-    /**
-     * Spawn the CLI process. Must be called before send().
-     */
-    async spawn() {
-        // Kill existing child to prevent orphaned processes from concurrent spawn
-        if (this.child && this.alive) {
-            this.child.kill('SIGTERM');
-        }
-        const { binPath, cwd, env, model, mcpConfigPath } = this.opts;
-        const args = [
-            '-p',
-            '--input-format',
-            'stream-json',
-            '--output-format',
-            'stream-json',
-            '--include-partial-messages',
-            '--verbose',
-            '--dangerously-skip-permissions',
-            '--permission-mode',
-            'bypassPermissions',
-            '--setting-sources',
-            'user,local',
-            '--model',
-            model,
-        ];
-        if (mcpConfigPath) {
-            args.push('--mcp-config', mcpConfigPath);
-        }
-        if (this.opts.strictMcpConfig || mcpConfigPath) {
-            args.push('--strict-mcp-config');
-        }
-        const { disallowedTools, tools, systemPrompt, appendSystemPrompt } = this.opts;
-        if (disallowedTools && disallowedTools.length > 0) {
-            args.push('--disallowed-tools', disallowedTools.join(','));
-        }
-        // Phase 1.1: --tools flag (whitelist / disable all)
-        if (tools !== undefined) {
-            args.push('--tools', tools);
-        }
-        if (systemPrompt) {
-            args.push('--system-prompt', systemPrompt);
-        }
-        // Phase 1.2: --append-system-prompt flag
-        if (appendSystemPrompt) {
-            args.push('--append-system-prompt', appendSystemPrompt);
-        }
-        const spawnResult = this.spawnFn(binPath, args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env: env ?? process.env });
-        const child = 'child' in spawnResult ? spawnResult.child : spawnResult;
-        const cleanup = 'cleanup' in spawnResult ? spawnResult.cleanup : undefined;
-        this.child = child;
-        this.cleanupFn = cleanup ?? null;
-        this.alive = true;
-        this.stderrBuf = '';
-        this.stdoutBuffer = '';
-        child.stderr.on('data', (chunk) => {
-            this.stderrBuf += chunk.toString();
-        });
-        child.stdout.on('data', (chunk) => {
-            this.onStdoutData(chunk.toString());
-        });
-        child.on('exit', (code) => {
-            this.log?.info('CLI session process exited', { sessionId: this.sessionId, exitCode: code });
-            this.markDead();
-        });
-        child.on('error', (err) => {
-            this.log?.error('CLI session process error', { sessionId: this.sessionId, err });
-            this.markDead();
-        });
-        this.resetIdleTimer();
-        this.log?.info('CLI session spawned', { sessionId: this.sessionId, cwd, model });
+    if (event.type === "content_block_delta" && delta?.type === "input_json_delta") {
+      const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+      if (lastTool) lastTool[1].chunks.push(delta.partial_json || "");
+      return;
     }
-    /**
-     * Send a user message and stream back events.
-     * Auto-respawns if the process has died.
-     *
-     * Phase 1.3: Concurrent send() guard — throws if a previous turn is still active.
-     * The activeTurn lock is claimed synchronously BEFORE any async work (spawn)
-     * to prevent TOCTOU races.
-     */
-    async *send(userMessage, systemPromptPrefix) {
-        // Phase 1.3: Guard against concurrent sends
-        if (this.activeTurn) {
-            throw new Error('CliSession: concurrent send() calls are not supported. Previous turn still active.');
-        }
-        // Claim the turn synchronously BEFORE any await to prevent TOCTOU race
-        const turn = { resolve: () => { }, events: [], done: false };
-        this.activeTurn = turn;
+    if (event.type === "content_block_delta" && delta?.type === "thinking_delta" && delta?.thinking) {
+      this.pushEvent({ type: "thinking_delta", text: delta.thinking });
+      return;
+    }
+    if (event.type === "content_block_delta" && delta?.text && !this.insideToolUse) {
+      this.hasAssistantText = true;
+      this.pushEvent({ type: "text_delta", text: delta.text });
+      return;
+    }
+    if (event.type === "content_block_stop" && this.insideToolUse) {
+      const lastTool = [...this.activeToolJsonChunks.entries()].pop();
+      if (lastTool) {
+        const [id, { chunks }] = lastTool;
+        let args = {};
         try {
-            if (!this.alive) {
-                this.log?.info('CLI session dead, respawning', { sessionId: this.sessionId });
-                await this.spawn();
-            }
-            this.resetIdleTimer();
-            this.parser.reset();
-            const content = systemPromptPrefix ? `${systemPromptPrefix}\n\n${userMessage}` : userMessage;
-            // Write NDJSON message to stdin
-            const ndjsonMessage = JSON.stringify({
-                type: 'user',
-                message: { role: 'user', content },
-                parent_tool_use_id: null,
-            }) + '\n';
-            // Track whether this turn saw a 'result' event (definitive turn end)
-            let sawResult = false;
-            // Wrap pushEvent to suppress intermediate message_stop events.
-            // The CLI emits message_stop for each API turn, but the session's turn
-            // boundary is the `result` event. Intermediate message_stop events would
-            // cause runAgentLoop to exit early (thinking the model stopped), missing
-            // later events including the result's usage with total_cost_usd.
-            const originalPush = this.pushEvent.bind(this);
-            this.parser = new StreamJsonParser((event) => {
-                if (event.type === 'message_stop' && !sawResult && event.finishReason !== 'error') {
-                    // Suppress — not the real turn end. The result event will emit
-                    // the final message_stop after all usage data is captured.
-                    // Error stops (e.g. authentication_failed) must pass through
-                    // so runAgentLoop can detect the failure.
-                    return;
-                }
-                originalPush(event);
-            });
-            // Override parser feed to detect result events for turn completion
-            let sawTerminal = false;
-            const baseFeed = this.parser.feed.bind(this.parser);
-            this.parser.feed = (line) => {
-                // Check if this line is a turn-ending event before parsing
-                try {
-                    let parsed = JSON.parse(line);
-                    if (parsed.type === 'stream_event' && parsed.event)
-                        parsed = parsed.event;
-                    if (parsed.type === 'result') {
-                        sawResult = true;
-                        sawTerminal = true;
-                    }
-                    // authentication_failed is also a terminal event
-                    if (parsed.type === 'assistant' && parsed.error === 'authentication_failed') {
-                        sawTerminal = true;
-                    }
-                }
-                catch {
-                    // Not JSON, let parser handle it
-                }
-                baseFeed(line);
-                if (sawTerminal) {
-                    this.completeTurn();
-                }
-            };
-            try {
-                this.child.stdin.write(ndjsonMessage, (err) => {
-                    if (err) {
-                        this.log?.error('stdin write error', { sessionId: this.sessionId, err });
-                        this.markDead();
-                        turn.done = true;
-                        turn.resolve();
-                    }
-                });
-            }
-            catch (err) {
-                this.log?.error('stdin write exception', { sessionId: this.sessionId, err });
-                this.markDead();
-                throw new Error('CLI session stdin write failed');
-            }
-            // Yield events as they arrive
-            while (!turn.done || turn.events.length > 0) {
-                if (turn.events.length > 0) {
-                    yield turn.events.shift();
-                }
-                else {
-                    await new Promise((r) => {
-                        turn.resolve = r;
-                        setTimeout(r, 50);
-                    });
-                }
-            }
-            // Yield any remaining events
-            while (turn.events.length > 0) {
-                yield turn.events.shift();
-            }
+          args = JSON.parse(chunks.join(""));
+        } catch {
         }
-        finally {
-            // Log how the turn ended for debugging cost/result event issues.
-            // If turn.done is false here, the generator was abandoned by the consumer
-            // (e.g., for-await broke out) before completeTurn/markDead fired.
-            // This means the result event hasn't been processed yet, and any
-            // subsequent stdout data (including the result) will be silently dropped
-            // because activeTurn is about to be set to null.
-            if (!turn.done) {
-                process.stderr.write(`\x1b[33m  ⚠ CliSession: generator abandoned before turn.done (events=${turn.events.length}). Result event will be lost.\x1b[0m\n`);
-            }
-            this.activeTurn = null;
-            this.resetIdleTimer();
+        this.pushEvent({ type: "tool_use_end", id, arguments: args });
+        this.activeToolJsonChunks.delete(id);
+      }
+      this.insideToolUse = false;
+      return;
+    }
+    if (event.type === "user" && event.message?.content) {
+      const content = event.message.content;
+      for (const contentBlock of content) {
+        if (contentBlock.type === "tool_result" && contentBlock.tool_use_id) {
+          const text = Array.isArray(contentBlock.content) ? contentBlock.content.map((c) => c.text || "").join("") : String(contentBlock.content || "");
+          this.pushEvent({
+            type: "tool_result",
+            id: contentBlock.tool_use_id,
+            result: text,
+            isError: !!contentBlock.is_error
+          });
         }
+      }
+      return;
     }
-    /** Whether a send() call is currently active. */
-    get hasActiveTurn() {
-        return this.activeTurn !== null && !this.activeTurn.done;
+    if (event.type === "message_start" && event.message?.usage) {
+      const usage = event.message.usage;
+      this.pushEvent({
+        type: "usage",
+        promptTokens: usage.input_tokens ?? 0,
+        completionTokens: usage.output_tokens ?? 0
+      });
+      return;
     }
-    /**
-     * Kill the CLI process.
-     */
-    kill() {
-        if (this.hasActiveTurn) {
-            process.stderr.write(`\x1b[31m  ✗ CliSession.kill() called with active turn — data loss will occur (session=${this.sessionId.slice(0, 8)})\x1b[0m\n`);
-            this._onSessionKilled?.({ sessionId: this.sessionId, hadActiveTurn: true, eventsInTurn: this.activeTurn.events.length });
-        }
-        this.clearIdleTimer();
-        if (this.child && this.alive) {
-            this.log?.info('Killing CLI session', { sessionId: this.sessionId });
-            this.child.kill('SIGTERM');
-            // Phase 1.5: unref the SIGKILL fallback timer so it doesn't keep Node alive
-            const sigkillTimer = setTimeout(() => {
-                if (this.child && !this.child.killed) {
-                    this.child.kill('SIGKILL');
-                }
-            }, 2000);
-            sigkillTimer.unref();
-        }
-        this.markDead();
+    if (event.type === "message_delta" && event.usage) {
+      const usage = event.usage;
+      this.pushEvent({
+        type: "usage",
+        promptTokens: 0,
+        completionTokens: usage.output_tokens ?? 0
+      });
+      return;
     }
-    /** Callback for session kill events — wire to audit logging. */
-    _onSessionKilled;
-    /** Register a callback that fires when this session is killed. */
-    set onSessionKilled(cb) {
-        this._onSessionKilled = cb;
+    if (event.type === "message_stop") {
+      this.pushEvent({ type: "message_stop", finishReason: "stop" });
+      return;
     }
-    // ---------------------------------------------------------------------------
-    // Private
-    // ---------------------------------------------------------------------------
-    /**
-     * Compute a fingerprint of CLI-relevant options for cache comparison.
-     * Field order is significant for JSON.stringify comparison.
-     * Add new CLI-relevant fields here when they're added to CliSessionOptions.
-     *
-     * NOTE: mcpConfigPath is EXCLUDED. It's an ephemeral temp path that changes
-     * on every createMcpBridge() call. Including it causes fingerprint mismatches
-     * that kill active sessions mid-turn when a second provider is created for
-     * the same project (e.g., orchestrator + worker sharing the same projectDir).
-     * The MCP bridge is swapped per-request via setHandlers() — the config path
-     * is only needed at spawn time, not for session identity.
-     */
-    static fingerprint(options) {
-        return JSON.stringify({
-            _coreVersion: CORE_VERSION, // auto-invalidate cache on core update
-            model: options.model,
-            // mcpConfigPath deliberately excluded — see comment above
-            strictMcpConfig: options.strictMcpConfig,
-            disallowedTools: options.disallowedTools,
-            tools: options.tools,
-            systemPrompt: options.systemPrompt,
-            appendSystemPrompt: options.appendSystemPrompt,
+    if (event.type === "result") {
+      if (event.is_error) {
+        this.pushEvent({ type: "message_stop", finishReason: "error" });
+        return;
+      }
+      if (event.result && !this.hasAssistantText) {
+        this.pushEvent({ type: "text_delta", text: event.result });
+      }
+      if (event.usage) {
+        const usage = event.usage;
+        this.pushEvent({
+          type: "usage",
+          promptTokens: usage.input_tokens ?? 0,
+          completionTokens: usage.output_tokens ?? 0,
+          cacheReadTokens: usage.cache_read_input_tokens ?? void 0,
+          cacheCreationTokens: usage.cache_creation_input_tokens ?? void 0,
+          costUsd: typeof event.total_cost_usd === "number" ? event.total_cost_usd : void 0
         });
+      }
+      this.pushEvent({ type: "message_stop", finishReason: "stop" });
+      return;
+    }
+    if (event.type === "assistant") {
+      if (event.error === "authentication_failed") {
+        this.pushEvent({ type: "message_stop", finishReason: "error" });
+      }
     }
-    pushEvent(event) {
-        if (!this.activeTurn)
-            return;
-        this.activeTurn.events.push(event);
-        this.activeTurn.resolve();
+  }
+};
+
+// src/agent/cli-session.ts
+var DEFAULT_IDLE_TIMEOUT_MS = 10 * 60 * 1e3;
+var CORE_VERSION = "unknown";
+try {
+  const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+  CORE_VERSION = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+} catch {
+}
+var CliSession = class _CliSession {
+  sessionId = randomUUID();
+  child = null;
+  alive = false;
+  stderrBuf = "";
+  stdoutBuffer = "";
+  activeTurn = null;
+  idleTimer = null;
+  cleanupFn = null;
+  parser;
+  log;
+  spawnFn;
+  idleTimeout;
+  opts;
+  constructor(options) {
+    this.opts = options;
+    this.log = options.logger;
+    this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
+    this.idleTimeout = options.idleTimeout ?? DEFAULT_IDLE_TIMEOUT_MS;
+    this.parser = new StreamJsonParser((event) => this.pushEvent(event));
+  }
+  get ready() {
+    return this.alive;
+  }
+  /**
+   * Check if this session was created with equivalent CLI-relevant options.
+   * Used by the session cache to detect option drift.
+   */
+  matchesOptions(other) {
+    return _CliSession.fingerprint(this.opts) === _CliSession.fingerprint(other);
+  }
+  /**
+   * Inject a mock child process for testing.
+   * @internal test only
+   */
+  _injectForTest(child) {
+    this.child = child;
+    this.alive = true;
+    this.stderrBuf = "";
+    this.stdoutBuffer = "";
+    child.stdout.on("data", (chunk) => {
+      this.onStdoutData(chunk.toString());
+    });
+    child.on("exit", () => this.markDead());
+    child.on("error", () => this.markDead());
+  }
+  /**
+   * Spawn the CLI process. Must be called before send().
+   */
+  async spawn() {
+    if (this.child && this.alive) {
+      this.child.kill("SIGTERM");
     }
-    completeTurn() {
-        if (!this.activeTurn)
-            return;
-        this.activeTurn.done = true;
-        this.activeTurn.resolve();
+    const { binPath, cwd, env, model, mcpConfigPath } = this.opts;
+    const args = [
+      "-p",
+      "--input-format",
+      "stream-json",
+      "--output-format",
+      "stream-json",
+      "--include-partial-messages",
+      "--verbose",
+      "--dangerously-skip-permissions",
+      "--permission-mode",
+      "bypassPermissions",
+      "--setting-sources",
+      "user,local",
+      "--model",
+      model
+    ];
+    if (mcpConfigPath) {
+      args.push("--mcp-config", mcpConfigPath);
     }
-    markDead() {
-        // Phase 1.5: Clear idle timer to prevent dangling timer on process crash
-        this.clearIdleTimer();
-        this.alive = false;
-        this.cleanupFn?.();
-        this.cleanupFn = null;
-        if (this.activeTurn && !this.activeTurn.done) {
-            // KNOWN ISSUE: On long orchestrator runs (many MCP tool calls), the CLI
-            // process can die before emitting the `result` event. This means:
-            // - costUsd from total_cost_usd is lost (stays 0)
-            // - cacheReadTokens / cacheCreationTokens are lost
-            // - The turn ends via markDead instead of completeTurn
-            // When this happens, consumers should fall back to cost-update events
-            // from the global usage callback for accurate cost tracking.
-            // See: project_costUsd_bench_issue.md in memory for full investigation.
-            const eventCount = this.activeTurn.events.length;
-            const hasResult = this.activeTurn.events.some((e) => e.type === 'usage' && e.costUsd != null);
-            if (!hasResult) {
-                const lastStderr = this.stderrBuf.slice(-500);
-                this.log?.warn('CLI session died before result event — costUsd will be 0', {
-                    sessionId: this.sessionId,
-                    eventsInTurn: eventCount,
-                    lastStderr: lastStderr || '(empty)',
-                });
-                // Always log to stderr so it's visible in bench output
-                process.stderr.write(`\x1b[33m  ⚠ CLI session died before result event (${eventCount} events buffered). costUsd will be 0. stderr: ${lastStderr.slice(0, 200)}\x1b[0m\n`);
-            }
-            if (!this.activeTurn.events.some((e) => e.type === 'message_stop')) {
-                this.activeTurn.events.push({ type: 'message_stop', finishReason: 'error' });
-            }
-            this.activeTurn.done = true;
-            this.activeTurn.resolve();
-        }
+    if (this.opts.strictMcpConfig || mcpConfigPath) {
+      args.push("--strict-mcp-config");
     }
-    onStdoutData(data) {
-        this.stdoutBuffer += data;
-        const lines = this.stdoutBuffer.split('\n');
-        this.stdoutBuffer = lines.pop() || '';
-        for (const line of lines) {
-            this.parser.feed(line);
-        }
+    const { disallowedTools, allowedTools, systemPrompt, appendSystemPrompt } = this.opts;
+    if (disallowedTools && disallowedTools.length > 0) {
+      args.push("--disallowed-tools", disallowedTools.join(","));
     }
-    resetIdleTimer() {
-        this.clearIdleTimer();
-        this.idleTimer = setTimeout(() => {
-            this.log?.info('CLI session idle timeout, killing', { sessionId: this.sessionId });
-            this.kill();
-        }, this.idleTimeout);
-        // Phase 1.5: unref so idle timer doesn't keep Node alive on shutdown
-        this.idleTimer.unref();
+    if (allowedTools !== void 0) {
+      args.push("--allowed-tools", allowedTools.join(","));
     }
-    clearIdleTimer() {
-        if (this.idleTimer) {
-            clearTimeout(this.idleTimer);
-            this.idleTimer = null;
-        }
+    if (systemPrompt) {
+      args.push("--system-prompt", systemPrompt);
     }
-}
-// ---------------------------------------------------------------------------
-// Session manager — cache keyed by identifier
-// ---------------------------------------------------------------------------
-const sessions = new Map();
-/**
- * Get an existing session or create a new one.
- * Phase 1.4: Validates that cached sessions have matching CLI-relevant options.
- * If options changed on the same key, the old session is killed and recreated.
- *
- * SAFETY: Refuses to kill a session with an active turn. This prevents data
- * loss when multiple providers share the same session key (e.g., orchestrator
- * and worker both using projectDir as key). If the fingerprint doesn't match
- * but the session has an active turn, we return the existing session and log
- * a warning — better to reuse a session with slightly different options than
- * to kill an active conversation and lose costUsd/result data.
- */
-export function getOrCreateCliSession(key, options) {
-    const existing = sessions.get(key);
-    if (existing && existing.ready) {
-        // Phase 1.4: Check if CLI-relevant options match
-        if (existing.matchesOptions(options)) {
-            return existing;
+    if (appendSystemPrompt) {
+      args.push("--append-system-prompt", appendSystemPrompt);
+    }
+    const spawnResult = this.spawnFn(
+      binPath,
+      args,
+      { cwd, stdio: ["pipe", "pipe", "pipe"], env: env ?? process.env }
+    );
+    const child = "child" in spawnResult ? spawnResult.child : spawnResult;
+    const cleanup = "cleanup" in spawnResult ? spawnResult.cleanup : void 0;
+    this.child = child;
+    this.cleanupFn = cleanup ?? null;
+    this.alive = true;
+    this.stderrBuf = "";
+    this.stdoutBuffer = "";
+    child.stderr.on("data", (chunk) => {
+      this.stderrBuf += chunk.toString();
+    });
+    child.stdout.on("data", (chunk) => {
+      this.onStdoutData(chunk.toString());
+    });
+    child.on("exit", (code) => {
+      this.log?.info("CLI session process exited", { sessionId: this.sessionId, exitCode: code });
+      this.markDead();
+    });
+    child.on("error", (err) => {
+      this.log?.error("CLI session process error", { sessionId: this.sessionId, err });
+      this.markDead();
+    });
+    this.resetIdleTimer();
+    this.log?.info("CLI session spawned", { sessionId: this.sessionId, cwd, model });
+  }
+  /**
+   * Send a user message and stream back events.
+   * Auto-respawns if the process has died.
+   *
+   * Phase 1.3: Concurrent send() guard that throws if a previous turn is still active.
+   * The activeTurn lock is claimed synchronously BEFORE any async work (spawn)
+   * to prevent TOCTOU races.
+   */
+  async *send(userMessage, systemPromptPrefix) {
+    if (this.activeTurn) {
+      throw new Error("CliSession: concurrent send() calls are not supported. Previous turn still active.");
+    }
+    const turn = { resolve: () => {
+    }, events: [], done: false };
+    this.activeTurn = turn;
+    try {
+      if (!this.alive) {
+        this.log?.info("CLI session dead, respawning", { sessionId: this.sessionId });
+        await this.spawn();
+      }
+      this.resetIdleTimer();
+      this.parser.reset();
+      const content = systemPromptPrefix ? `${systemPromptPrefix}
+
+${userMessage}` : userMessage;
+      const ndjsonMessage = JSON.stringify({
+        type: "user",
+        message: { role: "user", content },
+        parent_tool_use_id: null
+      }) + "\n";
+      let sawResult = false;
+      const originalPush = this.pushEvent.bind(this);
+      this.parser = new StreamJsonParser((event) => {
+        if (event.type === "message_stop" && !sawResult && event.finishReason !== "error") {
+          return;
+        }
+        originalPush(event);
+      });
+      let sawTerminal = false;
+      const baseFeed = this.parser.feed.bind(this.parser);
+      this.parser.feed = (line) => {
+        try {
+          let parsed = JSON.parse(line);
+          if (parsed.type === "stream_event" && parsed.event) parsed = parsed.event;
+          if (parsed.type === "result") {
+            sawResult = true;
+            sawTerminal = true;
+          }
+          if (parsed.type === "assistant" && parsed.error === "authentication_failed") {
+            sawTerminal = true;
+          }
+        } catch {
+        }
+        baseFeed(line);
+        if (sawTerminal) {
+          this.completeTurn();
+        }
+      };
+      try {
+        this.child.stdin.write(ndjsonMessage, (err) => {
+          if (err) {
+            this.log?.error("stdin write error", { sessionId: this.sessionId, err });
+            this.markDead();
+            turn.done = true;
+            turn.resolve();
+          }
+        });
+      } catch (err) {
+        this.log?.error("stdin write exception", { sessionId: this.sessionId, err });
+        this.markDead();
+        throw new Error("CLI session stdin write failed", { cause: err });
+      }
+      while (!turn.done || turn.events.length > 0) {
+        if (turn.events.length > 0) {
+          yield turn.events.shift();
+        } else {
+          await new Promise((r) => {
+            turn.resolve = r;
+            setTimeout(r, 50);
+          });
         }
-        // Options changed — but REFUSE to kill if there's an active turn
-        if (existing.hasActiveTurn) {
-            process.stderr.write(`\x1b[33m  ⚠ getOrCreateCliSession: fingerprint mismatch on key "${key}" but session has active turn — reusing existing session to prevent data loss\x1b[0m\n`);
-            return existing;
+      }
+      while (turn.events.length > 0) {
+        yield turn.events.shift();
+      }
+    } finally {
+      if (!turn.done) {
+        process.stderr.write(`\x1B[33m  CliSession: generator abandoned before turn.done (events=${turn.events.length}). Result event will be lost.\x1B[0m
+`);
+      }
+      this.activeTurn = null;
+      this.resetIdleTimer();
+    }
+  }
+  /** Whether a send() call is currently active. */
+  get hasActiveTurn() {
+    return this.activeTurn !== null && !this.activeTurn.done;
+  }
+  /**
+   * Kill the CLI process.
+   */
+  kill() {
+    if (this.hasActiveTurn) {
+      process.stderr.write(`\x1B[31m  \u2717 CliSession.kill() called with active turn, so data loss will occur (session=${this.sessionId.slice(0, 8)})\x1B[0m
+`);
+      this._onSessionKilled?.({ sessionId: this.sessionId, hadActiveTurn: true, eventsInTurn: this.activeTurn.events.length });
+    }
+    this.clearIdleTimer();
+    if (this.child && this.alive) {
+      this.log?.info("Killing CLI session", { sessionId: this.sessionId });
+      this.child.kill("SIGTERM");
+      const sigkillTimer = setTimeout(() => {
+        if (this.child && !this.child.killed) {
+          this.child.kill("SIGKILL");
         }
-        // No active turn — safe to kill and recreate
-        process.stderr.write(`\x1b[2m  [session-cache] killing session for key "${key}" — fingerprint changed\x1b[0m\n`);
-        existing.kill();
-        sessions.delete(key);
+      }, 2e3);
+      sigkillTimer.unref();
+    }
+    this.markDead();
+  }
+  /** Callback for session kill events — wire to audit logging. */
+  _onSessionKilled;
+  /** Register a callback that fires when this session is killed. */
+  set onSessionKilled(cb) {
+    this._onSessionKilled = cb;
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  /**
+   * Compute a fingerprint of CLI-relevant options for cache comparison.
+   * Field order is significant for JSON.stringify comparison.
+   * Add new CLI-relevant fields here when they're added to CliSessionOptions.
+   *
+   * NOTE: mcpConfigPath is EXCLUDED. It's an ephemeral temp path that changes
+   * on every createMcpBridge() call. Including it causes fingerprint mismatches
+   * that kill active sessions mid-turn when a second provider is created for
+   * the same project (e.g., orchestrator + worker sharing the same projectDir).
+   * The MCP bridge is swapped per-request via setHandlers() — the config path
+   * is only needed at spawn time, not for session identity.
+   */
+  static fingerprint(options) {
+    return JSON.stringify({
+      _coreVersion: CORE_VERSION,
+      // auto-invalidate cache on core update
+      model: options.model,
+      // mcpConfigPath deliberately excluded — see comment above
+      strictMcpConfig: options.strictMcpConfig,
+      disallowedTools: options.disallowedTools,
+      allowedTools: options.allowedTools,
+      systemPrompt: options.systemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt
+    });
+  }
+  pushEvent(event) {
+    if (!this.activeTurn) return;
+    this.activeTurn.events.push(event);
+    this.activeTurn.resolve();
+  }
+  completeTurn() {
+    if (!this.activeTurn) return;
+    this.activeTurn.done = true;
+    this.activeTurn.resolve();
+  }
+  markDead() {
+    this.clearIdleTimer();
+    this.alive = false;
+    this.cleanupFn?.();
+    this.cleanupFn = null;
+    if (this.activeTurn && !this.activeTurn.done) {
+      const eventCount = this.activeTurn.events.length;
+      const hasResult = this.activeTurn.events.some((e) => e.type === "usage" && e.costUsd != null);
+      if (!hasResult) {
+        const lastStderr = this.stderrBuf.slice(-500);
+        this.log?.warn("CLI session died before result event, so costUsd will be 0", {
+          sessionId: this.sessionId,
+          eventsInTurn: eventCount,
+          lastStderr: lastStderr || "(empty)"
+        });
+        process.stderr.write(`\x1B[33m  CLI session died before result event (${eventCount} events buffered). costUsd will be 0. stderr: ${lastStderr.slice(0, 200)}\x1B[0m
+`);
+      }
+      if (!this.activeTurn.events.some((e) => e.type === "message_stop")) {
+        this.activeTurn.events.push({ type: "message_stop", finishReason: "error" });
+      }
+      this.activeTurn.done = true;
+      this.activeTurn.resolve();
     }
-    else if (existing) {
-        // Kill stale (dead) session
-        existing.kill();
-        sessions.delete(key);
+  }
+  onStdoutData(data) {
+    this.stdoutBuffer += data;
+    const lines = this.stdoutBuffer.split("\n");
+    this.stdoutBuffer = lines.pop() || "";
+    for (const line of lines) {
+      this.parser.feed(line);
     }
-    const session = new CliSession(options);
-    sessions.set(key, session);
-    return session;
-}
-/**
- * Kill a specific session.
- */
-export function killCliSession(key) {
-    const session = sessions.get(key);
-    if (session) {
-        session.kill();
-        sessions.delete(key);
+  }
+  resetIdleTimer() {
+    this.clearIdleTimer();
+    this.idleTimer = setTimeout(() => {
+      this.log?.info("CLI session idle timeout, killing", { sessionId: this.sessionId });
+      this.kill();
+    }, this.idleTimeout);
+    this.idleTimer.unref();
+  }
+  clearIdleTimer() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
     }
-}
-/**
- * Kill all CLI sessions (for shutdown).
- */
-export function killAllCliSessions() {
-    for (const [, session] of sessions) {
-        session.kill();
+  }
+};
+var sessions = /* @__PURE__ */ new Map();
+function getOrCreateCliSession(key, options) {
+  const existing = sessions.get(key);
+  if (existing && existing.ready) {
+    if (existing.matchesOptions(options)) {
+      return existing;
     }
-    sessions.clear();
+    if (existing.hasActiveTurn) {
+      process.stderr.write(`\x1B[33m  getOrCreateCliSession: fingerprint mismatch on key "${key}" but session has active turn. Reusing existing session to prevent data loss\x1B[0m
+`);
+      return existing;
+    }
+    process.stderr.write(`\x1B[2m  [session-cache] killing session for key "${key}", fingerprint changed\x1B[0m
+`);
+    existing.kill();
+    sessions.delete(key);
+  } else if (existing) {
+    existing.kill();
+    sessions.delete(key);
+  }
+  const session = new CliSession(options);
+  sessions.set(key, session);
+  return session;
+}
+function killCliSession(key) {
+  const session = sessions.get(key);
+  if (session) {
+    session.kill();
+    sessions.delete(key);
+  }
+}
+function killAllCliSessions() {
+  for (const [, session] of sessions) {
+    session.kill();
+  }
+  sessions.clear();
 }
-//# sourceMappingURL=cli-session.js.map
+export {
+  CliSession,
+  getOrCreateCliSession,
+  killAllCliSessions,
+  killCliSession
+};