@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/runner.js

@@ -0,0 +1,683 @@
+// Backend runner — Claude Code, Cursor Agent, OpenAI Codex. Owns
+// argv construction, subprocess lifecycle, stream parsing, and the
+// progress UI. All IO routes through core/io.js so the same runner
+// works on every channel.
+
+const { spawn } = require("child_process");
+const {
+  CLAUDE_PATH, resolvedCursorPath, resolvedCodexPath,
+  AUTO_COMPACT_TOKENS, MAX_PROCESS_TIMEOUT, botSubprocessEnv,
+} = require("./config");
+const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
+const { chatContext, currentChannelId, currentAdapter } = require("./context");
+const { buildSystemPrompt } = require("./system-prompt");
+const { redactSensitive } = require("./redact");
+const { send, editMessage, sendVoice, splitMessage } = require("./io");
+const { textToVoice, TTS_CMD } = require("./media");
+const { killProcessTree } = require("./process-tree");
+const {
+  appendProjectTranscript, transcriptProjectInfo,
+  promptWithTranscriptPointer, stripTranscriptPointerForStorage,
+} = require("./transcripts");
+const { getClaudeOAuthToken, claudeAuthRecoveryMessage, isClaudeAuthErrorText, claudeUsageLimitMessage, isClaudeUsageLimitText, runClaudeAuthStatusDiagnostic, claudeSubprocessEnv } = require("./auth-flow");
+
+function parseStreamEvents(data) {
+  const events = [];
+  for (const line of data.split("\n").filter((l) => l.trim())) {
+    try { events.push(JSON.parse(line)); } catch (e) { /* partial */ }
+  }
+  return events;
+}
+
+function getActiveBinary() {
+  const { settings } = currentState();
+  if (settings.backend === "cursor") return resolvedCursorPath;
+  if (settings.backend === "codex") return resolvedCodexPath;
+  return CLAUDE_PATH;
+}
+
+function getActiveSessionId() {
+  const state = currentState();
+  if (state.settings.backend === "cursor") return state.cursorSessionId;
+  if (state.settings.backend === "codex") return state.codexSessionId;
+  return state.lastSessionId;
+}
+
+function getActiveSessionKey(state = currentState()) {
+  if (state.settings.backend === "cursor") return "cursorSessionId";
+  if (state.settings.backend === "codex") return "codexSessionId";
+  return "lastSessionId";
+}
+
+function shouldAutoCompact(state = currentState(), opts = {}) {
+  if (opts.skipAutoCompact || opts.fresh || opts.continueSession || state.isCompacting) return false;
+  if (!state[getActiveSessionKey(state)]) return false;
+  const threshold = Number.isFinite(AUTO_COMPACT_TOKENS) ? AUTO_COMPACT_TOKENS : 280000;
+  return (state.sessionUsage?.lastInputTokens || 0) >= threshold;
+}
+
+function buildClaudeArgs(prompt, opts = {}) {
+  const state = currentState();
+  const { settings } = state;
+  if (settings.backend === "cursor") return buildCursorArgs(prompt, opts);
+  if (settings.backend === "codex") return buildCodexArgs(prompt, opts);
+  const args = ["-p", "--verbose", "--output-format", "stream-json",
+    "--append-system-prompt", buildSystemPrompt()];
+  const transcriptInfo = transcriptProjectInfo(state);
+  if (transcriptInfo) args.push("--add-dir", transcriptInfo.transcriptsDir);
+  if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+  else if (opts.continueSession) args.push("--continue");
+  else if (state.lastSessionId && !opts.fresh) {
+    if (userOwnsClaudeSession(state.userId, state.lastSessionId)) {
+      args.push("--resume", state.lastSessionId);
+    } else {
+      console.warn(`[session-guard] dropping stale lastSessionId=${state.lastSessionId.slice(0, 8)} for ${state.userId}; not present in sessions.json — starting fresh`);
+      state.lastSessionId = null;
+    }
+  }
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.effort) args.push("--effort", settings.effort);
+  if (settings.budget) args.push("--max-budget-usd", String(settings.budget));
+  if (settings.permissionMode) args.push("--permission-mode", settings.permissionMode);
+  else args.push("--dangerously-skip-permissions");
+  if (settings.worktree) args.push("--worktree");
+  args.push(prompt);
+  return args;
+}
+
+function buildCursorArgs(prompt, opts = {}) {
+  const state = currentState();
+  const { settings } = state;
+  const args = ["--print", "--trust", "--output-format", "stream-json"];
+  if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+  else if (opts.continueSession) args.push("--continue");
+  else if (state.cursorSessionId && !opts.fresh) args.push("--resume", state.cursorSessionId);
+  if (settings.model) args.push("--model", settings.model);
+  if (settings.permissionMode === "plan") args.push("--mode", "plan");
+  else if (settings.permissionMode === "ask") args.push("--mode", "ask");
+  if (settings.worktree) args.push("--worktree");
+  args.push(prompt);
+  return args;
+}
+
+function buildCodexArgs(prompt, opts = {}) {
+  const state = currentState();
+  const { settings, codexSessionId } = state;
+  const args = [];
+  const resumeId = opts.resumeSessionId || ((!opts.fresh && !opts.continueSession) ? codexSessionId : null);
+  if (opts.continueSession && codexSessionId) args.push("exec", "resume", codexSessionId);
+  else if (resumeId) args.push("exec", "resume", resumeId);
+  else args.push("exec");
+  args.push("--json", "--skip-git-repo-check");
+  const transcriptInfo = transcriptProjectInfo(state);
+  if (transcriptInfo) args.push("--add-dir", transcriptInfo.transcriptsDir);
+  if (settings.permissionMode === "plan") args.push("--sandbox", "read-only");
+  else args.push("--dangerously-bypass-approvals-and-sandbox");
+  if (settings.model) args.push("--model", settings.model);
+  args.push(promptWithTranscriptPointer(prompt, state));
+  return args;
+}
+
+function preflightClaudeAuthMessage() {
+  const state = currentState();
+  if (state.settings.backend !== "claude") return null;
+  if (getClaudeOAuthToken().value) return null;
+  try {
+    const { execSync } = require("child_process");
+    const output = execSync(`"${CLAUDE_PATH}" auth status`, {
+      cwd: process.env.HOME || require("os").homedir(),
+      env: claudeSubprocessEnv(),
+      encoding: "utf8",
+      timeout: 10000,
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (isClaudeAuthErrorText(output)) return claudeAuthRecoveryMessage(output.trim().slice(-500));
+    return null;
+  } catch (e) {
+    const output = `${e.stdout || ""}\n${e.stderr || ""}\n${e.message || ""}`;
+    if (isClaudeAuthErrorText(output)) return claudeAuthRecoveryMessage(output.trim().slice(-500));
+    return null;
+  }
+}
+
+function claudeEmptyFailureMessage(code, stderrText = "") {
+  const stderr = redactSensitive(String(stderrText || "").trim());
+  if (isClaudeUsageLimitText(stderr)) return claudeUsageLimitMessage(stderr.slice(-1200));
+  if (isClaudeAuthErrorText(stderr)) return claudeAuthRecoveryMessage(stderr.slice(-1200));
+  const authStatus = runClaudeAuthStatusDiagnostic();
+  if (isClaudeAuthErrorText(authStatus)) return claudeAuthRecoveryMessage(authStatus.slice(-1200));
+  if (isClaudeUsageLimitText(authStatus)) return claudeUsageLimitMessage(authStatus.slice(-1200));
+  return [
+    `Claude exited with code ${code} but produced no assistant output.`,
+    stderr ? `\nStderr:\n${stderr.slice(-1200)}` : "\nStderr: (empty)",
+    authStatus ? `\nAuth status:\n${redactSensitive(authStatus).slice(-1200)}` : "",
+    "",
+    "Useful next steps:",
+    "• /auth_status — verify Claude auth",
+    "• /model sonnet — switch away from Opus if usage-limited",
+    "• /setup_token — create a launchd-safe OAuth token if Keychain is the issue",
+  ].filter(Boolean).join("\n");
+}
+
+function compactSummaryPrompt() {
+  return [
+    "Summarize this conversation for a fresh compacted continuation.",
+    "Include only durable context needed to continue effectively:",
+    "- current user goal and constraints",
+    "- important decisions and preferences",
+    "- files/repos touched and current code state",
+    "- commands/tests already run and results",
+    "- open TODOs, blockers, and exact next step",
+    "Do not include secrets, raw tokens, or irrelevant chat transcript.",
+  ].join("\n");
+}
+
+function compactSeedPrompt(summary) {
+  return [
+    "This is a compacted continuation of a previous Open Claudia session.",
+    "Treat the following summary as the prior conversation context. Do not repeat it back unless asked.",
+    "Continue from this state in future turns.",
+    "",
+    "Compacted summary:",
+    summary,
+  ].join("\n");
+}
+
+function formatProgress(text, tools, currentTool, elapsed, toolDetail) {
+  const mins = Math.floor(elapsed / 60);
+  const secs = elapsed % 60;
+  const time = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+  const parts = [];
+  let status = currentTool ? `Working: ${currentTool}` : (tools.length > 0 ? "Processing..." : "Thinking...");
+  if (currentTool && toolDetail) status += ` — ${toolDetail}`;
+  parts.push(`${status} (${time})`);
+  if (tools.length > 1) parts.push(`Steps: ${[...new Set(tools)].join(" > ")}`);
+  if (text) parts.push(text.length > 800 ? "..." + text.slice(-800) : text);
+  return parts.join("\n\n");
+}
+
+async function runClaudeCapture(prompt, cwd, opts = {}) {
+  const state = currentState();
+  const store = chatContext.getStore();
+  if (state.runningProcess) throw new Error("Another task is already running.");
+  const authPreflight = preflightClaudeAuthMessage();
+  if (authPreflight) throw new Error(authPreflight);
+
+  return new Promise((resolve, reject) => {
+    let assistantText = "";
+    let stderrBuffer = "";
+    let streamBuffer = "";
+    let sessionId = null;
+    appendProjectTranscript(opts.transcriptRole || "system-note", stripTranscriptPointerForStorage(prompt), {
+      capture: true,
+      label: opts.label || null,
+      fresh: !!opts.fresh,
+      continueSession: !!opts.continueSession,
+      resumeSessionId: opts.resumeSessionId || null,
+    }, state, getActiveSessionId);
+    const args = buildClaudeArgs(prompt, { ...opts, skipAutoCompact: true });
+    const proc = spawn(getActiveBinary(), args, {
+      cwd,
+      env: claudeSubprocessEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
+    });
+    state.runningProcess = proc;
+    const timeout = setTimeout(() => {
+      if (state.runningProcess === proc) {
+        killProcessTree(proc.pid, "SIGTERM");
+        setTimeout(() => killProcessTree(proc.pid, "SIGKILL"), 5000);
+      }
+    }, MAX_PROCESS_TIMEOUT);
+
+    proc.stdout.on("data", (data) => {
+      streamBuffer += data.toString();
+      const events = parseStreamEvents(streamBuffer);
+      const lastNewline = streamBuffer.lastIndexOf("\n");
+      streamBuffer = lastNewline >= 0 ? streamBuffer.slice(lastNewline + 1) : streamBuffer;
+      for (const evt of events) {
+        if (evt.type === "assistant" && evt.message?.content) {
+          for (const block of evt.message.content) {
+            if (block.type === "text") assistantText += block.text;
+          }
+        }
+        if (evt.type === "item.completed" && evt.item?.type === "agent_message" && typeof evt.item.text === "string") {
+          assistantText += (assistantText ? "\n" : "") + evt.item.text;
+        }
+        if (evt.type === "thread.started" && evt.thread_id) {
+          state.codexSessionId = evt.thread_id;
+          sessionId = evt.thread_id;
+          saveState();
+        }
+        if (evt.type === "result" && evt.session_id) {
+          if (state.settings.backend === "cursor") state.cursorSessionId = evt.session_id;
+          else state.lastSessionId = evt.session_id;
+          sessionId = evt.session_id;
+          if (evt.usage) {
+            const u = state.sessionUsage;
+            u.turns += 1;
+            u.inputTokens += evt.usage.input_tokens || 0;
+            u.outputTokens += evt.usage.output_tokens || 0;
+            u.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
+            u.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
+            u.lastInputTokens = (evt.usage.input_tokens || 0) +
+              (evt.usage.cache_read_input_tokens || 0) +
+              (evt.usage.cache_creation_input_tokens || 0);
+          }
+          if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
+          saveState();
+        }
+        if (evt.type === "result" && evt.result) assistantText = evt.result;
+      }
+    });
+    proc.stderr.on("data", (d) => { stderrBuffer += d.toString(); });
+    proc.on("close", (code) => chatContext.run(store, () => {
+      if (state.runningProcess === proc) state.runningProcess = null;
+      clearTimeout(timeout);
+      if (code !== 0 && code !== null) {
+        const failureText = claudeEmptyFailureMessage(code, stderrBuffer);
+        appendProjectTranscript("system-note", failureText, { capture: true, label: opts.label || null, exitCode: code, kind: "backend-error" }, state, getActiveSessionId);
+        reject(new Error(failureText));
+        return;
+      }
+      const cleanText = redactSensitive(assistantText.trim());
+      appendProjectTranscript("assistant", cleanText, { capture: true, label: opts.label || null, exitCode: code }, state, getActiveSessionId);
+      resolve({ text: cleanText, sessionId });
+    }));
+    proc.on("error", (err) => chatContext.run(store, () => {
+      if (state.runningProcess === proc) state.runningProcess = null;
+      clearTimeout(timeout);
+      reject(err);
+    }));
+  });
+}
+
+async function compactActiveSession(cwd, opts = {}) {
+  const state = currentState();
+  const sessionKey = getActiveSessionKey(state);
+  const oldSessionId = state[sessionKey];
+  if (!oldSessionId) return { compacted: false, reason: "No conversation." };
+  if (state.isCompacting) return { compacted: false, reason: "Compaction already in progress." };
+
+  state.isCompacting = true;
+  try {
+    if (opts.notify) await send(opts.message || "Context is getting large, compacting first so this stays fast…");
+    const summaryRun = await runClaudeCapture(compactSummaryPrompt(), cwd, { resumeSessionId: oldSessionId, skipAutoCompact: true, label: "compact-summary" });
+    const summary = summaryRun.text || "No prior context was returned by the summarizer.";
+    state[sessionKey] = null;
+    state.sessionUsage = { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+    state.isFirstMessage = true;
+    saveState();
+
+    const seedRun = await runClaudeCapture(compactSeedPrompt(summary), cwd, { fresh: true, skipAutoCompact: true, label: "compact-seed" });
+    const newSessionId = seedRun.sessionId || state[sessionKey];
+    if (newSessionId) state[sessionKey] = newSessionId;
+    state.isFirstMessage = false;
+    state.lastCompactedAt = Date.now();
+    state.sessionUsage = { turns: 0, inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, costUsd: 0, lastInputTokens: 0 };
+    saveState();
+
+    if (newSessionId && state.currentSession) {
+      const title = `Compacted ${new Date().toLocaleDateString()}`;
+      recordSession(state.userId, state.currentSession.name, newSessionId, title);
+    }
+    return { compacted: true, oldSessionId, newSessionId, summary };
+  } finally {
+    state.isCompacting = false;
+    saveState();
+  }
+}
+
+async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
+  const state = currentState();
+  const store = chatContext.getStore();
+  const channelId = currentChannelId();
+  const adapter = currentAdapter();
+  const { settings } = state;
+
+  if (state.runningProcess) {
+    state.messageQueue.push({ prompt, replyToMsgId, opts });
+    await send(state.isCompacting ? "Compacting context, will pick this up next…" : "Queued.", { replyTo: replyToMsgId });
+    return;
+  }
+
+  const authPreflight = preflightClaudeAuthMessage();
+  if (authPreflight) {
+    await send(authPreflight, { replyTo: replyToMsgId });
+    return;
+  }
+
+  if (shouldAutoCompact(state, opts)) {
+    try {
+      await compactActiveSession(cwd, {
+        notify: true,
+        message: "Context is getting large, compacting first so this stays fast…",
+      });
+    } catch (e) {
+      await send(`Compaction failed: ${redactSensitive(e.message)}\nContinuing in the existing session.`, { replyTo: replyToMsgId });
+    }
+  }
+
+  appendProjectTranscript("user", prompt, {
+    sourceMessageId: replyToMsgId || null,
+    fresh: !!opts.fresh,
+    continueSession: !!opts.continueSession,
+    resumeSessionId: opts.resumeSessionId || null,
+  }, state, getActiveSessionId);
+
+  if (adapter && channelId) adapter.typing(channelId).catch(() => {});
+  state.statusMessageId = null;
+  state.streamBuffer = "";
+  let assistantText = "";
+  let toolUses = [];
+  let currentTool = null;
+  let currentToolDetail = "";
+
+  const args = buildClaudeArgs(prompt, opts);
+  const binaryPath = getActiveBinary();
+  const proc = spawn(binaryPath, args, {
+    cwd,
+    env: claudeSubprocessEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: process.platform !== "win32",
+  });
+
+  state.runningProcess = proc;
+  const startTime = Date.now();
+  let longRunningNotified = false;
+
+  const processTimeout = setTimeout(() => {
+    if (state.runningProcess === proc) {
+      killProcessTree(proc.pid, "SIGTERM");
+      setTimeout(() => killProcessTree(proc.pid, "SIGKILL"), 5000);
+      chatContext.run(store, () => send(`Task timed out after ${MAX_PROCESS_TIMEOUT / 60000} minutes. Stopped.`));
+    }
+  }, MAX_PROCESS_TIMEOUT);
+
+  let lastUpdate = "";
+  const scheduleUpdate = () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    const interval = elapsed > 120 ? 5000 : 2000;
+    state.streamInterval = setTimeout(() => chatContext.run(store, updateProgress), interval);
+  };
+  const updateProgress = async () => {
+    const elapsed = Math.floor((Date.now() - startTime) / 1000);
+    try {
+      if (adapter && channelId) adapter.typing(channelId).catch(() => {});
+      const display = formatProgress(assistantText, toolUses, currentTool, elapsed, currentToolDetail);
+      if (display && display !== lastUpdate) {
+        if (!state.statusMessageId && assistantText) {
+          state.statusMessageId = await send(display.length > 4000 ? display.slice(-4000) : display, { replyTo: replyToMsgId });
+        } else if (state.statusMessageId) {
+          await editMessage(state.statusMessageId, display.length > 4000 ? display.slice(-4000) : display);
+        }
+        lastUpdate = display;
+      }
+      if (elapsed > 300 && !longRunningNotified) {
+        longRunningNotified = true;
+        await send(`Still working (${Math.floor(elapsed / 60)}min)... Send /stop to cancel.`);
+      }
+    } catch (e) {
+      console.error("Progress update error:", e.message);
+    }
+    if (state.runningProcess) scheduleUpdate();
+  };
+  scheduleUpdate();
+
+  proc.stdout.on("data", (data) => {
+    state.streamBuffer += data.toString();
+    const events = parseStreamEvents(state.streamBuffer);
+    const lastNewline = state.streamBuffer.lastIndexOf("\n");
+    state.streamBuffer = lastNewline >= 0 ? state.streamBuffer.slice(lastNewline + 1) : state.streamBuffer;
+    for (const evt of events) {
+      if (evt.type === "assistant" && evt.message?.content) {
+        for (const block of evt.message.content) {
+          if (block.type === "text") assistantText += block.text;
+          else if (block.type === "tool_use") {
+            currentTool = block.name;
+            toolUses.push(block.name);
+            const input = block.input || {};
+            if (block.name === "Bash" && input.command) currentToolDetail = input.command.slice(0, 80);
+            else if (block.name === "Read" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Edit" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Write" && input.file_path) currentToolDetail = input.file_path.split("/").slice(-2).join("/");
+            else if (block.name === "Grep" && input.pattern) currentToolDetail = input.pattern.slice(0, 40);
+            else if (block.name === "Glob" && input.pattern) currentToolDetail = input.pattern;
+            else currentToolDetail = "";
+          }
+        }
+      }
+      if (evt.type === "tool_call" && evt.subtype === "started" && evt.tool_call) {
+        const tc = evt.tool_call;
+        if (tc.shellToolCall) {
+          const a = tc.shellToolCall.args || {};
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = (a.description || a.command || "").slice(0, 80);
+        } else if (tc.readToolCall) {
+          currentTool = "Read"; toolUses.push("Read");
+          currentToolDetail = (tc.readToolCall.args?.path || "").split("/").slice(-2).join("/");
+        } else if (tc.editToolCall) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          currentToolDetail = (tc.editToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.writeToolCall) {
+          currentTool = "Write"; toolUses.push("Write");
+          currentToolDetail = (tc.writeToolCall.args?.filePath || "").split("/").slice(-2).join("/");
+        } else if (tc.grepToolCall) {
+          currentTool = "Grep"; toolUses.push("Grep");
+          currentToolDetail = (tc.grepToolCall.args?.pattern || "").slice(0, 40);
+        } else if (tc.globToolCall) {
+          currentTool = "Glob"; toolUses.push("Glob");
+          currentToolDetail = (tc.globToolCall.args?.globPattern || "").slice(0, 40);
+        } else if (tc.createPlanToolCall) {
+          currentTool = "Plan"; toolUses.push("Plan");
+          const plan = tc.createPlanToolCall.args || {};
+          let planText = "";
+          if (plan.name) planText += `**${plan.name}**\n\n`;
+          if (plan.plan) planText += plan.plan + "\n";
+          if (plan.todos && plan.todos.length) {
+            planText += "\n**Tasks:**\n";
+            for (const todo of plan.todos) {
+              planText += `• ${todo.content || todo.id}\n`;
+            }
+          }
+          if (planText) assistantText = planText;
+          currentToolDetail = plan.name || "creating plan";
+        } else {
+          const toolKey = Object.keys(tc)[0] || "unknown";
+          currentTool = toolKey.replace("ToolCall", ""); toolUses.push(currentTool);
+          currentToolDetail = "";
+        }
+      }
+      if (evt.type === "thread.started" && evt.thread_id) {
+        state.codexSessionId = evt.thread_id;
+        saveState();
+      }
+      if (evt.type === "item.started" && evt.item) {
+        const it = evt.item;
+        if (it.type === "command_execution" && it.command) {
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = String(it.command).slice(0, 80);
+        } else if (it.type === "file_change" && (it.path || it.file_path)) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          const p = it.path || it.file_path;
+          currentToolDetail = String(p).split("/").slice(-2).join("/");
+        } else if (it.type === "web_search" && it.query) {
+          currentTool = "Web"; toolUses.push("Web");
+          currentToolDetail = String(it.query).slice(0, 60);
+        } else if (it.type) {
+          currentTool = it.type; toolUses.push(it.type);
+          currentToolDetail = "";
+        }
+      }
+      if (evt.type === "item.completed" && evt.item) {
+        const it = evt.item;
+        if (it.type === "agent_message" && typeof it.text === "string") {
+          assistantText += (assistantText ? "\n" : "") + it.text;
+        }
+      }
+      if (evt.type === "turn.completed" && evt.usage && settings.backend === "codex") {
+        const u = state.sessionUsage;
+        u.turns += 1;
+        const input = evt.usage.input_tokens || 0;
+        const cached = evt.usage.cached_input_tokens || 0;
+        const output = evt.usage.output_tokens || 0;
+        u.inputTokens += input;
+        u.outputTokens += output;
+        u.cacheReadTokens += cached;
+        u.lastInputTokens = input + cached;
+        saveState();
+      }
+      if (evt.type === "result" && evt.session_id) {
+        if (settings.backend === "cursor") { state.cursorSessionId = evt.session_id; }
+        else { state.lastSessionId = evt.session_id; }
+        if (evt.usage) {
+          const u = state.sessionUsage;
+          u.turns += 1;
+          u.inputTokens += evt.usage.input_tokens || 0;
+          u.outputTokens += evt.usage.output_tokens || 0;
+          u.cacheReadTokens += evt.usage.cache_read_input_tokens || 0;
+          u.cacheCreationTokens += evt.usage.cache_creation_input_tokens || 0;
+          u.lastInputTokens = (evt.usage.input_tokens || 0) +
+            (evt.usage.cache_read_input_tokens || 0) +
+            (evt.usage.cache_creation_input_tokens || 0);
+        }
+        if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;
+        saveState();
+      }
+      if (evt.type === "result" && evt.result) assistantText = evt.result;
+    }
+  });
+
+  let stderrBuffer = "";
+  proc.stderr.on("data", (d) => {
+    const chunk = d.toString();
+    stderrBuffer += chunk;
+    console.error("STDERR:", redactSensitive(chunk));
+  });
+
+  proc.on("close", (code) => chatContext.run(store, async () => {
+    state.runningProcess = null;
+    clearTimeout(state.streamInterval); state.streamInterval = null;
+    clearTimeout(processTimeout);
+
+    if (settings.backend === "claude" && isClaudeAuthErrorText(stderrBuffer)) {
+      const authText = claudeAuthRecoveryMessage(stderrBuffer.trim().slice(-800));
+      appendProjectTranscript("system-note", authText, { kind: "auth-error" }, state, getActiveSessionId);
+      await send(authText, { replyTo: replyToMsgId });
+      return;
+    }
+    if (settings.backend === "cursor" && isClaudeAuthErrorText(stderrBuffer)) {
+      const authText = "Cursor authentication error. Run `agent login` on this machine, then retry.";
+      appendProjectTranscript("system-note", authText, { kind: "auth-error" }, state, getActiveSessionId);
+      await send(authText, { replyTo: replyToMsgId });
+      return;
+    }
+    if (settings.backend === "codex" && /not (?:logged in|authenticated)|please (?:log|sign) in|401 unauthorized|invalid api key/i.test(stderrBuffer)) {
+      const authText = "Codex authentication error. Try /codex_auth_status, then /codex_login or /codex_setup_token.";
+      appendProjectTranscript("system-note", authText, { kind: "auth-error" }, state, getActiveSessionId);
+      await send(authText, { replyTo: replyToMsgId });
+      return;
+    }
+
+    try {
+      if (code !== 0 && code !== null && !assistantText.trim()) {
+        const failureText = claudeEmptyFailureMessage(code, stderrBuffer);
+        appendProjectTranscript("system-note", failureText, { exitCode: code, kind: "backend-error" }, state, getActiveSessionId);
+        await send(failureText, { replyTo: replyToMsgId });
+        return;
+      }
+
+      const finalText = redactSensitive(assistantText || "(no output)");
+      appendProjectTranscript("assistant", finalText, {
+        exitCode: code,
+        sourceMessageId: state.statusMessageId || null,
+      }, state, getActiveSessionId);
+      const chunks = splitMessage(finalText);
+      const firstChunk = chunks[0];
+
+      if (state.statusMessageId && chunks.length === 1) {
+        await editMessage(state.statusMessageId, firstChunk);
+      } else {
+        const sent = await send(firstChunk, { replyTo: replyToMsgId });
+        if (!sent) await send(firstChunk);
+        for (let i = 1; i < chunks.length; i++) {
+          await send(chunks[i]);
+        }
+      }
+      if (code !== 0 && code !== null) await send(`Exit code: ${code}`);
+
+      if (state.lastInputWasVoice && TTS_CMD) {
+        state.lastInputWasVoice = false;
+        const voicePath = textToVoice(finalText);
+        if (voicePath) await sendVoice(voicePath);
+      }
+    } catch (e) {
+      console.error("Final message delivery failed:", e.message);
+      await send("Task completed but failed to deliver the response. Send /continue to see the result.");
+    }
+    if (settings.budget) settings.budget = null;
+    state.statusMessageId = null;
+
+    if (state.lastSessionId && state.currentSession) {
+      const title = state.isFirstMessage ? (prompt.length > 60 ? prompt.slice(0, 57) + "..." : prompt) : null;
+      recordSession(state.userId, state.currentSession.name, state.lastSessionId, title);
+      state.isFirstMessage = false;
+    }
+
+    if (state.messageQueue.length === 0 && state.currentSession && shouldAutoCompact(state)) {
+      try {
+        await compactActiveSession(state.currentSession.dir, { notify: false });
+      } catch (e) {
+        console.warn(`[proactive-compact] failed: ${redactSensitive(e.message)}`);
+      }
+    }
+
+    if (state.messageQueue.length > 0 && state.currentSession) {
+      const next = state.messageQueue.shift();
+      await runClaude(next.prompt, state.currentSession.dir, next.replyToMsgId, next.opts);
+    }
+  }));
+
+  proc.on("error", (err) => chatContext.run(store, async () => {
+    state.runningProcess = null;
+    clearTimeout(state.streamInterval);
+    clearTimeout(processTimeout);
+    await send(`Error: ${err.message}`);
+    state.statusMessageId = null;
+  }));
+}
+
+async function runClaudeSilent(prompt, cwd, label) {
+  return new Promise((resolve) => {
+    const args = ["-p", "--output-format", "text", "--verbose",
+      "--append-system-prompt", buildSystemPrompt(),
+      "--dangerously-skip-permissions", prompt];
+    const proc = spawn(CLAUDE_PATH, args, {
+      cwd, env: claudeSubprocessEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let output = "";
+    proc.stdout.on("data", (d) => { output += d.toString(); });
+    proc.on("close", async () => {
+      const chunks = splitMessage(`Cron: ${label}\n\n${redactSensitive(output.trim() || "(no output)")}`);
+      for (const c of chunks) await send(c);
+      resolve();
+    });
+    proc.on("error", async (err) => { await send(`Cron "${label}" failed: ${err.message}`); resolve(); });
+  });
+}
+
+module.exports = {
+  runClaude,
+  runClaudeCapture,
+  runClaudeSilent,
+  compactActiveSession,
+  buildSystemPrompt,
+  getActiveSessionId,
+  getActiveBinary,
+  getActiveSessionKey,
+  shouldAutoCompact,
+  formatProgress,
+  preflightClaudeAuthMessage,
+  claudeEmptyFailureMessage,
+};