@episoda/cli 0.2.153 → 0.2.154

package/dist/daemon/daemon-process.js

@@ -2913,7 +2913,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.153",
+      version: "0.2.154",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8535,7 +8535,7 @@ function generateCodexMcpConfigToml(servers, projectPath) {
 }
 
 // src/agent/agent-manager.ts
-var import_child_process12 = require("child_process");
+var import_child_process14 = require("child_process");
 var path20 = __toESM(require("path"));
 var fs19 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
@@ -8842,6 +8842,1057 @@ function generateClaudeConfig(options = {}) {
 
 // src/agent/agent-manager.ts
 var import_core11 = __toESM(require_dist());
+
+// src/agent/claude-persistent-runtime.ts
+var import_child_process12 = require("child_process");
+var ECHO_TIMEOUT_MS = parseInt(process.env.AGENT_ECHO_TIMEOUT_MS || "10000", 10);
+var INACTIVITY_TIMEOUT_MS = parseInt(process.env.AGENT_STREAM_INACTIVITY_TIMEOUT_MS || "180000", 10);
+var SHUTDOWN_SIGTERM_WAIT_MS = 2e3;
+var SHUTDOWN_SIGKILL_WAIT_MS = 2e3;
+var STDIN_DRAIN_TIMEOUT_MS = 1e4;
+var RUNTIME_DEBUG = process.env.AGENT_RUNTIME_DEBUG === "1";
+var ClaudePersistentRuntime = class {
+  constructor(options) {
+    this.options = options;
+    this.provider = "claude";
+    this.process = null;
+    this._turnState = "idle";
+    this.alive = false;
+    this.stuck = false;
+    // Set when SIGKILL doesn't work (macOS kernel wait)
+    // Current turn's callbacks — set on each sendMessage(), cleared on turn end
+    this.callbacks = null;
+    // Keep a small stderr tail so we can print it on failure without spamming logs.
+    this.stderrTail = "";
+    this.maxStderrTailBytes = 8192;
+    // Stdout JSONL parsing state
+    this.stdoutBuffer = "";
+    this.parsedLineCount = 0;
+    this.chunksSent = 0;
+    this.hasContent = false;
+    // For paragraph breaks between messages
+    // EP1360: Per-turn TTFT tracking
+    this.turnTtftLogged = false;
+    // EP1360: tool_use_id dedup (#20583 — Claude Code can emit duplicate tool_use IDs)
+    this.seenToolUseIds = /* @__PURE__ */ new Set();
+    // Timers
+    this.echoTimer = null;
+    this.inactivityTimer = null;
+    this.turnStartTime = 0;
+    this.sawAnyStdoutThisTurn = false;
+    // EP1360: Instrumentation
+    this.spawnTimestamp = 0;
+    this.sessionId = options.sessionId;
+  }
+  // -------------------------------------------------------------------------
+  // Public interface
+  // -------------------------------------------------------------------------
+  get turnState() {
+    return this._turnState;
+  }
+  get agentSessionId() {
+    return this._agentSessionId;
+  }
+  get pid() {
+    return this._pid;
+  }
+  /**
+   * Spawn the persistent CLI process.
+   * Must be called once before sendMessage(). Separated from constructor
+   * because spawn is synchronous but we need to set up handlers.
+   */
+  spawn() {
+    if (this.process) {
+      throw new Error(`[ClaudePersistentRuntime] Process already spawned for session ${this.sessionId}`);
+    }
+    const { binaryPath, args, env, cwd } = this.options;
+    this.spawnTimestamp = Date.now();
+    const spawnRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+    console.log(`[ClaudePersistentRuntime] Spawning persistent Claude process for session ${this.sessionId}, RSS=${spawnRssMb}MB`);
+    this.process = (0, import_child_process12.spawn)(binaryPath, args, {
+      cwd,
+      env,
+      // CLAUDE_CODE_DISABLE_PLUGIN_CACHE=1 is set by agent-manager in envVars
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this._pid = this.process.pid;
+    this.alive = true;
+    this.process.stderr?.on("data", (data) => {
+      const chunk = data.toString();
+      this.stderrTail = (this.stderrTail + chunk).slice(-this.maxStderrTailBytes);
+      if (RUNTIME_DEBUG) {
+        console.error(`[ClaudePersistentRuntime] stderr (session=${this.sessionId}): ${chunk.trimEnd()}`);
+      }
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.resetInactivityTimer();
+      this.stdoutBuffer += data.toString();
+      const lines = this.stdoutBuffer.split("\n");
+      this.stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          this.parsedLineCount++;
+          if (this.parsedLineCount === 1) {
+            const ttftMs = Date.now() - this.spawnTimestamp;
+            console.log(`[ClaudePersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
+          }
+          this.handleParsedEvent(parsed);
+        } catch {
+          if (line.trim() && this.callbacks) {
+            this.callbacks.onChunk(line + "\n");
+          }
+        }
+      }
+    });
+    this.process.on("exit", (code, signal) => {
+      const exitRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+      console.log(`[ClaudePersistentRuntime] Process exited: code=${code}, signal=${signal}, parsedLines=${this.parsedLineCount}, session=${this.sessionId}, RSS=${exitRssMb}MB`);
+      this.alive = false;
+      this.process = null;
+      if (this._turnState !== "idle" && this.callbacks) {
+        const msg = signal ? `Claude process killed by ${signal}` : `Claude process exited with code ${code}`;
+        if (this.stderrTail.trim()) {
+          console.error(`[ClaudePersistentRuntime] stderr tail (session=${this.sessionId}): ${this.stderrTail.trimEnd()}`);
+        }
+        this.callbacks.onError(`PROCESS_EXIT: ${msg}`);
+        this.endTurn();
+      }
+    });
+    this.process.on("error", (error) => {
+      console.error(`[ClaudePersistentRuntime] Spawn error: ${error.message}, session=${this.sessionId}`);
+      this.alive = false;
+      if (this.callbacks) {
+        this.callbacks.onError(`SPAWN_ERROR: ${error.message}`);
+        this.endTurn();
+      }
+    });
+  }
+  async sendMessage(message, callbacks) {
+    if (this._turnState !== "idle") {
+      throw new Error(
+        `[ClaudePersistentRuntime] Cannot send message: turn state is '${this._turnState}', expected 'idle'. Turn serialization requires the previous turn to complete before sending a new message. session=${this.sessionId}`
+      );
+    }
+    if (!this.alive || !this.process?.stdin) {
+      throw new Error(
+        `[ClaudePersistentRuntime] Cannot send message: process is not alive. session=${this.sessionId}`
+      );
+    }
+    this.callbacks = callbacks;
+    this.resultModel = void 0;
+    this.resultCostUsd = void 0;
+    this.resultUsage = void 0;
+    this.resultNumTurns = void 0;
+    this.turnStartTime = Date.now();
+    this.turnTtftLogged = false;
+    this.seenToolUseIds.clear();
+    this.sawAnyStdoutThisTurn = false;
+    this._turnState = "waiting_for_echo";
+    const payload = JSON.stringify({ type: "user", message: { role: "user", content: message } }) + "\n";
+    try {
+      await this.writeToStdin(payload);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.callbacks.onError(`SYNC_RUNTIME_ERROR: stdin write failed: ${msg}`);
+      this.endTurn();
+      throw err;
+    }
+    this.echoTimer = setTimeout(() => {
+      if (this._turnState === "waiting_for_echo") {
+        console.warn(`[ClaudePersistentRuntime] Echo timeout after ${ECHO_TIMEOUT_MS}ms \u2014 auto-degrading. session=${this.sessionId}`);
+        if (this.callbacks) {
+          this.callbacks.onError(`ECHO_TIMEOUT: No stdout event within ${ECHO_TIMEOUT_MS}ms after send`);
+          this.endTurn();
+        }
+      }
+    }, ECHO_TIMEOUT_MS);
+    this.resetInactivityTimer();
+  }
+  isAlive() {
+    return this.alive && !this.stuck;
+  }
+  async shutdown() {
+    this.clearTimers();
+    if (!this.process || !this.alive) {
+      return;
+    }
+    console.log(`[ClaudePersistentRuntime] Shutting down session ${this.sessionId} (3-stage)`);
+    try {
+      this.process.stdin?.end();
+    } catch {
+    }
+    const exited = await this.waitForExit(SHUTDOWN_SIGTERM_WAIT_MS);
+    if (exited) return;
+    console.log(`[ClaudePersistentRuntime] SIGTERM for session ${this.sessionId}`);
+    try {
+      this.process.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const exitedAfterTerm = await this.waitForExit(SHUTDOWN_SIGKILL_WAIT_MS);
+    if (exitedAfterTerm) return;
+    console.log(`[ClaudePersistentRuntime] SIGKILL for session ${this.sessionId}`);
+    try {
+      this.process.kill("SIGKILL");
+    } catch {
+      return;
+    }
+    const exitedAfterKill = await this.waitForExit(2e3);
+    if (!exitedAfterKill) {
+      console.error(`[ClaudePersistentRuntime] Process did not exit after SIGKILL \u2014 marking as stuck. session=${this.sessionId}`);
+      this.stuck = true;
+      this.alive = false;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Event handling
+  // -------------------------------------------------------------------------
+  handleParsedEvent(parsed) {
+    const type = parsed.type;
+    if (this._turnState === "waiting_for_echo") {
+      this.sawAnyStdoutThisTurn = true;
+      this.clearEchoTimer();
+      this._turnState = "streaming";
+      if (RUNTIME_DEBUG) {
+        console.log(`[ClaudePersistentRuntime] First stdout for turn \u2014 streaming started. session=${this.sessionId}`);
+      }
+    }
+    if (type === "user") {
+      return;
+    }
+    if (!this.callbacks) return;
+    switch (type) {
+      case "stream_event": {
+        const ev = parsed.event;
+        const evType = ev?.type;
+        if (!evType) break;
+        if (evType === "content_block_delta") {
+          const delta = ev?.delta;
+          const text = delta?.text ?? "";
+          if (text) {
+            this.chunksSent++;
+            if (!this.turnTtftLogged) {
+              this.turnTtftLogged = true;
+              const turnTtft = Date.now() - this.turnStartTime;
+              console.log(`[ClaudePersistentRuntime] EP1360: Turn TTFT: ${turnTtft}ms, session=${this.sessionId}`);
+            }
+            this.callbacks.onChunk(text);
+          }
+        }
+        if (evType === "content_block_start" && this.callbacks.onToolUse) {
+          const block = ev?.content_block;
+          if (block?.type === "tool_use") {
+            const toolId = block.id;
+            if (toolId && this.seenToolUseIds.has(toolId)) break;
+            if (toolId) this.seenToolUseIds.add(toolId);
+            const toolEvent = {
+              id: toolId || `tool-${Date.now()}`,
+              name: block.name,
+              input: block.input || {}
+            };
+            this.callbacks.onToolUse(toolEvent);
+          }
+        }
+        break;
+      }
+      case "assistant": {
+        const content = parsed.message?.content;
+        if (content) {
+          const shouldEmitText = this.chunksSent === 0;
+          if (shouldEmitText && this.hasContent) {
+            this.callbacks.onChunk("\n\n");
+          }
+          for (const block of content) {
+            if (block.type === "text" && block.text && shouldEmitText) {
+              this.hasContent = true;
+              this.chunksSent++;
+              if (!this.turnTtftLogged) {
+                this.turnTtftLogged = true;
+                const turnTtft = Date.now() - this.turnStartTime;
+                console.log(`[ClaudePersistentRuntime] EP1360: Turn TTFT: ${turnTtft}ms, session=${this.sessionId}`);
+              }
+              this.callbacks.onChunk(block.text);
+            } else if (block.type === "tool_use" && this.callbacks.onToolUse) {
+              const toolId = block.id;
+              if (toolId && this.seenToolUseIds.has(toolId)) {
+                continue;
+              }
+              if (toolId) {
+                this.seenToolUseIds.add(toolId);
+              }
+              const toolEvent = {
+                id: toolId,
+                name: block.name,
+                input: block.input || {}
+              };
+              this.callbacks.onToolUse(toolEvent);
+            } else if (block.type === "tool_result" && this.callbacks.onToolResult) {
+              const toolResult = {
+                id: block.tool_use_id || block.id || `tool-result-${Date.now()}`,
+                name: block.name,
+                output: block.output ?? block.result ?? block.content ?? block
+              };
+              this.callbacks.onToolResult(toolResult);
+            }
+          }
+        }
+        break;
+      }
+      case "content_block_delta": {
+        const delta = parsed.delta;
+        if (delta?.text) {
+          this.chunksSent++;
+          if (!this.turnTtftLogged) {
+            this.turnTtftLogged = true;
+            const turnTtft = Date.now() - this.turnStartTime;
+            console.log(`[ClaudePersistentRuntime] EP1360: Turn TTFT: ${turnTtft}ms, session=${this.sessionId}`);
+          }
+          this.callbacks.onChunk(delta.text);
+        }
+        break;
+      }
+      case "tool_result": {
+        if (this.callbacks.onToolResult) {
+          const toolResult = {
+            id: parsed.tool_use_id || parsed.toolUseId || parsed.id || `tool-result-${Date.now()}`,
+            name: parsed.name || parsed.tool_name,
+            output: parsed.output ?? parsed.result ?? parsed.content ?? parsed.message ?? parsed
+          };
+          this.callbacks.onToolResult(toolResult);
+        }
+        break;
+      }
+      case "result": {
+        if (parsed.session_id) {
+          this._agentSessionId = parsed.session_id;
+        }
+        const resultObj = parsed.result;
+        if (resultObj?.session_id) {
+          this._agentSessionId = resultObj.session_id;
+        }
+        this.resultModel = parsed.model;
+        if (typeof parsed.total_cost_usd === "number") {
+          this.resultCostUsd = parsed.total_cost_usd;
+        } else if (typeof parsed.cost_usd === "number") {
+          this.resultCostUsd = parsed.cost_usd;
+        }
+        this.resultNumTurns = typeof parsed.num_turns === "number" ? parsed.num_turns : void 0;
+        if (parsed.usage) {
+          const u = parsed.usage;
+          const inputTokens = u.input_tokens ?? u.prompt_tokens ?? 0;
+          const outputTokens = u.output_tokens ?? u.completion_tokens ?? 0;
+          this.resultUsage = {
+            inputTokens,
+            outputTokens,
+            cacheReadTokens: u.cache_read_input_tokens ?? u.cache_read_tokens,
+            cacheWriteTokens: u.cache_creation_input_tokens ?? u.cache_write_tokens,
+            totalTokens: inputTokens + outputTokens
+          };
+        }
+        this.completeTurn();
+        break;
+      }
+      case "system": {
+        if (parsed.session_id) {
+          this._agentSessionId = parsed.session_id;
+        }
+        if (parsed.subtype === "compact_boundary" && this.callbacks.onCompaction) {
+          const metadata = parsed.compactMetadata;
+          const compactionEvent = {
+            seq: this.parsedLineCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            provider: "claude",
+            type: "session.compaction",
+            raw: parsed,
+            trigger: metadata?.trigger ?? "auto",
+            preCompactionTokens: metadata?.preCompactTokenCount
+          };
+          console.log(`[ClaudePersistentRuntime] Compaction detected \u2014 trigger: ${compactionEvent.trigger}, session=${this.sessionId}`);
+          this.callbacks.onCompaction(compactionEvent);
+        }
+        break;
+      }
+      case "error": {
+        const errorMsg = parsed.error?.message || parsed.message || "Unknown error from Claude Code";
+        this.callbacks.onError(errorMsg);
+        this.endTurn();
+        break;
+      }
+      default:
+        if (type) {
+          console.log(`[ClaudePersistentRuntime] Unhandled event: ${type}, session=${this.sessionId}`);
+        }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Turn lifecycle
+  // -------------------------------------------------------------------------
+  completeTurn() {
+    if (!this.callbacks) return;
+    const durationMs = Date.now() - this.turnStartTime;
+    const resultMeta = this.resultModel || this.resultCostUsd !== void 0 || this.resultUsage ? {
+      model: this.resultModel,
+      costUsd: this.resultCostUsd,
+      durationMs,
+      numTurns: this.resultNumTurns,
+      usage: this.resultUsage
+    } : void 0;
+    console.log(`[ClaudePersistentRuntime] Turn completed: duration=${durationMs}ms, chunks=${this.chunksSent}, session=${this.sessionId}`);
+    const cb = this.callbacks;
+    this.endTurn();
+    cb.onComplete(this._agentSessionId, resultMeta);
+  }
+  endTurn() {
+    this.clearTimers();
+    this.callbacks = null;
+    this._turnState = "idle";
+    this.chunksSent = 0;
+  }
+  // -------------------------------------------------------------------------
+  // stdin
+  // -------------------------------------------------------------------------
+  writeToStdin(data) {
+    if (!this.process?.stdin || this.process.stdin.destroyed) {
+      throw new Error(`[ClaudePersistentRuntime] stdin not available. session=${this.sessionId}`);
+    }
+    return new Promise((resolve4, reject) => {
+      const stdin = this.process.stdin;
+      const ok = stdin.write(data);
+      if (ok) {
+        resolve4();
+        return;
+      }
+      const onDrain = () => {
+        cleanup();
+        resolve4();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const onTimeout = () => {
+        cleanup();
+        reject(new Error(`STDIN_DRAIN_TIMEOUT after ${STDIN_DRAIN_TIMEOUT_MS}ms`));
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        stdin.off("drain", onDrain);
+        stdin.off("error", onError);
+      };
+      const timer = setTimeout(onTimeout, STDIN_DRAIN_TIMEOUT_MS);
+      stdin.once("drain", onDrain);
+      stdin.once("error", onError);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Timers
+  // -------------------------------------------------------------------------
+  clearEchoTimer() {
+    if (this.echoTimer) {
+      clearTimeout(this.echoTimer);
+      this.echoTimer = null;
+    }
+  }
+  resetInactivityTimer() {
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+    }
+    if (this._turnState === "idle") return;
+    this.inactivityTimer = setTimeout(() => {
+      if (this._turnState !== "idle") {
+        console.warn(`[ClaudePersistentRuntime] Inactivity timeout (${INACTIVITY_TIMEOUT_MS}ms) \u2014 no stdout during streaming. session=${this.sessionId}`);
+        if (this.callbacks) {
+          this.callbacks.onError(`INACTIVITY_TIMEOUT: No stdout for ${INACTIVITY_TIMEOUT_MS}ms during streaming`);
+          this.endTurn();
+        }
+      }
+    }, INACTIVITY_TIMEOUT_MS);
+  }
+  clearTimers() {
+    this.clearEchoTimer();
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+      this.inactivityTimer = null;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  waitForExit(timeoutMs) {
+    return new Promise((resolve4) => {
+      if (!this.process || !this.alive) {
+        resolve4(true);
+        return;
+      }
+      const onExit = () => {
+        clearTimeout(timer);
+        resolve4(true);
+      };
+      const timer = setTimeout(() => {
+        this.process?.removeListener("exit", onExit);
+        resolve4(false);
+      }, timeoutMs);
+      this.process.once("exit", onExit);
+    });
+  }
+};
+
+// src/agent/codex-persistent-runtime.ts
+var import_child_process13 = require("child_process");
+var INIT_TIMEOUT_MS = 3e4;
+var INACTIVITY_TIMEOUT_MS2 = parseInt(process.env.AGENT_STREAM_INACTIVITY_TIMEOUT_MS || "180000", 10);
+var SHUTDOWN_SIGTERM_WAIT_MS2 = 2e3;
+var SHUTDOWN_SIGKILL_WAIT_MS2 = 2e3;
+var STDIN_DRAIN_TIMEOUT_MS2 = 1e4;
+var RUNTIME_DEBUG2 = process.env.AGENT_RUNTIME_DEBUG === "1";
+var CodexPersistentRuntime = class {
+  constructor(options) {
+    this.options = options;
+    this.provider = "codex";
+    this.process = null;
+    this._turnState = "idle";
+    this.alive = false;
+    this.stuck = false;
+    this.callbacks = null;
+    // Keep a small stderr tail so we can print it on failure without spamming logs.
+    this.stderrTail = "";
+    this.maxStderrTailBytes = 8192;
+    this.stdoutBuffer = "";
+    this.parsedLineCount = 0;
+    // Per-turn accounting
+    this.turnStartTime = 0;
+    this.chunksSent = 0;
+    this.turnTtftLogged = false;
+    // Timers
+    this.inactivityTimer = null;
+    // Spawn instrumentation
+    this.spawnTimestamp = 0;
+    // JSON-RPC state
+    this.nextId = 1;
+    this.pending = /* @__PURE__ */ new Map();
+    this.initializing = null;
+    this.initialized = false;
+    this.threadIdWaiters = [];
+    this.debugTraceCount = 0;
+    this.sessionId = options.sessionId;
+  }
+  get turnState() {
+    return this._turnState;
+  }
+  get agentSessionId() {
+    return this._agentSessionId;
+  }
+  get pid() {
+    return this._pid;
+  }
+  spawn() {
+    if (this.process) {
+      throw new Error(`[CodexPersistentRuntime] Process already spawned for session ${this.sessionId}`);
+    }
+    const { binaryPath, args, env, cwd } = this.options;
+    this.spawnTimestamp = Date.now();
+    const spawnRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+    console.log(`[CodexPersistentRuntime] Spawning persistent Codex app-server for session ${this.sessionId}, RSS=${spawnRssMb}MB`);
+    this.process = (0, import_child_process13.spawn)(binaryPath, args, {
+      cwd,
+      env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this._pid = this.process.pid;
+    this.alive = true;
+    this.process.stderr?.on("data", (data) => {
+      const chunk = data.toString();
+      this.stderrTail = (this.stderrTail + chunk).slice(-this.maxStderrTailBytes);
+      if (RUNTIME_DEBUG2) {
+        console.error(`[CodexPersistentRuntime] stderr (session=${this.sessionId}): ${chunk.trimEnd()}`);
+      }
+    });
+    this.process.stdout?.on("data", (data) => {
+      this.resetInactivityTimer();
+      this.stdoutBuffer += data.toString();
+      const lines = this.stdoutBuffer.split("\n");
+      this.stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          this.parsedLineCount++;
+          if (this.parsedLineCount === 1) {
+            const ttftMs = Date.now() - this.spawnTimestamp;
+            console.log(`[CodexPersistentRuntime] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, session=${this.sessionId}`);
+          }
+          this.handleJsonRpcMessage(parsed);
+        } catch {
+          if (line.trim() && this.callbacks) {
+            this.callbacks.onChunk(line + "\n");
+          }
+        }
+      }
+    });
+    this.process.on("exit", (code, signal) => {
+      const exitRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+      console.log(`[CodexPersistentRuntime] Process exited: code=${code}, signal=${signal}, parsedLines=${this.parsedLineCount}, session=${this.sessionId}, RSS=${exitRssMb}MB`);
+      this.alive = false;
+      this.process = null;
+      for (const [id, p] of this.pending) {
+        clearTimeout(p.timeout);
+        p.reject(new Error(`Codex app-server exited (id=${id})`));
+      }
+      this.pending.clear();
+      if (this._turnState !== "idle" && this.callbacks) {
+        const msg = signal ? `Codex process killed by ${signal}` : `Codex process exited with code ${code}`;
+        if (this.stderrTail.trim()) {
+          console.error(`[CodexPersistentRuntime] stderr tail (session=${this.sessionId}): ${this.stderrTail.trimEnd()}`);
+        }
+        this.callbacks.onError(`PROCESS_EXIT: ${msg}`);
+        this.endTurn();
+      }
+    });
+    this.process.on("error", (error) => {
+      console.error(`[CodexPersistentRuntime] Spawn error: ${error.message}, session=${this.sessionId}`);
+      this.alive = false;
+      for (const [id, p] of this.pending) {
+        clearTimeout(p.timeout);
+        p.reject(error);
+      }
+      this.pending.clear();
+      if (this.callbacks) {
+        this.callbacks.onError(`SPAWN_ERROR: ${error.message}`);
+        this.endTurn();
+      }
+    });
+  }
+  async sendMessage(message, callbacks) {
+    if (this._turnState !== "idle") {
+      throw new Error(
+        `[CodexPersistentRuntime] Cannot send message: turn state is '${this._turnState}', expected 'idle'. session=${this.sessionId}`
+      );
+    }
+    if (!this.alive || !this.process?.stdin) {
+      throw new Error(`[CodexPersistentRuntime] Cannot send message: process is not alive. session=${this.sessionId}`);
+    }
+    this.callbacks = callbacks;
+    this.turnStartTime = Date.now();
+    this.chunksSent = 0;
+    this.turnTtftLogged = false;
+    this.resultModel = void 0;
+    this.resultUsage = void 0;
+    this.resultNumTurns = void 0;
+    this._turnState = "streaming";
+    void (async () => {
+      try {
+        await this.ensureInitialized();
+        const threadId = this._agentSessionId;
+        if (!threadId) {
+          throw new Error("Missing threadId after initialization");
+        }
+        await this.sendRequest("turn/start", {
+          threadId,
+          input: [{ type: "text", text: message }]
+        }, INIT_TIMEOUT_MS);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (this.callbacks) {
+          this.callbacks.onError(`SYNC_RUNTIME_ERROR: ${msg}`);
+          this.endTurn();
+        }
+      }
+    })();
+    this.resetInactivityTimer();
+  }
+  isAlive() {
+    return this.alive && !this.stuck;
+  }
+  async shutdown() {
+    this.clearTimers();
+    if (!this.process || !this.alive) return;
+    console.log(`[CodexPersistentRuntime] Shutting down session ${this.sessionId} (3-stage)`);
+    try {
+      this.process.stdin?.end();
+    } catch {
+    }
+    const exited = await this.waitForExit(SHUTDOWN_SIGTERM_WAIT_MS2);
+    if (exited) return;
+    console.log(`[CodexPersistentRuntime] SIGTERM for session ${this.sessionId}`);
+    try {
+      this.process.kill("SIGTERM");
+    } catch {
+      return;
+    }
+    const exitedAfterTerm = await this.waitForExit(SHUTDOWN_SIGKILL_WAIT_MS2);
+    if (exitedAfterTerm) return;
+    console.log(`[CodexPersistentRuntime] SIGKILL for session ${this.sessionId}`);
+    try {
+      this.process.kill("SIGKILL");
+    } catch {
+      return;
+    }
+    const exitedAfterKill = await this.waitForExit(2e3);
+    if (!exitedAfterKill) {
+      console.error(`[CodexPersistentRuntime] Process did not exit after SIGKILL \u2014 marking as stuck. session=${this.sessionId}`);
+      this.stuck = true;
+      this.alive = false;
+    }
+  }
+  // -------------------------------------------------------------------------
+  // JSON-RPC plumbing
+  // -------------------------------------------------------------------------
+  handleJsonRpcMessage(msg) {
+    if (RUNTIME_DEBUG2 && this.debugTraceCount < 20) {
+      this.debugTraceCount++;
+      const kind = typeof msg.id === "number" ? "response" : typeof msg.method === "string" ? `notif:${msg.method}` : "unknown";
+      console.log(`[CodexPersistentRuntime] debug json-rpc (${kind}) session=${this.sessionId}: ${JSON.stringify(msg).slice(0, 2e3)}`);
+    }
+    const isResponse = typeof msg.id === "number" && (msg.result !== void 0 || msg.error !== void 0);
+    if (isResponse) {
+      const id = msg.id;
+      const pending = this.pending.get(id);
+      if (!pending) return;
+      clearTimeout(pending.timeout);
+      this.pending.delete(id);
+      if (msg.error) {
+        const e = msg.error;
+        pending.reject(new Error(e?.message || "JSON-RPC error"));
+      } else {
+        pending.resolve(msg.result);
+      }
+      return;
+    }
+    const method = msg.method;
+    if (!method) return;
+    if (method === "thread/started" || method === "thread.started") {
+      const params2 = msg.params ?? {};
+      const threadId = this.extractThreadId(params2);
+      if (threadId) {
+        this.setThreadId(threadId, "notification");
+        console.log(`[CodexPersistentRuntime] Thread started: ${threadId}, session=${this.sessionId}`);
+      }
+      return;
+    }
+    if (!this.callbacks) return;
+    const params = msg.params ?? {};
+    switch (method) {
+      case "item/agentMessage/delta":
+      case "item.agentMessage.delta": {
+        const delta = params.delta || params.text || "";
+        if (delta) {
+          this.chunksSent++;
+          if (!this.turnTtftLogged) {
+            this.turnTtftLogged = true;
+            const turnTtft = Date.now() - this.turnStartTime;
+            console.log(`[CodexPersistentRuntime] EP1360: Turn TTFT: ${turnTtft}ms, session=${this.sessionId}`);
+          }
+          this.callbacks.onChunk(delta);
+        }
+        break;
+      }
+      case "item/started":
+      case "item.started": {
+        const item = params.item;
+        if (!item) break;
+        if (item.type === "command_execution" && this.callbacks.onToolUse) {
+          const toolEvent = {
+            id: item.id || `codex-cmd-${Date.now()}`,
+            name: "Bash",
+            input: { command: item.command || item.input || "" }
+          };
+          this.callbacks.onToolUse(toolEvent);
+        }
+        break;
+      }
+      case "item/completed":
+      case "item.completed": {
+        const item = params.item;
+        if (!item) break;
+        if (item.type === "agent_message" && item.text) {
+          this.chunksSent++;
+          if (!this.turnTtftLogged) {
+            this.turnTtftLogged = true;
+            const turnTtft = Date.now() - this.turnStartTime;
+            console.log(`[CodexPersistentRuntime] EP1360: Turn TTFT: ${turnTtft}ms, session=${this.sessionId}`);
+          }
+          this.callbacks.onChunk(item.text);
+        }
+        if (item.type === "command_execution" && this.callbacks.onToolResult) {
+          const toolResult = {
+            id: item.id || `codex-cmd-${Date.now()}`,
+            name: "Bash",
+            output: item.output ?? item.result ?? item
+          };
+          this.callbacks.onToolResult(toolResult);
+        }
+        if (item.type === "contextCompaction" && this.callbacks.onCompaction) {
+          const compactionEvent = {
+            seq: this.parsedLineCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            provider: "codex",
+            type: "session.compaction",
+            raw: msg,
+            trigger: "auto",
+            summary: item.summary
+          };
+          this.callbacks.onCompaction(compactionEvent);
+        }
+        break;
+      }
+      case "turn/completed":
+      case "turn.completed": {
+        const usage = params.usage;
+        if (usage) {
+          const inputTokens = usage.input_tokens ?? usage.prompt_tokens ?? 0;
+          const outputTokens = usage.output_tokens ?? usage.completion_tokens ?? 0;
+          this.resultUsage = { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+        }
+        this.resultModel = params.model ?? this.resultModel;
+        this.resultNumTurns = typeof params.num_turns === "number" ? params.num_turns : this.resultNumTurns;
+        this.completeTurn();
+        break;
+      }
+      case "turn/failed":
+      case "turn.failed":
+      case "error": {
+        const errMsg = params.message || params.error?.message || "Codex operation failed";
+        this.callbacks.onError(errMsg);
+        this.endTurn();
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initializing) return this.initializing;
+    this.initializing = (async () => {
+      await this.sendRequest("initialize", {
+        clientInfo: { name: "episoda", version: "1.0" }
+      }, INIT_TIMEOUT_MS);
+      await this.sendNotification("initialized", {});
+      const resumeThreadId = this.options.resumeThreadId;
+      const model = this.options.model;
+      if (resumeThreadId) {
+        const resumeMethods = ["thread/resume", "thread.resume"];
+        let resumed = false;
+        for (const method of resumeMethods) {
+          try {
+            const res = await this.sendRequest(method, { threadId: resumeThreadId }, INIT_TIMEOUT_MS);
+            const threadId = this.extractThreadId(res) || resumeThreadId;
+            if (threadId) {
+              this.setThreadId(threadId, `response:${method}`);
+              console.log(`[CodexPersistentRuntime] Thread resumed (${method}): ${threadId}, session=${this.sessionId}`);
+              resumed = true;
+              break;
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[CodexPersistentRuntime] Thread resume failed (${method}): ${msg}, session=${this.sessionId}`);
+          }
+        }
+        if (!resumed) {
+          console.warn(`[CodexPersistentRuntime] Falling back to thread/start (resume unsupported or failed). session=${this.sessionId}`);
+        }
+      }
+      if (!this._agentSessionId) {
+        const startMethods = ["thread/start", "thread.start"];
+        let started = false;
+        for (const method of startMethods) {
+          try {
+            const res = await this.sendRequest(method, model ? { model } : {}, INIT_TIMEOUT_MS);
+            const threadId = this.extractThreadId(res);
+            if (threadId) {
+              this.setThreadId(threadId, `response:${method}`);
+              console.log(`[CodexPersistentRuntime] Thread started (response): ${threadId}, session=${this.sessionId}`);
+            }
+            started = true;
+            break;
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.warn(`[CodexPersistentRuntime] Thread start failed (${method}): ${msg}, session=${this.sessionId}`);
+          }
+        }
+        if (!started) {
+          throw new Error("Failed to start thread (no supported method)");
+        }
+      }
+      await this.waitForThreadId(1e4);
+      this.initialized = true;
+    })().finally(() => {
+      this.initializing = null;
+    });
+    return this.initializing;
+  }
+  setThreadId(threadId, source) {
+    if (!threadId) return;
+    if (this._agentSessionId && this._agentSessionId !== threadId) {
+      console.warn(
+        `[CodexPersistentRuntime] ThreadId changed (${source}): ${this._agentSessionId} -> ${threadId}, session=${this.sessionId}`
+      );
+    }
+    this._agentSessionId = threadId;
+    if (this.threadIdWaiters.length) {
+      const waiters = this.threadIdWaiters;
+      this.threadIdWaiters = [];
+      for (const w of waiters) {
+        try {
+          w(threadId);
+        } catch {
+        }
+      }
+    }
+  }
+  waitForThreadId(timeoutMs) {
+    if (this._agentSessionId) return Promise.resolve(this._agentSessionId);
+    return new Promise((resolve4, reject) => {
+      const onId = (id) => {
+        clearTimeout(timer);
+        resolve4(id);
+      };
+      const timer = setTimeout(() => {
+        this.threadIdWaiters = this.threadIdWaiters.filter((w) => w !== onId);
+        reject(new Error(`Timeout waiting for threadId after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.threadIdWaiters.push(onId);
+    });
+  }
+  extractThreadId(obj) {
+    if (!obj || typeof obj !== "object") return void 0;
+    const rec = obj;
+    const direct = rec.threadId ?? rec.thread_id ?? rec.id;
+    if (typeof direct === "string" && direct.trim()) return direct;
+    const thread = rec.thread;
+    if (thread && typeof thread === "object") {
+      const t = thread;
+      const nested = t.id ?? t.threadId ?? t.thread_id;
+      if (typeof nested === "string" && nested.trim()) return nested;
+    }
+    const result = rec.result;
+    if (result && typeof result === "object") return this.extractThreadId(result);
+    return void 0;
+  }
+  async sendNotification(method, params) {
+    const msg = { jsonrpc: "2.0", method, params };
+    await this.writeToStdin(JSON.stringify(msg) + "\n");
+  }
+  sendRequest(method, params, timeoutMs = INIT_TIMEOUT_MS) {
+    const id = this.nextId++;
+    const msg = { jsonrpc: "2.0", id, method, params };
+    return new Promise(async (resolve4, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`JSON-RPC timeout: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve: resolve4, reject, timeout });
+      try {
+        await this.writeToStdin(JSON.stringify(msg) + "\n");
+      } catch (err) {
+        clearTimeout(timeout);
+        this.pending.delete(id);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  writeToStdin(data) {
+    if (!this.process?.stdin || this.process.stdin.destroyed) {
+      throw new Error(`[CodexPersistentRuntime] stdin not available. session=${this.sessionId}`);
+    }
+    return new Promise((resolve4, reject) => {
+      const stdin = this.process.stdin;
+      const ok = stdin.write(data);
+      if (ok) {
+        resolve4();
+        return;
+      }
+      const onDrain = () => {
+        cleanup();
+        resolve4();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const onTimeout = () => {
+        cleanup();
+        reject(new Error(`STDIN_DRAIN_TIMEOUT after ${STDIN_DRAIN_TIMEOUT_MS2}ms`));
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        stdin.off("drain", onDrain);
+        stdin.off("error", onError);
+      };
+      const timer = setTimeout(onTimeout, STDIN_DRAIN_TIMEOUT_MS2);
+      stdin.once("drain", onDrain);
+      stdin.once("error", onError);
+    });
+  }
+  // -------------------------------------------------------------------------
+  // Turn lifecycle
+  // -------------------------------------------------------------------------
+  completeTurn() {
+    if (!this.callbacks) return;
+    const durationMs = Date.now() - this.turnStartTime;
+    const resultMeta = this.resultModel || this.resultUsage ? {
+      model: this.resultModel,
+      durationMs,
+      numTurns: this.resultNumTurns,
+      usage: this.resultUsage
+    } : void 0;
+    console.log(`[CodexPersistentRuntime] Turn completed: duration=${durationMs}ms, chunks=${this.chunksSent}, session=${this.sessionId}`);
+    const cb = this.callbacks;
+    this.endTurn();
+    cb.onComplete(this._agentSessionId, resultMeta);
+  }
+  endTurn() {
+    this.clearTimers();
+    this.callbacks = null;
+    this._turnState = "idle";
+    this.chunksSent = 0;
+  }
+  // -------------------------------------------------------------------------
+  // Timers
+  // -------------------------------------------------------------------------
+  resetInactivityTimer() {
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+    }
+    if (this._turnState === "idle") return;
+    this.inactivityTimer = setTimeout(() => {
+      if (this._turnState !== "idle") {
+        console.warn(`[CodexPersistentRuntime] Inactivity timeout (${INACTIVITY_TIMEOUT_MS2}ms). session=${this.sessionId}`);
+        if (this.callbacks) {
+          this.callbacks.onError(`INACTIVITY_TIMEOUT: No stdout for ${INACTIVITY_TIMEOUT_MS2}ms during streaming`);
+          this.endTurn();
+        }
+      }
+    }, INACTIVITY_TIMEOUT_MS2);
+  }
+  clearTimers() {
+    if (this.inactivityTimer) {
+      clearTimeout(this.inactivityTimer);
+      this.inactivityTimer = null;
+    }
+  }
+  waitForExit(timeoutMs) {
+    return new Promise((resolve4) => {
+      if (!this.process || !this.alive) {
+        resolve4(true);
+        return;
+      }
+      const onExit = () => {
+        clearTimeout(timer);
+        resolve4(true);
+      };
+      const timer = setTimeout(() => {
+        this.process?.removeListener("exit", onExit);
+        resolve4(false);
+      }, timeoutMs);
+      this.process.once("exit", onExit);
+    });
+  }
+};
+
+// src/agent/agent-manager.ts
 var instance3 = null;
 function getAgentManager() {
   if (!instance3) {
@@ -8849,6 +9900,11 @@ function getAgentManager() {
   }
   return instance3;
 }
+var AGENT_DISABLE_PERSISTENT = process.env.AGENT_DISABLE_PERSISTENT === "1";
+var AGENT_MAX_PERSISTENT = parseInt(process.env.AGENT_MAX_PERSISTENT || "5", 10);
+var AGENT_IDLE_TIMEOUT_MS = parseInt(process.env.AGENT_IDLE_TIMEOUT_MS || "300000", 10);
+var IDLE_SCAN_INTERVAL_MS = 6e4;
+var CLAUDE_PERSISTENT_BLOCKED_MODELS = ["haiku"];
 var AgentManager = class {
   constructor() {
     this.sessions = /* @__PURE__ */ new Map();
@@ -8856,8 +9912,41 @@ var AgentManager = class {
     this.initialized = false;
     // EP1133: Lock for config file writes to prevent race conditions
     this.configWriteLock = Promise.resolve();
+    // EP1360: Persistent runtime management
+    this.runtimes = /* @__PURE__ */ new Map();
+    // EP1360: Per-session downgrade. If a persistent runtime wedges/crashes for a session,
+    // we permanently fall back to spawn-per-message for the remainder of that session.
+    this.persistentDisabledSessions = /* @__PURE__ */ new Map();
+    this.idleScanTimer = null;
     this.pidDir = path20.join(os7.homedir(), ".episoda", "agent-pids");
   }
+  /**
+   * EP1360: Best-effort child process RSS sampling.
+   * Returns RSS in MB, or null if not available.
+   *
+   * NOTE: We intentionally avoid adding native deps here; `ps` is available
+   * on macOS/Linux. This instrumentation must never break message flow.
+   */
+  async getChildRssMb(pid) {
+    if (!pid || pid <= 0) return null;
+    try {
+      if (typeof import_child_process14.execFile !== "function") return null;
+      const stdout = await new Promise((resolve4, reject) => {
+        (0, import_child_process14.execFile)("ps", ["-o", "rss=", "-p", String(pid)], { timeout: 1e3 }, (err, out) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve4(String(out));
+        });
+      });
+      const kb = Number(String(stdout).trim());
+      if (!Number.isFinite(kb) || kb <= 0) return null;
+      return Math.round(kb / 1024 * 10) / 10;
+    } catch {
+      return null;
+    }
+  }
   /**
    * EP1133: Acquire lock for config file writes
    * Ensures sequential writes to prevent file corruption
@@ -9152,6 +10241,12 @@ var AgentManager = class {
     } catch (error) {
       console.warn("[AgentManager] Codex CLI not available:", error instanceof Error ? error.message : error);
     }
+    if (!AGENT_DISABLE_PERSISTENT) {
+      this.startIdleScanner();
+      console.log(`[AgentManager] EP1360: Persistent runtimes enabled (max=${AGENT_MAX_PERSISTENT}, idleTimeout=${AGENT_IDLE_TIMEOUT_MS}ms)`);
+    } else {
+      console.log("[AgentManager] EP1360: Persistent runtimes DISABLED (AGENT_DISABLE_PERSISTENT=1)");
+    }
     this.initialized = true;
     console.log("[AgentManager] Initialized");
   }
@@ -9276,7 +10371,8 @@ var AgentManager = class {
   /**
    * Send a message to an agent session
    *
-   * Spawns a new agent CLI process for each message.
+   * EP1360: Uses persistent runtimes when enabled/available; falls back to
+   * spawn-per-message for incident response, pool pressure, or per-session downgrade.
    * EP1133: Supports both Claude Code and Codex CLI with provider-specific handling.
    * EP1251: Supports credentials refresh for GitHub token on resume.
    */
@@ -9286,6 +10382,22 @@ var AgentManager = class {
     if (!session) {
       return { success: false, error: "Session not found" };
     }
+    const shouldDisablePersistentFromError = (error) => {
+      return error.startsWith("ECHO_TIMEOUT:") || error.startsWith("INACTIVITY_TIMEOUT:") || error.startsWith("PROCESS_EXIT:") || error.startsWith("SPAWN_ERROR:") || error.startsWith("SYNC_RUNTIME_ERROR:");
+    };
+    const wrapRuntimeOnComplete = (agentSid, resultMetadata) => {
+      if (agentSid) {
+        session.agentSessionId = agentSid;
+        session.claudeSessionId = agentSid;
+      }
+      onComplete(agentSid, resultMetadata);
+    };
+    const wrapRuntimeOnError = (error) => {
+      if (shouldDisablePersistentFromError(error)) {
+        this.disablePersistentForSession(sessionId, error);
+      }
+      onError(error);
+    };
     const mcpAuth = await this.resolveMcpAuth();
     if (mcpAuth.source === "config") {
       console.log("[AgentManager] EP1287: Using MCP token from ~/.episoda/config.json");
@@ -9298,6 +10410,78 @@ var AgentManager = class {
       session.canWrite = canWrite;
       session.readOnlyReason = readOnlyReason;
     }
+    if (!isFirstMessage) {
+      const runtime = this.getRuntime(sessionId);
+      if (runtime) {
+        try {
+          if (runtime.turnState !== "idle") {
+            const err = `TURN_IN_PROGRESS: Persistent runtime is busy (turnState=${runtime.turnState})`;
+            console.warn(`[AgentManager] EP1360: ${err}, session=${sessionId}`);
+            onError(err);
+            return { success: false, error: err };
+          }
+          let runtimeMessage = message;
+          if (session.canWrite === false) {
+            if (session.provider === "codex") {
+              const readOnlyReminder = `
+[SYSTEM REMINDER - READ-ONLY MODE]
+You are in READ-ONLY mode. Do NOT:
+- Create, modify, or delete any files
+- Run commands that write to the filesystem
+- Make git commits or changes
+Reason: ${session.readOnlyReason || "No write access to this module."}
+If changes are needed, explain what needs to be done but do not execute.
+[END SYSTEM REMINDER]
+
+`;
+              runtimeMessage = readOnlyReminder + runtimeMessage;
+            } else {
+              const readOnlyReminder = `
+REMINDER: You are in READ-ONLY mode. You cannot create, modify, or delete files.
+Reason: ${session.readOnlyReason || "No write access to this module."}
+If changes are needed, explain what needs to be done.`;
+              runtimeMessage = `${readOnlyReminder}
+
+${runtimeMessage}`;
+            }
+          }
+          const pid = runtime.pid;
+          void this.getChildRssMb(pid).then((rss) => {
+            if (rss !== null) {
+              console.log(`[AgentManager] EP1360: Persistent turn start RSS: ${rss}MB, provider=${session.provider}, session=${sessionId}, pid=${pid}`);
+            }
+          });
+          const onCompleteWithRss = (agentSid, resultMetadata) => {
+            void this.getChildRssMb(pid).then((rss) => {
+              if (rss !== null) {
+                console.log(`[AgentManager] EP1360: Persistent turn complete RSS: ${rss}MB, provider=${session.provider}, session=${sessionId}, pid=${pid}`);
+              }
+            });
+            wrapRuntimeOnComplete(agentSid, resultMetadata);
+          };
+          await runtime.sendMessage(runtimeMessage, {
+            onChunk,
+            onToolUse,
+            onToolResult,
+            onCompaction: options.onCompaction,
+            onComplete: onCompleteWithRss,
+            onError: wrapRuntimeOnError
+          });
+          console.log(`[AgentManager] EP1360: Sent follow-up message via persistent ${session.provider} runtime, session=${sessionId}`);
+          return { success: true };
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          if (msg.includes("turn state is '") || msg.startsWith("TURN_IN_PROGRESS:")) {
+            const err = `TURN_IN_PROGRESS: ${msg}`;
+            console.warn(`[AgentManager] EP1360: ${err}, session=${sessionId}`);
+            onError(err);
+            return { success: false, error: err };
+          }
+          console.warn(`[AgentManager] EP1360: Persistent runtime failed for follow-up, falling back to spawn-per-message: ${msg}`);
+          this.disablePersistentForSession(sessionId, `SYNC_RUNTIME_ERROR: ${msg}`);
+        }
+      }
+    }
     if (credentials?.githubToken) {
       session.credentials.githubToken = credentials.githubToken;
       session.credentials.githubTokenExpiresAt = credentials.githubTokenExpiresAt;
@@ -9345,6 +10529,8 @@ Violations will result in errors and may affect your ability to assist.
       }
       let binaryPath;
       let args;
+      let argsBeforeMessage = 0;
+      let runtimeFirstMessage = message;
       if (provider === "codex") {
         binaryPath = await ensureCodexBinary();
         args = [
@@ -9390,6 +10576,8 @@ If changes are needed, explain what needs to be done but do not execute.
 `;
           fullMessage = readOnlyReminder + fullMessage;
         }
+        argsBeforeMessage = args.length;
+        runtimeFirstMessage = fullMessage;
         args.push(fullMessage);
       } else {
         binaryPath = await ensureClaudeBinary();
@@ -9425,6 +10613,9 @@ Reason: ${session.readOnlyReason || "No write access to this module."}
 If changes are needed, explain what needs to be done.`;
             args.push("--append-system-prompt", readOnlyReminder);
             console.log("[AgentManager] EP1205: Appended read-only reminder to subsequent message");
+            runtimeFirstMessage = `${readOnlyReminder}
+
+${message}`;
           }
         }
         if (resumeSessionId) {
@@ -9481,6 +10672,7 @@ If changes are needed, explain what needs to be done.`;
           args.push("--mcp-config", mcpConfigJson);
           console.log(`[AgentManager] EP1253: MCP config with env: ${mcpConfigJson.substring(0, 200)}...`);
         }
+        argsBeforeMessage = args.length;
         args.push("--", message);
       }
       console.log(`[AgentManager] Spawning ${provider} CLI for session ${sessionId}`);
@@ -9725,7 +10917,95 @@ If changes are needed, explain what needs to be done.`;
           envVars.ANTHROPIC_API_KEY = session.credentials.apiKey;
         }
       }
-      const childProcess = (0, import_child_process12.spawn)(spawnCmd, spawnArgs, {
+      if (provider === "claude") {
+        envVars.CLAUDE_CODE_DISABLE_PLUGIN_CACHE = "1";
+      }
+      const daemonSpawnRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+      const spawnTimestamp = Date.now();
+      const modelLower = (session.credentials.preferredModel || "").toLowerCase();
+      const modelBlockedForPersistent = provider === "claude" && CLAUDE_PERSISTENT_BLOCKED_MODELS.some((blocked) => modelLower.includes(blocked));
+      if (modelBlockedForPersistent) {
+        console.log(`[AgentManager] EP1360: Model "${session.credentials.preferredModel}" incompatible with persistent mode (#17406) \u2014 using spawn-per-message`);
+      }
+      if (this.isPersistentEnabled() && !modelBlockedForPersistent) {
+        try {
+          const baseArgs = args.slice(0, argsBeforeMessage);
+          let persistentArgs;
+          if (provider === "claude") {
+            persistentArgs = [...baseArgs];
+            persistentArgs.push(
+              "--input-format",
+              "stream-json",
+              "--replay-user-messages"
+            );
+          } else {
+            persistentArgs = ["app-server"];
+          }
+          let runtimeBinaryPath;
+          let runtimeArgs;
+          if (spawnCmd === "npx") {
+            runtimeBinaryPath = "npx";
+            runtimeArgs = ["--yes", binaryPath.replace("npx:", ""), ...persistentArgs];
+          } else {
+            runtimeBinaryPath = spawnCmd;
+            runtimeArgs = persistentArgs;
+          }
+          const runtime = this.createRuntime(sessionId, provider, {
+            sessionId,
+            binaryPath: runtimeBinaryPath,
+            args: runtimeArgs,
+            env: envVars,
+            cwd: session.projectPath,
+            ...provider === "codex" ? {
+              model: session.credentials.preferredModel,
+              resumeThreadId: session.agentSessionId || session.claudeSessionId
+            } : {}
+          });
+          if (runtime) {
+            if (runtime.turnState !== "idle") {
+              const err = `TURN_IN_PROGRESS: Persistent runtime is busy (turnState=${runtime.turnState})`;
+              console.warn(`[AgentManager] EP1360: ${err}, session=${sessionId}`);
+              onError(err);
+              return { success: false, error: err };
+            }
+            if (runtime.pid) {
+              session.pid = runtime.pid;
+              this.writePidFile(sessionId, runtime.pid);
+            }
+            const pid = runtime.pid;
+            void this.getChildRssMb(pid).then((rss) => {
+              if (rss !== null) {
+                console.log(`[AgentManager] EP1360: Persistent turn start RSS: ${rss}MB, provider=${provider}, session=${sessionId}, pid=${pid}`);
+              }
+            });
+            const onCompleteWithRss = (agentSid, resultMetadata) => {
+              void this.getChildRssMb(pid).then((rss) => {
+                if (rss !== null) {
+                  console.log(`[AgentManager] EP1360: Persistent turn complete RSS: ${rss}MB, provider=${provider}, session=${sessionId}, pid=${pid}`);
+                }
+              });
+              wrapRuntimeOnComplete(agentSid, resultMetadata);
+            };
+            await runtime.sendMessage(runtimeFirstMessage, {
+              onChunk,
+              onToolUse,
+              onToolResult,
+              onCompaction: options.onCompaction,
+              onComplete: onCompleteWithRss,
+              onError: wrapRuntimeOnError
+            });
+            console.log(`[AgentManager] EP1360: Started persistent ${provider} runtime for session ${sessionId}, pid=${runtime.pid}`);
+            return { success: true };
+          }
+        } catch (error) {
+          console.warn(
+            `[AgentManager] EP1360: Persistent runtime creation failed, falling back to spawn-per-message: ${error instanceof Error ? error.message : error}`
+          );
+          const msg = error instanceof Error ? error.message : String(error);
+          this.disablePersistentForSession(sessionId, `SYNC_RUNTIME_ERROR: ${msg}`);
+        }
+      }
+      const childProcess = (0, import_child_process14.spawn)(spawnCmd, spawnArgs, {
         cwd: session.projectPath,
         env: envVars,
         stdio: ["pipe", "pipe", "pipe"]
@@ -9736,6 +11016,14 @@ If changes are needed, explain what needs to be done.`;
         session.pid = childProcess.pid;
         this.writePidFile(sessionId, childProcess.pid);
       }
+      let spawnChildRssMb = null;
+      let resultChildRssMb = null;
+      void this.getChildRssMb(childProcess.pid).then((rss) => {
+        spawnChildRssMb = rss;
+        if (rss !== null) {
+          console.log(`[AgentManager] EP1360: Child RSS at spawn: ${rss}MB, provider=${provider}, session=${sessionId}, pid=${childProcess.pid}`);
+        }
+      });
       childProcess.stderr?.on("data", (data) => {
         console.error(`[AgentManager] stderr: ${data.toString()}`);
       });
@@ -9751,6 +11039,8 @@ If changes are needed, explain what needs to be done.`;
       let stdoutEventCount = 0;
       let chunksSent = 0;
       const streamStartTime = Date.now();
+      let ttftLogged = false;
+      let parsedLineCount = 0;
       let hasContent = false;
       childProcess.stdout?.on("data", (data) => {
         const rawData = data.toString();
@@ -9765,6 +11055,12 @@ If changes are needed, explain what needs to be done.`;
           if (!line.trim()) continue;
           try {
             const parsed = JSON.parse(line);
+            parsedLineCount++;
+            if (!ttftLogged) {
+              ttftLogged = true;
+              const ttftMs = Date.now() - spawnTimestamp;
+              console.log(`[AgentManager] EP1360: TTFT (spawn to first JSON): ${ttftMs}ms, provider=${provider}, session=${sessionId}, isFirstMessage=${isFirstMessage}`);
+            }
             if (stdoutEventCount <= 10 || chunksSent === 0) {
               console.log(`[AgentManager] EP1191: Parsed event type: ${parsed.type}`);
             }
@@ -9819,6 +11115,12 @@ If changes are needed, explain what needs to be done.`;
                   }
                   break;
                 case "turn.completed":
+                  void this.getChildRssMb(childProcess.pid).then((rss) => {
+                    resultChildRssMb = rss;
+                    if (rss !== null) {
+                      console.log(`[AgentManager] EP1360: Child RSS at turn.completed: ${rss}MB, provider=${provider}, session=${sessionId}, pid=${childProcess.pid}`);
+                    }
+                  });
                   if (parsed.usage) {
                     const u = parsed.usage;
                     const inputTokens = u.input_tokens ?? u.prompt_tokens ?? 0;
@@ -9894,6 +11196,12 @@ If changes are needed, explain what needs to be done.`;
                   }
                   break;
                 case "result":
+                  void this.getChildRssMb(childProcess.pid).then((rss) => {
+                    resultChildRssMb = rss;
+                    if (rss !== null) {
+                      console.log(`[AgentManager] EP1360: Child RSS at result: ${rss}MB, provider=${provider}, session=${sessionId}, pid=${childProcess.pid}`);
+                    }
+                  });
                   if (parsed.session_id) {
                     extractedSessionId = parsed.session_id;
                     session.agentSessionId = extractedSessionId;
@@ -9965,6 +11273,12 @@ If changes are needed, explain what needs to be done.`;
       });
       childProcess.on("exit", (code, signal) => {
         const duration = Date.now() - streamStartTime;
+        const daemonExitRssMb = Math.round(process.memoryUsage().rss / 1024 / 1024);
+        const daemonDeltaMb = daemonExitRssMb - daemonSpawnRssMb;
+        console.log(`[AgentManager] EP1360: Daemon RSS at exit: ${daemonExitRssMb}MB (delta: ${daemonDeltaMb >= 0 ? "+" : ""}${daemonDeltaMb}MB from spawn ${daemonSpawnRssMb}MB), session=${sessionId}`);
+        const childDeltaMb = spawnChildRssMb !== null && resultChildRssMb !== null ? Math.round((resultChildRssMb - spawnChildRssMb) * 10) / 10 : null;
+        console.log(`[AgentManager] EP1360: Child RSS (spawn-per-message): spawn=${spawnChildRssMb ?? "null"}MB, result=${resultChildRssMb ?? "null"}MB${childDeltaMb !== null ? ` (delta: ${childDeltaMb >= 0 ? "+" : ""}${childDeltaMb}MB)` : ""}, session=${sessionId}, pid=${childProcess.pid}`);
+        console.log(`[AgentManager] EP1360: Stream stats: parsedLines=${parsedLineCount}, rawDataEvents=${stdoutEventCount}, chunksSent=${chunksSent}, session=${sessionId}`);
         console.log(`[AgentManager] EP1191: ${provider} CLI exited for session ${sessionId}: code=${code}, signal=${signal}, duration=${duration}ms, stdoutEvents=${stdoutEventCount}, chunksSent=${chunksSent}`);
         this.processes.delete(sessionId);
         this.removePidFile(sessionId);
@@ -10018,7 +11332,18 @@ If changes are needed, explain what needs to be done.`;
       console.log(`[AgentManager] Aborting session ${sessionId} with SIGINT`);
       agentProcess.kill("SIGINT");
     }
+    const runtime = this.runtimes.get(sessionId);
+    if (runtime) {
+      console.log(`[AgentManager] EP1360: Shutting down persistent runtime for aborted session ${sessionId}`);
+      void runtime.shutdown();
+      this.runtimes.delete(sessionId);
+    }
     const session = this.sessions.get(sessionId);
+    if (session) {
+      session.pid = void 0;
+    }
+    this.removePidFile(sessionId);
+    this.persistentDisabledSessions.delete(sessionId);
     if (session) {
       session.status = "stopping";
     }
@@ -10052,6 +11377,16 @@ If changes are needed, explain what needs to be done.`;
         });
       });
     }
+    const runtime = this.runtimes.get(sessionId);
+    if (runtime) {
+      try {
+        await runtime.shutdown();
+      } catch (error) {
+        console.warn(`[AgentManager] EP1360: Error shutting down runtime for session ${sessionId}:`, error);
+      }
+      this.runtimes.delete(sessionId);
+    }
+    this.persistentDisabledSessions.delete(sessionId);
     this.sessions.delete(sessionId);
     this.processes.delete(sessionId);
     this.removePidFile(sessionId);
@@ -10080,8 +11415,183 @@ If changes are needed, explain what needs to be done.`;
    * Stop all active sessions
    */
   async stopAllSessions() {
+    this.stopIdleScanner();
     const sessionIds = Array.from(this.sessions.keys());
     await Promise.all(sessionIds.map((id) => this.stopSession(id)));
+    this.persistentDisabledSessions.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // EP1360: Persistent Runtime Lifecycle
+  // ---------------------------------------------------------------------------
+  /**
+   * EP1360: Check if persistent runtimes are enabled.
+   */
+  isPersistentEnabled() {
+    return !AGENT_DISABLE_PERSISTENT;
+  }
+  /**
+   * EP1360: Get the persistent runtime for a session, if one exists and is alive.
+   */
+  getRuntime(sessionId) {
+    if (this.persistentDisabledSessions.has(sessionId)) {
+      return void 0;
+    }
+    const runtime = this.runtimes.get(sessionId);
+    if (runtime && runtime.isAlive()) {
+      return runtime;
+    }
+    if (runtime && !runtime.isAlive()) {
+      this.runtimes.delete(sessionId);
+      const session = this.sessions.get(sessionId);
+      if (session) {
+        session.pid = void 0;
+      }
+      this.removePidFile(sessionId);
+    }
+    return void 0;
+  }
+  /**
+   * EP1360: Create a persistent runtime for a session.
+   * Returns the runtime if a slot is available (possibly after evicting an idle runtime).
+   * Returns null if all slots are occupied by active streams (degrade to spawn-per-message).
+   */
+  createRuntime(sessionId, provider, options) {
+    if (AGENT_DISABLE_PERSISTENT) {
+      return null;
+    }
+    if (this.persistentDisabledSessions.has(sessionId)) {
+      return null;
+    }
+    const existing = this.getRuntime(sessionId);
+    if (existing) {
+      return existing;
+    }
+    if (this.runtimes.size >= AGENT_MAX_PERSISTENT) {
+      if (!this.evictIdleRuntime()) {
+        console.log(`[AgentManager] EP1360: All ${AGENT_MAX_PERSISTENT} persistent slots active \u2014 degrading to spawn-per-message for session ${sessionId}`);
+        return null;
+      }
+    }
+    let runtime;
+    if (provider === "claude") {
+      const claudeRuntime = new ClaudePersistentRuntime(options);
+      claudeRuntime.spawn();
+      runtime = claudeRuntime;
+    } else {
+      const codexRuntime = new CodexPersistentRuntime(options);
+      codexRuntime.spawn();
+      runtime = codexRuntime;
+    }
+    this.runtimes.set(sessionId, runtime);
+    console.log(`[AgentManager] EP1360: Created persistent ${provider} runtime for session ${sessionId} (${this.runtimes.size}/${AGENT_MAX_PERSISTENT} slots used)`);
+    return runtime;
+  }
+  /**
+   * EP1360: Shut down a persistent runtime for a session.
+   */
+  async shutdownRuntime(sessionId) {
+    const runtime = this.runtimes.get(sessionId);
+    if (!runtime) return;
+    try {
+      await runtime.shutdown();
+    } catch (error) {
+      console.warn(`[AgentManager] EP1360: Error shutting down runtime for session ${sessionId}:`, error);
+    }
+    this.runtimes.delete(sessionId);
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.pid = void 0;
+    }
+    this.removePidFile(sessionId);
+  }
+  /**
+   * EP1360: Permanently disable persistent mode for a session (remainder of session).
+   * Minimal "auto-downgrade" mechanism: once the runtime shows runtime-level failure
+   * signals (timeouts/crash/spawn), future messages use spawn-per-message.
+   */
+  disablePersistentForSession(sessionId, reason) {
+    if (this.persistentDisabledSessions.has(sessionId)) return;
+    this.persistentDisabledSessions.set(sessionId, { reason, at: Date.now() });
+    console.warn(`[AgentManager] EP1360: Disabling persistent mode for session ${sessionId} (downgrade to spawn-per-message): ${reason}`);
+    const runtime = this.runtimes.get(sessionId);
+    if (runtime) {
+      void runtime.shutdown().catch((err) => {
+        console.warn(`[AgentManager] EP1360: Error shutting down downgraded runtime for session ${sessionId}:`, err);
+      });
+      this.runtimes.delete(sessionId);
+    }
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.pid = void 0;
+    }
+    this.removePidFile(sessionId);
+  }
+  /**
+   * EP1360: Evict the least-recently-used idle runtime to free a slot.
+   * Returns true if a slot was freed, false if all runtimes are actively streaming.
+   */
+  evictIdleRuntime() {
+    let oldestIdleSessionId = null;
+    let oldestActivityTime = Infinity;
+    for (const [sid, runtime2] of this.runtimes) {
+      if (runtime2.turnState === "idle") {
+        const session2 = this.sessions.get(sid);
+        const activityTime = session2?.lastActivityAt?.getTime() ?? 0;
+        if (activityTime < oldestActivityTime) {
+          oldestActivityTime = activityTime;
+          oldestIdleSessionId = sid;
+        }
+      }
+    }
+    if (!oldestIdleSessionId) {
+      return false;
+    }
+    console.log(`[AgentManager] EP1360: Evicting idle runtime for session ${oldestIdleSessionId} (LRU)`);
+    const runtime = this.runtimes.get(oldestIdleSessionId);
+    if (runtime) {
+      void runtime.shutdown().catch((err) => {
+        console.warn(`[AgentManager] EP1360: Error during eviction shutdown:`, err);
+      });
+    }
+    this.runtimes.delete(oldestIdleSessionId);
+    const session = this.sessions.get(oldestIdleSessionId);
+    if (session) {
+      session.pid = void 0;
+    }
+    this.removePidFile(oldestIdleSessionId);
+    return true;
+  }
+  /**
+   * EP1360: Start the idle runtime scanner.
+   * Runs every 60s and shuts down runtimes that have been idle longer than AGENT_IDLE_TIMEOUT_MS.
+   */
+  startIdleScanner() {
+    if (this.idleScanTimer) return;
+    this.idleScanTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [sid, runtime] of this.runtimes) {
+        if (runtime.turnState !== "idle") continue;
+        const session = this.sessions.get(sid);
+        const lastActivity = session?.lastActivityAt?.getTime() ?? 0;
+        const idleMs = now - lastActivity;
+        if (idleMs > AGENT_IDLE_TIMEOUT_MS) {
+          console.log(`[AgentManager] EP1360: Runtime for session ${sid} idle for ${Math.round(idleMs / 1e3)}s \u2014 shutting down`);
+          void this.shutdownRuntime(sid);
+        }
+      }
+    }, IDLE_SCAN_INTERVAL_MS);
+    if (this.idleScanTimer.unref) {
+      this.idleScanTimer.unref();
+    }
+  }
+  /**
+   * EP1360: Stop the idle runtime scanner.
+   */
+  stopIdleScanner() {
+    if (this.idleScanTimer) {
+      clearInterval(this.idleScanTimer);
+      this.idleScanTimer = null;
+    }
   }
   /**
    * Get session info
@@ -10132,7 +11642,8 @@ If changes are needed, explain what needs to be done.`;
         moduleUid: session.moduleUid,
         status: reconStatus,
         agentSessionId: session.agentSessionId || session.claudeSessionId,
-        lastActivityAt: session.lastActivityAt
+        lastActivityAt: session.lastActivityAt,
+        persistentRuntime: this.runtimes.has(sessionId)
       });
     }
     return result;
@@ -10403,7 +11914,7 @@ var AgentCommandQueue = class {
 };
 
 // src/utils/dev-server.ts
-var import_child_process13 = require("child_process");
+var import_child_process15 = require("child_process");
 var import_core12 = __toESM(require_dist());
 var fs20 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
@@ -10452,7 +11963,7 @@ function writeToLog(logPath, line, isError = false) {
 }
 async function killProcessOnPort(port) {
   try {
-    const result = (0, import_child_process13.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    const result = (0, import_child_process15.execSync)(`lsof -ti:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
     if (!result) {
       console.log(`[DevServer] EP929: No process found on port ${port}`);
       return true;
@@ -10461,7 +11972,7 @@ async function killProcessOnPort(port) {
     console.log(`[DevServer] EP929: Found ${pids.length} process(es) on port ${port}: ${pids.join(", ")}`);
     for (const pid of pids) {
       try {
-        (0, import_child_process13.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process15.execSync)(`kill -15 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Sent SIGTERM to PID ${pid}`);
       } catch {
       }
@@ -10469,8 +11980,8 @@ async function killProcessOnPort(port) {
     await new Promise((resolve4) => setTimeout(resolve4, 1e3));
     for (const pid of pids) {
       try {
-        (0, import_child_process13.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
-        (0, import_child_process13.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
+        (0, import_child_process15.execSync)(`kill -0 ${pid} 2>/dev/null`, { encoding: "utf8" });
+        (0, import_child_process15.execSync)(`kill -9 ${pid} 2>/dev/null || true`, { encoding: "utf8" });
         console.log(`[DevServer] EP929: Force killed PID ${pid}`);
       } catch {
       }
@@ -10521,7 +12032,7 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customComm
   if (injectedCount > 0) {
     console.log(`[DevServer] EP998: Injecting ${injectedCount} env vars from database`);
   }
-  const devProcess = (0, import_child_process13.spawn)(cmd, args, {
+  const devProcess = (0, import_child_process15.spawn)(cmd, args, {
     cwd: projectPath,
     env: mergedEnv,
     stdio: ["ignore", "pipe", "pipe"],
@@ -10884,7 +12395,7 @@ function getInstallCommand2(cwd) {
 }
 
 // src/daemon/daemon-process.ts
-var import_child_process14 = require("child_process");
+var import_child_process16 = require("child_process");
 var fs23 = __toESM(require("fs"));
 var http2 = __toESM(require("http"));
 var os9 = __toESM(require("os"));
@@ -11000,6 +12511,7 @@ async function fetchEnvVars2(projectId) {
   }
 }
 var Daemon = class _Daemon {
+  // sessionId -> last seq
   constructor() {
     this.machineId = "";
     this.machineUuid = null;
@@ -11059,6 +12571,8 @@ var Daemon = class _Daemon {
     // EP1324: Retry limiting for failed update attempts
     this.lastFailedUpdateVersion = null;
     this.updateFailedAttempts = 0;
+    // EP1360: Per-session monotonic event seq for daemon→platform stream gap detection.
+    this.agentEventSeq = /* @__PURE__ */ new Map();
     this.ipcServer = new IPCServer();
   }
   static {
@@ -11098,6 +12612,11 @@ var Daemon = class _Daemon {
   static {
     this.MAX_UPDATE_ATTEMPTS = 3;
   }
+  nextAgentSeq(sessionId) {
+    const next = (this.agentEventSeq.get(sessionId) ?? 0) + 1;
+    this.agentEventSeq.set(sessionId, next);
+    return next;
+  }
   /**
    * Start the daemon
    */
@@ -11211,7 +12730,7 @@ var Daemon = class _Daemon {
       const configDir = getConfigDir9();
       const logPath = path24.join(configDir, "daemon.log");
       const logFd = fs23.openSync(logPath, "a");
-      const child = (0, import_child_process14.spawn)("node", [__filename], {
+      const child = (0, import_child_process16.spawn)("node", [__filename], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
         env: { ...process.env, EPISODA_DAEMON_MODE: "1" }
@@ -11981,7 +13500,7 @@ var Daemon = class _Daemon {
               await client.send({
                 type: "agent_result",
                 commandId,
-                result: { success: true, status: "chunk", sessionId, chunk }
+                result: { success: true, status: "chunk", sessionId, seq: this.nextAgentSeq(sessionId), chunk }
               });
             } catch (sendError) {
               console.error(`[Daemon] EP912: Failed to send chunk (WebSocket may be disconnected):`, sendError);
@@ -11999,6 +13518,7 @@ var Daemon = class _Daemon {
                   success: true,
                   status: "tool_use",
                   sessionId,
+                  seq: this.nextAgentSeq(sessionId),
                   toolUse: event
                 }
               });
@@ -12016,6 +13536,7 @@ var Daemon = class _Daemon {
                   success: true,
                   status: "tool_result",
                   sessionId,
+                  seq: this.nextAgentSeq(sessionId),
                   toolResult: event
                 }
               });
@@ -12034,6 +13555,7 @@ var Daemon = class _Daemon {
                   success: true,
                   status: "compaction",
                   sessionId,
+                  seq: this.nextAgentSeq(sessionId),
                   compaction: event
                 }
               });
@@ -12049,7 +13571,7 @@ var Daemon = class _Daemon {
               await client.send({
                 type: "agent_result",
                 commandId,
-                result: { success: true, status: "complete", sessionId, claudeSessionId, resultMetadata }
+                result: { success: true, status: "complete", sessionId, seq: this.nextAgentSeq(sessionId), claudeSessionId, resultMetadata }
               });
             } catch (sendError) {
               console.error(`[Daemon] EP912: Failed to send complete (WebSocket may be disconnected):`, sendError);
@@ -12063,7 +13585,7 @@ var Daemon = class _Daemon {
               await client.send({
                 type: "agent_result",
                 commandId,
-                result: { success: false, status: "error", sessionId, error }
+                result: { success: false, status: "error", sessionId, seq: this.nextAgentSeq(sessionId), error }
               });
             } catch (sendError) {
               console.error(`[Daemon] EP912: Failed to send error (WebSocket may be disconnected):`, sendError);
@@ -12136,6 +13658,7 @@ var Daemon = class _Daemon {
               success: startResult.success,
               status: startResult.success ? "started" : "error",
               sessionId: cmd.sessionId,
+              seq: this.nextAgentSeq(cmd.sessionId),
               error: startResult.error
             };
           } else if (cmd.action === "message") {
@@ -12159,14 +13682,16 @@ var Daemon = class _Daemon {
               success: sendResult.success,
               status: sendResult.success ? "started" : "error",
               sessionId: cmd.sessionId,
+              seq: this.nextAgentSeq(cmd.sessionId),
               error: sendResult.error
             };
           } else if (cmd.action === "abort") {
             await agentManager.abortSession(cmd.sessionId);
-            result = { success: true, status: "aborted", sessionId: cmd.sessionId };
+            result = { success: true, status: "aborted", sessionId: cmd.sessionId, seq: this.nextAgentSeq(cmd.sessionId) };
           } else if (cmd.action === "stop") {
             await agentManager.stopSession(cmd.sessionId);
-            result = { success: true, status: "complete", sessionId: cmd.sessionId };
+            result = { success: true, status: "complete", sessionId: cmd.sessionId, seq: this.nextAgentSeq(cmd.sessionId) };
+            this.agentEventSeq.delete(cmd.sessionId);
           } else {
             result = {
               success: false,
@@ -12192,6 +13717,7 @@ var Daemon = class _Daemon {
                 success: false,
                 status: "error",
                 sessionId,
+                seq: this.nextAgentSeq(sessionId),
                 error: errorMsg
               }
             });