@beevibe/daemon 0.1.2 → 0.1.4

package/dist/main.js

@@ -2,7 +2,6 @@
 
 // src/setup.ts
 import { hostname, userInfo } from "node:os";
-import { spawnSync } from "node:child_process";
 
 // ../../node_modules/.pnpm/nanoid@5.1.9/node_modules/nanoid/index.js
 import { webcrypto as crypto } from "node:crypto";
@@ -224,6 +223,29 @@ function saveConfig(cfg) {
 `, { mode: 384 });
 }
 
+// src/detect-clis.ts
+import { execFile } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync = promisify2(execFile);
+async function probeOne(cli) {
+  try {
+    await execFileAsync("which", [cli]);
+  } catch {
+    return null;
+  }
+  let cli_version;
+  try {
+    const { stdout } = await execFileAsync(cli, ["--version"]);
+    cli_version = stdout.trim().split(`
+`)[0];
+  } catch {}
+  return { cli, cli_version };
+}
+async function detectClis() {
+  const results = await Promise.all(KNOWN_CLIS.map((cli) => probeOne(cli)));
+  return results.filter((r) => r !== null);
+}
+
 // src/setup.ts
 async function runSetup(options) {
   if (!/^https?:\/\//.test(options.apiUrl)) {
@@ -234,7 +256,7 @@ async function runSetup(options) {
   }
   const externalId = options.externalId ?? hostname();
   const deviceName = options.deviceName ?? `${userInfo().username}@${hostname()}`;
-  const runtimes = options.detectedClis ?? detectClis();
+  const runtimes = options.detectedClis ?? await detectClis();
   if (runtimes.length === 0) {
     throw new Error(`No supported CLIs detected on PATH. beevibe currently looks for: ${KNOWN_CLIS.join(", ")}`);
   }
@@ -264,21 +286,6 @@ async function runSetup(options) {
   saveConfig(config);
   return config;
 }
-function detectClis() {
-  const out = [];
-  for (const cli of KNOWN_CLIS) {
-    const which = spawnSync("which", [cli], { encoding: "utf8" });
-    if (which.status !== 0 || !which.stdout.trim())
-      continue;
-    const version = spawnSync(cli, ["--version"], { encoding: "utf8" });
-    out.push({
-      cli,
-      cli_version: version.status === 0 ? version.stdout.trim().split(`
-`)[0] : undefined
-    });
-  }
-  return out;
-}
 
 // ../core/dist/adapters/local-workspace/manager.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
@@ -436,6 +443,16 @@ class LocalWorkspaceManager {
     if (!runtime3) {
       throw new Error(`No runtime registered for agent ${agent2.id} (runtime_config.type='${agent2.runtime_config.type}')`);
     }
+    if (runtime3.prepareWorkspace) {
+      if (!agent2.api_key) {
+        throw new Error(`Cannot prepare workspace for agent ${agent2.id}: agent.api_key is missing`);
+      }
+      await runtime3.prepareWorkspace({
+        workspace: workspace2,
+        agentApiKey: agent2.api_key,
+        mcpServerUrl: this.config.mcpServerUrl
+      });
+    }
     await syncSkills({
       sourceDir: this.config.skillsSourceDir,
       targetDir: runtime3.skillsDir(workspace2),
@@ -648,6 +665,15 @@ function extractStepEvents(msg) {
       }
     ];
   }
+  if (msg.type === STREAM_TYPE.ToolResult) {
+    return [
+      {
+        kind: "tool_result",
+        description: describeToolResult(msg.content, msg.is_error === true),
+        timestamp: now
+      }
+    ];
+  }
   if (msg.type === STREAM_TYPE.ContentBlockStart && msg.content_block?.type === BLOCK_TYPE.ToolUse) {
     const block = msg.content_block;
     return [
@@ -681,6 +707,11 @@ function extractStepEvents(msg) {
   }
   return [];
 }
+function describeToolResult(content, isError) {
+  const text = typeof content === "string" ? content : JSON.stringify(content ?? "");
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return isError ? `[error] ${collapsed}` : collapsed;
+}
 var PREFERRED_INPUT_FIELDS = [
   "file_path",
   "command",
@@ -937,110 +968,1486 @@ class ClaudeCodeRuntime {
   }
 }
 
-// ../core/dist/adapters/runtime-registry.js
-function createDefaultRuntimeRegistry() {
+// ../core/dist/adapters/codex/runtime.js
+import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+
+// ../core/dist/adapters/codex/stream-json.js
+var CODEX_EVENT_TYPE = {
+  ThreadStarted: "thread.started",
+  TurnStarted: "turn.started",
+  TurnCompleted: "turn.completed",
+  TurnFailed: "turn.failed",
+  ItemStarted: "item.started",
+  ItemUpdated: "item.updated",
+  ItemCompleted: "item.completed",
+  Error: "error"
+};
+var CODEX_ITEM_TYPE = {
+  AgentMessage: "agent_message",
+  Reasoning: "reasoning",
+  CommandExecution: "command_execution",
+  FileChange: "file_change",
+  McpToolCall: "mcp_tool_call",
+  CollabToolCall: "collab_tool_call",
+  WebSearch: "web_search",
+  TodoList: "todo_list",
+  Error: "error"
+};
+function parseCodexEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{"))
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractCodexStepEvents(evt) {
+  const now = new Date().toISOString();
+  if (evt.type !== CODEX_EVENT_TYPE.ItemStarted && evt.type !== CODEX_EVENT_TYPE.ItemCompleted) {
+    return [];
+  }
+  const item = evt.item;
+  if (!item || !item.type)
+    return [];
+  const isCompletion = evt.type === CODEX_EVENT_TYPE.ItemCompleted;
+  if (item.type === CODEX_ITEM_TYPE.AgentMessage) {
+    if (!isCompletion)
+      return [];
+    const text = item.text?.trim();
+    if (!text)
+      return [];
+    return [{ kind: "agent", description: text, timestamp: now }];
+  }
+  if (item.type === CODEX_ITEM_TYPE.McpToolCall) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: item.tool ?? "unknown",
+        description: describeCodexInput(item.arguments),
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.CommandExecution) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "shell",
+        description: (item.command ?? "").slice(0, 200),
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.FileChange) {
+    const summary = (item.changes ?? []).map((c) => `${c.kind ?? "?"} ${c.path ?? ""}`).join(", ").slice(0, 200);
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "file_change",
+        description: summary,
+        timestamp: now
+      }
+    ];
+  }
+  if (item.type === CODEX_ITEM_TYPE.WebSearch) {
+    return [
+      {
+        kind: isCompletion ? "tool_result" : "tool_call",
+        tool: "web_search",
+        description: (item.query ?? "").slice(0, 200),
+        timestamp: now
+      }
+    ];
+  }
+  return [];
+}
+var PREFERRED_CODEX_FIELDS = [
+  "file_path",
+  "path",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "intent"
+];
+function describeCodexInput(input) {
+  if (typeof input === "string")
+    return input.slice(0, 200);
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return "";
+  const obj = input;
+  for (const key of PREFERRED_CODEX_FIELDS) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0)
+      return v.slice(0, 200);
+  }
+  return JSON.stringify(input).slice(0, 200);
+}
+function parseCodexEvents(events, exitCode, lastMessage) {
+  let threadId;
+  let usage;
+  let assistantText = "";
+  let turnFailed;
+  let topLevelError;
+  const transcriptParts = [];
+  for (const evt of events) {
+    switch (evt.type) {
+      case CODEX_EVENT_TYPE.ThreadStarted:
+        if (evt.thread_id)
+          threadId = evt.thread_id;
+        break;
+      case CODEX_EVENT_TYPE.TurnCompleted:
+        if (evt.usage)
+          usage = evt.usage;
+        break;
+      case CODEX_EVENT_TYPE.TurnFailed:
+        turnFailed = evt.error?.message ?? turnFailed;
+        break;
+      case CODEX_EVENT_TYPE.Error:
+        topLevelError = evt.message ?? topLevelError;
+        if (evt.message)
+          transcriptParts.push(`[error] ${evt.message}
+`);
+        break;
+      case CODEX_EVENT_TYPE.ItemCompleted: {
+        const item = evt.item;
+        if (!item || !item.type)
+          break;
+        if (item.type === CODEX_ITEM_TYPE.AgentMessage && item.text) {
+          assistantText = item.text;
+          transcriptParts.push(`[assistant] ${item.text}
+`);
+        } else if (item.type === CODEX_ITEM_TYPE.McpToolCall) {
+          const tool = item.tool ?? "unknown";
+          transcriptParts.push(`[tool_call] ${tool}
+`);
+          const resultSummary = summarizeMcpResult(item.result);
+          if (resultSummary || item.error?.message) {
+            transcriptParts.push(`[tool_result from ${tool}] ${item.error?.message ?? resultSummary}
+`);
+          }
+        } else if (item.type === CODEX_ITEM_TYPE.CommandExecution) {
+          transcriptParts.push(`[tool_call] shell ${(item.command ?? "").slice(0, 200)}
+`);
+          if (item.aggregated_output) {
+            transcriptParts.push(`[tool_result from shell] ${item.aggregated_output.slice(0, 200).replace(/\n/g, " ")}
+`);
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  const failed = exitCode !== 0 || !!turnFailed || !!topLevelError;
+  const trimmedLast = lastMessage.trim();
+  const failureMessage = turnFailed ?? topLevelError;
+  const output = failed ? failureMessage || assistantText || bareCliExitMessage(exitCode) : trimmedLast || assistantText || "Session completed.";
   return {
-    claude: new ClaudeCodeRuntime({})
+    status: failed ? "failed" : "completed",
+    output,
+    transcript: transcriptParts.join("") || undefined,
+    cli_session_id: threadId,
+    usage: usage ? {
+      input_tokens: usage.input_tokens ?? 0,
+      output_tokens: (usage.output_tokens ?? 0) + (usage.reasoning_output_tokens ?? 0),
+      cache_creation_input_tokens: 0,
+      cache_read_input_tokens: usage.cached_input_tokens ?? 0
+    } : undefined
   };
 }
+function summarizeMcpResult(result) {
+  if (!result || !Array.isArray(result.content))
+    return "";
+  for (const block of result.content) {
+    if (block && typeof block === "object" && block.type === "text") {
+      const text = block.text;
+      if (typeof text === "string")
+        return text.slice(0, 200).replace(/\n/g, " ");
+    }
+  }
+  return JSON.stringify(result.content).slice(0, 200);
+}
 
-// src/api-client.ts
-import WebSocket from "ws";
+// ../core/dist/adapters/codex/runtime.js
+var OPENAI_AUTH_VARS = ["OPENAI_API_KEY", "OPENAI_AUTH_TOKEN"];
 
-class ApiClient {
-  cfg;
-  constructor(cfg) {
-    this.cfg = cfg;
-  }
-  async get(path2) {
-    const res = await fetch(this.url(path2), {
-      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
-    });
-    if (res.status === 204 || res.status >= 400)
-      return;
-    return await res.json();
+class CodexRuntime {
+  config;
+  type = "codex";
+  prepared = new Map;
+  constructor(config = {}) {
+    this.config = config;
   }
-  async post(path2, body) {
-    const res = await fetch(this.url(path2), {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${this.cfg.daemonToken}`
+  async execute(context) {
+    const prepared = this.prepared.get(context.workspace.path);
+    const sid = context.env?.BEEVIBE_SESSION_ID;
+    const lastMessagePath = join4(context.workspace.path, `.beevibe-codex-last-message-${Date.now()}.txt`);
+    const globalArgs = buildGlobalArgs(context, this.config);
+    const execArgs = [
+      "--json",
+      "--skip-git-repo-check",
+      "--output-last-message",
+      lastMessagePath
+    ];
+    if (prepared && sid) {
+      globalArgs.push("-c", `mcp_servers.beevibe.url=${tomlString(withBeevibeSession(prepared.mcpServerUrl, sid))}`, "-c", `mcp_servers.beevibe.bearer_token_env_var=${tomlString("BEEVIBE_AGENT_API_KEY")}`, "-c", `mcp_servers.beevibe.default_tools_approval_mode=${tomlString("approve")}`);
+    }
+    const args = context.resume_session_id ? [
+      ...globalArgs,
+      "exec",
+      "resume",
+      ...execArgs,
+      context.resume_session_id,
+      composePrompt(context)
+    ] : [...globalArgs, "exec", ...execArgs, composePrompt(context)];
+    const env2 = { ...process.env };
+    for (const key of OPENAI_AUTH_VARS)
+      delete env2[key];
+    if (context.env)
+      Object.assign(env2, context.env);
+    if (prepared)
+      env2.BEEVIBE_AGENT_API_KEY = prepared.agentApiKey;
+    const events = [];
+    let pending = "";
+    const handleLine = (line) => {
+      const evt = parseCodexEventLine(line);
+      if (!evt)
+        return;
+      events.push(evt);
+      if (!context.onStep)
+        return;
+      for (const step of extractCodexStepEvents(evt)) {
+        context.onStep(step);
+      }
+    };
+    const result = await runCliProcess({
+      command: this.config.command ?? "codex",
+      args,
+      cwd: context.workspace.path,
+      env: env2,
+      abortSignal: context.abort_signal,
+      onSpawn: ({ pid, process_group_id }) => {
+        context.onSpawn?.({ process_pid: pid, process_group_id });
       },
-      body: JSON.stringify(body)
+      onLog: (stream, chunk) => {
+        if (stream !== "stdout")
+          return;
+        pending += chunk;
+        let nl;
+        while ((nl = pending.indexOf(`
+`)) !== -1) {
+          handleLine(pending.slice(0, nl));
+          pending = pending.slice(nl + 1);
+        }
+      }
     });
-    if (res.status === 204)
-      return { status: 204, body: undefined };
-    const text = await res.text();
-    if (!text)
-      return { status: res.status, body: undefined };
+    if (pending)
+      handleLine(pending);
+    if (result.truncated) {
+      console.warn("[CodexRuntime] stdout truncated at 4MB — result parsing may be incomplete");
+    }
+    if (result.aborted) {
+      removeIfExists(lastMessagePath);
+      return {
+        status: "cancelled",
+        output: "Session cancelled.",
+        process_pid: result.pid ?? undefined,
+        process_group_id: result.process_group_id ?? undefined
+      };
+    }
+    const lastMessage = readIfExists(lastMessagePath);
+    removeIfExists(lastMessagePath);
+    const parsed = parseCodexEvents(events, result.exitCode, lastMessage);
+    const STDERR_TAIL_BYTES = 4096;
+    const stderrTail = parsed.status === "failed" && result.stderr ? result.stderr.slice(-STDERR_TAIL_BYTES) : undefined;
+    return {
+      ...parsed,
+      process_pid: result.pid ?? undefined,
+      process_group_id: result.process_group_id ?? undefined,
+      exit_code: result.exitCode,
+      ...stderrTail ? { stderr: stderrTail } : {}
+    };
+  }
+  async healthCheck() {
     try {
-      return { status: res.status, body: JSON.parse(text) };
+      const result = await runCliProcess({
+        command: this.config.command ?? "codex",
+        args: ["--version"],
+        cwd: tmpdir2(),
+        timeoutMs: 5000,
+        graceMs: 0
+      });
+      return {
+        healthy: result.exitCode === 0,
+        error: result.exitCode === 0 ? undefined : result.stderr.slice(-500)
+      };
     } catch {
-      return { status: res.status, body: undefined };
+      return {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "codex"}`
+      };
     }
   }
-  async claim(runtimeId) {
-    const res = await fetch(`${this.url("/runtime/claim")}?runtime_id=${encodeURIComponent(runtimeId)}`, {
-      method: "POST",
-      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
-    });
-    if (res.status === 204)
-      return;
-    if (res.status >= 400)
-      return;
-    return await res.json();
+  async shutdown() {}
+  skillsDir(workspace2) {
+    return join4(workspace2.path, ".codex", "skills");
   }
-  openWebSocket(runtimeIds) {
-    const wsUrl = this.cfg.apiUrl.replace(/^http/, "ws");
-    const url = `${wsUrl}/runtime/ws?runtime_ids=${runtimeIds.map(encodeURIComponent).join(",")}`;
-    return new WebSocket(url, {
-      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+  prepareWorkspace(context) {
+    this.prepared.set(context.workspace.path, {
+      agentApiKey: context.agentApiKey,
+      mcpServerUrl: context.mcpServerUrl
     });
   }
-  url(path2) {
-    return `${this.cfg.apiUrl}${path2}`;
+}
+function buildGlobalArgs(context, config) {
+  const args = [
+    "--sandbox",
+    "workspace-write",
+    "--ask-for-approval",
+    "never",
+    "--cd",
+    context.workspace.path
+  ];
+  const model = context.model ?? config.model;
+  if (model)
+    args.push("--model", model);
+  return args;
+}
+function composePrompt(context) {
+  if (context.system_prompt_append.length === 0)
+    return context.intent;
+  return [
+    "<beevibe_system_context>",
+    context.system_prompt_append,
+    "</beevibe_system_context>",
+    "",
+    context.intent
+  ].join(`
+`);
+}
+function withBeevibeSession(mcpServerUrl, sid) {
+  const url = new URL(mcpServerUrl);
+  url.searchParams.set("beevibe_session", sid);
+  return url.toString();
+}
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function readIfExists(path2) {
+  try {
+    return existsSync3(path2) ? readFileSync3(path2, "utf8") : "";
+  } catch {
+    return "";
   }
 }
-// src/spawner.ts
-async function runDispatch(deps, payload, abortSignal) {
-  const syntheticAgent = {
-    id: payload.agent_id,
-    api_key: payload.agent_api_key,
-    hierarchy_level: payload.agent_hierarchy_level,
-    runtime_config: { type: "claude" }
-  };
-  const ws = await deps.workspaceManager.ensureWorkspace({ agent: syntheticAgent });
-  console.log(`[daemon/spawn] sess=${payload.session_id} agent=${payload.agent_id} type=${payload.type} cwd=${ws.path}`);
-  const runtime3 = deps.runtime ?? new ClaudeCodeRuntime;
-  const buffer = [];
-  let flushTimer;
-  const flush = async () => {
-    if (buffer.length === 0)
-      return;
-    const events = buffer.splice(0);
-    try {
-      await deps.api.post("/runtime/events", { events });
-    } catch (err) {
-      console.warn("[daemon/spawner] /runtime/events POST failed; events dropped:", err instanceof Error ? err.message : String(err));
-    }
-  };
-  const scheduleFlush = () => {
-    if (flushTimer)
-      return;
-    flushTimer = setTimeout(() => {
-      flushTimer = undefined;
-      flush();
-    }, 250);
-  };
-  const onStep = (step) => {
-    buffer.push({
-      session_id: payload.session_id,
-      kind: step.kind,
-      content: step.description,
-      tool_name: step.tool
-    });
-    if (buffer.length >= 16)
+function removeIfExists(path2) {
+  try {
+    if (existsSync3(path2))
+      unlinkSync(path2);
+  } catch {}
+}
+
+// ../core/dist/adapters/opencode/runtime.js
+import { existsSync as existsSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join5 } from "node:path";
+
+// ../core/dist/adapters/opencode/stream-json.js
+var OPENCODE_EVENT_TYPE = {
+  Text: "text",
+  Reasoning: "reasoning",
+  ToolUse: "tool_use",
+  StepStart: "step_start",
+  StepFinish: "step_finish",
+  Error: "error"
+};
+var OPENCODE_TOOL_STATUS = {
+  Pending: "pending",
+  Running: "running",
+  Completed: "completed",
+  Error: "error"
+};
+function parseOpenCodeEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{"))
+    return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+}
+function extractOpenCodeStepEvents(evt) {
+  const now = new Date().toISOString();
+  if (evt.type === OPENCODE_EVENT_TYPE.Text) {
+    const text = evt.part?.text?.trim();
+    if (!text)
+      return [];
+    return [{ kind: "agent", description: text, timestamp: now }];
+  }
+  if (evt.type === OPENCODE_EVENT_TYPE.ToolUse) {
+    const part = evt.part;
+    if (!part)
+      return [];
+    const status = part.state?.status;
+    const isTerminal = status === OPENCODE_TOOL_STATUS.Completed || status === OPENCODE_TOOL_STATUS.Error;
+    return [
+      {
+        kind: isTerminal ? "tool_result" : "tool_call",
+        tool: part.tool ?? "unknown",
+        description: describeOpenCodeInput(part.state?.input),
+        timestamp: now
+      }
+    ];
+  }
+  return [];
+}
+var PREFERRED_OPENCODE_FIELDS = [
+  "file_path",
+  "path",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "intent"
+];
+function describeOpenCodeInput(input) {
+  if (typeof input === "string")
+    return input.slice(0, 200);
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return "";
+  const obj = input;
+  for (const key of PREFERRED_OPENCODE_FIELDS) {
+    const v = obj[key];
+    if (typeof v === "string" && v.length > 0)
+      return v.slice(0, 200);
+  }
+  return JSON.stringify(input).slice(0, 200);
+}
+function parseOpenCodeEvents(events, exitCode) {
+  let sessionId;
+  let sawUsage = false;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalReasoning = 0;
+  let totalCacheRead = 0;
+  let totalCacheWrite = 0;
+  let totalCost = 0;
+  const assistantTexts = [];
+  const transcriptParts = [];
+  let errorMessage;
+  for (const evt of events) {
+    if (evt.sessionID)
+      sessionId = evt.sessionID;
+    switch (evt.type) {
+      case OPENCODE_EVENT_TYPE.StepFinish: {
+        const part = evt.part;
+        if (!part)
+          break;
+        sawUsage = true;
+        totalCost += part.cost ?? 0;
+        totalInput += part.tokens?.input ?? 0;
+        totalOutput += part.tokens?.output ?? 0;
+        totalReasoning += part.tokens?.reasoning ?? 0;
+        totalCacheRead += part.tokens?.cache?.read ?? 0;
+        totalCacheWrite += part.tokens?.cache?.write ?? 0;
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.Text: {
+        const text = evt.part?.text;
+        if (text) {
+          assistantTexts.push(text);
+          transcriptParts.push(`[assistant] ${text}
+`);
+        }
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.ToolUse: {
+        const part = evt.part;
+        if (!part)
+          break;
+        const tool = part.tool ?? "unknown";
+        const status = part.state?.status;
+        if (status === OPENCODE_TOOL_STATUS.Completed || status === OPENCODE_TOOL_STATUS.Error) {
+          const detail = (part.state?.error ?? part.state?.output ?? "").slice(0, 200).replace(/\n/g, " ");
+          transcriptParts.push(detail ? `[tool_result from ${tool}] ${detail}
+` : `[tool_result from ${tool}]
+`);
+        } else {
+          transcriptParts.push(`[tool_call] ${tool}
+`);
+        }
+        break;
+      }
+      case OPENCODE_EVENT_TYPE.Error:
+        errorMessage = evt.error?.message ?? evt.result?.error?.message ?? errorMessage;
+        if (errorMessage)
+          transcriptParts.push(`[error] ${errorMessage}
+`);
+        break;
+      default:
+        break;
+    }
+  }
+  const assistantText = assistantTexts.join(`
+`).trim();
+  const failed = exitCode !== 0 || !!errorMessage;
+  const output = failed ? errorMessage || assistantText || bareCliExitMessage(exitCode) : assistantText || "Session completed.";
+  const usage = sawUsage ? {
+    input_tokens: totalInput,
+    output_tokens: totalOutput + totalReasoning,
+    cache_creation_input_tokens: totalCacheWrite,
+    cache_read_input_tokens: totalCacheRead,
+    cost_usd: totalCost
+  } : undefined;
+  return {
+    status: failed ? "failed" : "completed",
+    output,
+    transcript: transcriptParts.join("") || undefined,
+    cli_session_id: sessionId,
+    usage
+  };
+}
+
+// ../core/dist/adapters/opencode/runtime.js
+class OpenCodeRuntime {
+  config;
+  type = "opencode";
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async execute(context) {
+    const args = [
+      "run",
+      "--format",
+      "json",
+      "--dangerously-skip-permissions",
+      "--dir",
+      context.workspace.path
+    ];
+    const model = context.model ?? this.config.model;
+    if (model)
+      args.push("--model", model);
+    if (context.resume_session_id)
+      args.push("--session", context.resume_session_id);
+    args.push(composePrompt2(context));
+    const env2 = { ...process.env };
+    if (context.env)
+      Object.assign(env2, context.env);
+    const events = [];
+    let pending = "";
+    const handleLine = (line) => {
+      const evt = parseOpenCodeEventLine(line);
+      if (!evt)
+        return;
+      events.push(evt);
+      if (!context.onStep)
+        return;
+      for (const step of extractOpenCodeStepEvents(evt)) {
+        context.onStep(step);
+      }
+    };
+    const result = await runCliProcess({
+      command: this.config.command ?? "opencode",
+      args,
+      cwd: context.workspace.path,
+      env: env2,
+      abortSignal: context.abort_signal,
+      onSpawn: ({ pid, process_group_id }) => {
+        context.onSpawn?.({ process_pid: pid, process_group_id });
+      },
+      onLog: (stream, chunk) => {
+        if (stream !== "stdout")
+          return;
+        pending += chunk;
+        let nl;
+        while ((nl = pending.indexOf(`
+`)) !== -1) {
+          handleLine(pending.slice(0, nl));
+          pending = pending.slice(nl + 1);
+        }
+      }
+    });
+    if (pending)
+      handleLine(pending);
+    if (result.truncated) {
+      console.warn("[OpenCodeRuntime] stdout truncated at 4MB — result parsing may be incomplete");
+    }
+    if (result.aborted) {
+      return {
+        status: "cancelled",
+        output: "Session cancelled.",
+        process_pid: result.pid ?? undefined,
+        process_group_id: result.process_group_id ?? undefined
+      };
+    }
+    const parsed = parseOpenCodeEvents(events, result.exitCode);
+    const STDERR_TAIL_BYTES = 4096;
+    const stderrTail = parsed.status === "failed" && result.stderr ? result.stderr.slice(-STDERR_TAIL_BYTES) : undefined;
+    return {
+      ...parsed,
+      process_pid: result.pid ?? undefined,
+      process_group_id: result.process_group_id ?? undefined,
+      exit_code: result.exitCode,
+      ...stderrTail ? { stderr: stderrTail } : {}
+    };
+  }
+  async healthCheck() {
+    try {
+      const result = await runCliProcess({
+        command: this.config.command ?? "opencode",
+        args: ["--version"],
+        cwd: tmpdir3(),
+        timeoutMs: 5000,
+        graceMs: 0
+      });
+      return { healthy: result.exitCode === 0 };
+    } catch {
+      return {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "opencode"}`
+      };
+    }
+  }
+  async shutdown() {}
+  skillsDir(workspace2) {
+    return join5(workspace2.path, ".opencode", "skills");
+  }
+  prepareWorkspace(context) {
+    const configPath = join5(context.workspace.path, "opencode.json");
+    if (existsSync4(configPath))
+      return;
+    writeFileSync3(configPath, buildOpenCodeConfig(context.agentApiKey, context.mcpServerUrl), {
+      mode: 384
+    });
+  }
+}
+function composePrompt2(context) {
+  if (context.system_prompt_append.length === 0)
+    return context.intent;
+  return [
+    "<beevibe_system_context>",
+    context.system_prompt_append,
+    "</beevibe_system_context>",
+    "",
+    context.intent
+  ].join(`
+`);
+}
+function buildOpenCodeConfig(apiKey, mcpServerUrl) {
+  return JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    mcp: {
+      beevibe: {
+        type: "remote",
+        url: mcpServerUrl,
+        enabled: true,
+        oauth: false,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "X-Beevibe-Session": "{env:BEEVIBE_SESSION_ID}"
+        }
+      }
+    }
+  }, null, 2) + `
+`;
+}
+
+// ../core/dist/adapters/runtime-registry.js
+function createDefaultRuntimeRegistry() {
+  return {
+    claude: new ClaudeCodeRuntime({}),
+    codex: new CodexRuntime({}),
+    opencode: new OpenCodeRuntime({})
+  };
+}
+function runtimeMissingError(cli) {
+  return `No runtime registered for dispatch payload type '${cli}'`;
+}
+
+// src/api-client.ts
+import WebSocket from "ws";
+
+class ApiClient {
+  cfg;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async get(path2) {
+    const res = await fetch(this.url(path2), {
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+    if (res.status === 204 || res.status >= 400)
+      return;
+    return await res.json();
+  }
+  async post(path2, body) {
+    const res = await fetch(this.url(path2), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.cfg.daemonToken}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (res.status === 204)
+      return { status: 204, body: undefined };
+    const text = await res.text();
+    if (!text)
+      return { status: res.status, body: undefined };
+    try {
+      return { status: res.status, body: JSON.parse(text) };
+    } catch {
+      return { status: res.status, body: undefined };
+    }
+  }
+  async claim(runtimeId) {
+    const res = await fetch(`${this.url("/runtime/claim")}?runtime_id=${encodeURIComponent(runtimeId)}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+    if (res.status === 204)
+      return;
+    if (res.status >= 400)
+      return;
+    return await res.json();
+  }
+  openWebSocket(runtimeIds) {
+    const wsUrl = this.cfg.apiUrl.replace(/^http/, "ws");
+    const url = `${wsUrl}/runtime/ws?runtime_ids=${runtimeIds.map(encodeURIComponent).join(",")}`;
+    return new WebSocket(url, {
+      headers: { authorization: `Bearer ${this.cfg.daemonToken}` }
+    });
+  }
+  url(path2) {
+    return `${this.cfg.apiUrl}${path2}`;
+  }
+}
+
+// ../sandbox/dist/orchestrator.js
+import { spawn as spawn3 } from "node:child_process";
+import { mkdir as mkdir2, readFile as readFile2, readdir, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join7, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../sandbox/dist/docker.js
+import { spawn as spawn2 } from "node:child_process";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join6 } from "node:path";
+var DEFAULT_IMAGE = "python:3.12-slim";
+var DEFAULT_LIMITS = {
+  cmd_timeout_seconds: 300,
+  cpus: 2,
+  memory: "2g",
+  storage: "4g",
+  network: true
+};
+async function createSandbox(opts = {}) {
+  const image = opts.image ?? DEFAULT_IMAGE;
+  const limits = { ...DEFAULT_LIMITS, ...opts.limits ?? {} };
+  const id = generateId(opts.label ?? "bv-sbx");
+  const artifact_dir = await mkdtemp(join6(tmpdir4(), `${id}-artifacts-`));
+  const args = [
+    "run",
+    "--detach",
+    "--name",
+    id,
+    `--cpus=${limits.cpus}`,
+    `--memory=${limits.memory}`,
+    `--storage-opt=size=${limits.storage}`,
+    "--user",
+    "1000:1000",
+    "--tmpfs",
+    "/tmp:rw,size=512m",
+    "-v",
+    `${artifact_dir}:/sandbox/artifacts:rw`,
+    "--workdir",
+    "/sandbox",
+    "--entrypoint",
+    "tail"
+  ];
+  if (!limits.network) {
+    args.push("--network=none");
+  }
+  args.push(image, "-f", "/dev/null");
+  const result = await runDocker(args, { timeoutMs: 30000 });
+  if (result.exit_code !== 0) {
+    await rm(artifact_dir, { recursive: true, force: true }).catch(() => {});
+    throw new SandboxError(`Failed to create sandbox: ${result.stderr.trim() || "docker run exited " + result.exit_code}`);
+  }
+  return {
+    id,
+    image,
+    artifact_dir,
+    created_at: new Date
+  };
+}
+async function exec(sandbox, cmd, opts = {}) {
+  const cwd = opts.cwd ?? "/sandbox";
+  const timeoutMs = (opts.timeout_seconds ?? DEFAULT_LIMITS.cmd_timeout_seconds) * 1000;
+  const args = ["exec", "--workdir", cwd];
+  for (const [k, v] of Object.entries(opts.env ?? {})) {
+    args.push("--env", `${k}=${v}`);
+  }
+  args.push(sandbox.id, "sh", "-c", cmd);
+  const startedAt = Date.now();
+  const r = await runDocker(args, { timeoutMs });
+  return {
+    stdout: r.stdout,
+    stderr: r.stderr,
+    exit_code: r.exit_code,
+    timed_out: r.timed_out,
+    duration_seconds: (Date.now() - startedAt) / 1000
+  };
+}
+async function destroySandbox(sandbox) {
+  await runDocker(["rm", "-f", sandbox.id], { timeoutMs: 30000 }).catch(() => {});
+}
+async function prepareBaseEnvironment(sandbox) {
+  const r = await runDocker([
+    "exec",
+    "--user",
+    "0",
+    sandbox.id,
+    "sh",
+    "-c",
+    "apt-get update -qq && apt-get install -y -qq --no-install-recommends git curl ca-certificates && rm -rf /var/lib/apt/lists/* && mkdir -p /sandbox && chown -R 1000:1000 /sandbox"
+  ], { timeoutMs: 180000 });
+  if (r.exit_code !== 0) {
+    throw new SandboxError(`base prep failed (exit ${r.exit_code}): ${r.stderr.trim().slice(0, 500)}`);
+  }
+}
+
+class SandboxError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SandboxError";
+  }
+}
+function runDocker(args, opts) {
+  return new Promise((resolve) => {
+    const proc = spawn2("docker", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGKILL");
+    }, opts.timeoutMs);
+    proc.stdout?.on("data", (c) => {
+      stdout += c.toString("utf8");
+    });
+    proc.stderr?.on("data", (c) => {
+      stderr += c.toString("utf8");
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr: stderr + `
+<spawn-error>${err.message}</spawn-error>`,
+        exit_code: -1,
+        timed_out: timedOut
+      });
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr,
+        exit_code: code ?? -1,
+        timed_out: timedOut
+      });
+    });
+  });
+}
+function generateId(label) {
+  const suffix = randomBytes2(4).toString("hex");
+  const safe = label.toLowerCase().replace(/[^a-z0-9_-]/g, "-").slice(0, 32);
+  return `${safe}-${suffix}`;
+}
+
+// ../sandbox/dist/orchestrator.js
+var DEFAULT_PROMPT_HEADER = `You are a Beevibe sandbox child agent running inside a fresh Docker container.
+
+You have ONLY these five MCP tools to touch the container. They are in your
+tool list as deferred MCP tools — you MUST load each one via ToolSearch
+before using it. ToolSearch's "select:" form only accepts ONE tool name per
+call, so make five separate calls at the very start of your work:
+
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_exec", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_read_file", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_write_file", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_list", "max_results": 1 })
+  ToolSearch({ "query": "select:mcp__beevibe-sandbox__sandbox_export_artifact", "max_results": 1 })
+
+After those five ToolSearch calls, you may invoke the MCP tools directly:
+
+  mcp__beevibe-sandbox__sandbox_exec(cmd, cwd?, timeout_seconds?)
+  mcp__beevibe-sandbox__sandbox_read_file(path, max_bytes?)
+  mcp__beevibe-sandbox__sandbox_write_file(path, content)
+  mcp__beevibe-sandbox__sandbox_list(path)
+  mcp__beevibe-sandbox__sandbox_export_artifact(sandbox_path, title?)
+
+You have NO Bash, NO Read, NO Edit, NO Write tool — those will return errors.
+
+The container has Python 3.12, git, and curl pre-installed. Operate inside
+/sandbox. Use a project-local venv at /sandbox/venv.
+
+Your job: use the external repo the user gives you to produce a real artifact
+for the goal. Plan, install, run, verify, export. You succeed by exporting at
+least one artifact under /sandbox/artifacts/ via sandbox_export_artifact. Stop
+as soon as you've exported something useful — don't keep exploring. If you
+can't, write REASON.txt explaining why and export that.`;
+function nowIso() {
+  return new Date().toISOString();
+}
+var MAX_TRANSCRIPT_EVENTS = 500;
+var MAX_EVENT_TEXT_BYTES = 4000;
+function classifyStartupError(err) {
+  const raw = err instanceof Error ? err.message : String(err);
+  if (/Cannot connect to the Docker daemon/i.test(raw)) {
+    return "Docker isn't running. Start Docker Desktop and try the run again.";
+  }
+  if (/ENOENT.*docker/i.test(raw)) {
+    return "The `docker` CLI isn't on PATH. Install Docker Desktop (or set DOCKER_HOST).";
+  }
+  if (/no space left on device/i.test(raw)) {
+    return "Docker is out of disk. Prune containers/images or expand Docker Desktop's allotment.";
+  }
+  return raw;
+}
+async function runRepoAgent(opts) {
+  const state = {
+    run_id: opts.run_id,
+    status: "starting",
+    repo_url: opts.repo_url,
+    goal: opts.goal,
+    started_at: nowIso(),
+    transcript: [],
+    artifacts: []
+  };
+  const emit = () => opts.on_state?.({ ...state, transcript: state.transcript.slice(), artifacts: state.artifacts.slice() });
+  const log = (kind, text) => {
+    const trimmed = text.length > MAX_EVENT_TEXT_BYTES ? text.slice(0, MAX_EVENT_TEXT_BYTES) + `
+…[truncated ${text.length - MAX_EVENT_TEXT_BYTES} bytes]…` : text;
+    state.transcript.push({ at: nowIso(), kind, text: trimmed });
+    if (state.transcript.length > MAX_TRANSCRIPT_EVENTS) {
+      const overflow = state.transcript.length - MAX_TRANSCRIPT_EVENTS;
+      state.transcript.splice(1, overflow);
+      const alreadyMarked = state.transcript[1]?.text.startsWith("[log truncated:");
+      if (!alreadyMarked) {
+        state.transcript.splice(1, 0, {
+          at: nowIso(),
+          kind: "log",
+          text: `[log truncated: dropped ${overflow} earlier event${overflow === 1 ? "" : "s"}]`
+        });
+      }
+    }
+    emit();
+  };
+  let sandbox = null;
+  try {
+    log("log", "Creating sandbox container…");
+    state.status = "preparing";
+    emit();
+    try {
+      sandbox = await createSandbox({ label: `bv-run-${opts.run_id}` });
+    } catch (err) {
+      throw new Error(classifyStartupError(err));
+    }
+    state.sandbox_id = sandbox.id;
+    log("log", `Sandbox ${sandbox.id} created (image ${sandbox.image}).`);
+    log("log", "Installing git + curl in the sandbox base image…");
+    await prepareBaseEnvironment(sandbox);
+    log("log", "Base environment ready.");
+    if (opts.input_url) {
+      const filename = opts.input_filename ?? "input.bin";
+      log("log", `Fetching input into /sandbox/inputs/${filename}…`);
+      const r = await exec(sandbox, `mkdir -p /sandbox/inputs && curl -fsSL ${shellQuote(opts.input_url)} -o /sandbox/inputs/${shellQuote(filename)}`, { timeout_seconds: 120 });
+      if (r.exit_code !== 0) {
+        throw new Error(`input fetch failed: ${r.stderr.trim().slice(0, 400)}`);
+      }
+      log("log", "Input file ready.");
+    }
+    const mcpServerCommand = opts.mcp_server_command ?? defaultMcpServerCommand();
+    const mcpConfigPath = join7(sandbox.artifact_dir, "mcp-config.json");
+    const mcpConfig = {
+      mcpServers: {
+        "beevibe-sandbox": {
+          command: mcpServerCommand.command,
+          args: mcpServerCommand.args,
+          env: {
+            BEEVIBE_SANDBOX_ID: sandbox.id,
+            BEEVIBE_SANDBOX_ARTIFACTS: sandbox.artifact_dir
+          }
+        }
+      }
+    };
+    await writeFile2(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+    log("log", `MCP config written: ${mcpConfigPath}`);
+    const userPrompt = buildUserPrompt(opts);
+    const systemPromptAppend = DEFAULT_PROMPT_HEADER;
+    state.status = "running";
+    log("log", "Spawning child claude session…");
+    emit();
+    const claudeResult = await runClaude({
+      claudeBin: opts.claude_bin ?? "claude",
+      mcpConfigPath,
+      systemPromptAppend,
+      userPrompt,
+      maxBudgetUsd: opts.max_budget_usd ?? 2,
+      timeoutSeconds: opts.max_runtime_seconds ?? 600,
+      onTranscript: (kind, text) => log(kind, text)
+    });
+    if (claudeResult.exit_code !== 0 && claudeResult.exit_code !== null) {
+      const tail = claudeResult.stderr.slice(-500);
+      log("error", `Child claude exited with code ${claudeResult.exit_code}: ${tail}`);
+      state.status = claudeResult.timed_out ? "blocked" : "failed";
+      state.error = claudeResult.timed_out ? `Run hit the ${opts.max_runtime_seconds ?? 600}s wall-clock budget — agent didn't finish in time.` : `Claude exited ${claudeResult.exit_code}.${tail ? " " + tail.slice(-200) : ""}`;
+      state.finished_at = nowIso();
+      emit();
+      return state;
+    }
+    log("log", "Child claude exited cleanly. Collecting artifacts…");
+    state.artifacts = await collectArtifacts(sandbox);
+    if (state.artifacts.length === 0) {
+      state.status = "blocked";
+      state.error = "agent produced no artifacts";
+    } else {
+      state.status = "succeeded";
+    }
+    state.finished_at = nowIso();
+    emit();
+    return state;
+  } catch (err) {
+    log("error", err instanceof Error ? err.message : String(err));
+    state.status = "failed";
+    state.error = err instanceof Error ? err.message : String(err);
+    state.finished_at = nowIso();
+    emit();
+    return state;
+  } finally {
+    if (sandbox) {
+      try {
+        log("log", `Destroying sandbox ${sandbox.id}…`);
+        await destroySandbox(sandbox);
+      } catch (err) {
+        log("log", `Sandbox cleanup note: ${err instanceof Error ? err.message : String(err)}. Run with \`docker ps -a --filter name=bv-run-\` to inspect.`);
+      }
+    }
+  }
+}
+function buildUserPrompt(opts) {
+  const lines = [
+    `Goal: ${opts.goal}`,
+    `Repo: ${opts.repo_url}`
+  ];
+  if (opts.input_url) {
+    lines.push(`Input file (pre-fetched): /sandbox/inputs/${opts.input_filename ?? "input.bin"}`);
+  }
+  lines.push("");
+  lines.push("Work inside /sandbox. Clone the repo to /sandbox/repo. Install in a venv. ");
+  lines.push("Produce at least one artifact under /sandbox/artifacts/, then call ");
+  lines.push("sandbox_export_artifact() on each one with a short, human-readable title. ");
+  lines.push("Stop as soon as you've exported a useful artifact — don't keep exploring.");
+  return lines.join(`
+`);
+}
+var ALLOWED_TOOLS = [
+  "mcp__beevibe-sandbox__sandbox_exec",
+  "mcp__beevibe-sandbox__sandbox_read_file",
+  "mcp__beevibe-sandbox__sandbox_write_file",
+  "mcp__beevibe-sandbox__sandbox_list",
+  "mcp__beevibe-sandbox__sandbox_export_artifact"
+];
+var DISALLOWED_TOOLS = ["Bash", "Read", "Edit", "Write", "BashOutput", "KillBash"];
+function runClaude(args) {
+  return new Promise((resolve2) => {
+    const cliArgs = [
+      "--print",
+      "--mcp-config",
+      args.mcpConfigPath,
+      "--allowed-tools",
+      ALLOWED_TOOLS.join(","),
+      "--disallowed-tools",
+      DISALLOWED_TOOLS.join(","),
+      "--append-system-prompt",
+      args.systemPromptAppend,
+      "--max-budget-usd",
+      String(args.maxBudgetUsd),
+      "--output-format",
+      "stream-json",
+      "--verbose"
+    ];
+    const proc = spawn3(args.claudeBin, cliArgs, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+      detached: true
+    });
+    proc.unref();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let stdoutBuffer = "";
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => proc.kill("SIGKILL"), 5000);
+    }, args.timeoutSeconds * 1000);
+    proc.stdout.on("data", (chunk) => {
+      const s = chunk.toString("utf8");
+      stdout += s;
+      stdoutBuffer += s;
+      let nl;
+      while ((nl = stdoutBuffer.indexOf(`
+`)) !== -1) {
+        const line = stdoutBuffer.slice(0, nl);
+        stdoutBuffer = stdoutBuffer.slice(nl + 1);
+        if (line.trim().length === 0)
+          continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt && typeof evt === "object" && evt.type === "system" && evt.subtype === "init") {
+            const init = evt;
+            const servers = init.mcp_servers;
+            if (servers) {
+              for (const sv of servers) {
+                args.onTranscript("log", `mcp server ${sv.name}: ${sv.status}`);
+              }
+            }
+            const tools = init.tools;
+            const mcpTools = (tools ?? []).filter((t) => t.startsWith("mcp__beevibe-sandbox__"));
+            args.onTranscript("log", `mcp tools exposed: ${mcpTools.length ? mcpTools.join(", ") : "none"}`);
+          }
+          handleStreamEvent(evt, args.onTranscript);
+        } catch {}
+      }
+    });
+    proc.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      const friendly = /ENOENT/i.test(err.message) ? `Claude CLI not found at ${args.claudeBin}. Set BEEVIBE_CLAUDE_BIN to the binary path.` : `claude spawn error: ${err.message}`;
+      args.onTranscript("error", friendly);
+      resolve2({ exit_code: -1, stdout, stderr, timed_out: timedOut });
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0 && code !== null) {
+        const tail = stderr.slice(-800).trim();
+        if (tail) {
+          args.onTranscript("error", `claude stderr tail: ${tail}`);
+        }
+      }
+      resolve2({ exit_code: code, stdout, stderr, timed_out: timedOut });
+    });
+    proc.stdin.write(args.userPrompt);
+    proc.stdin.end();
+  });
+}
+function handleStreamEvent(evt, emit) {
+  if (!evt || typeof evt !== "object")
+    return;
+  const e = evt;
+  const t = e.type;
+  if (t === "assistant" || t === "assistant_message") {
+    const message = e.message;
+    if (message && Array.isArray(message.content)) {
+      for (const item of message.content) {
+        if (!item || typeof item !== "object")
+          continue;
+        const it = item;
+        if (it.type === "text" && typeof it.text === "string") {
+          emit("agent", it.text);
+        } else if (it.type === "tool_use") {
+          const name = String(it.name ?? "unknown");
+          const input = it.input ? compactJson(it.input) : "";
+          emit("tool_call", `${name}(${input})`);
+        }
+      }
+    } else if (typeof e.content === "string") {
+      emit("agent", e.content);
+    }
+  } else if (t === "user" || t === "user_message") {
+    const message = e.message;
+    if (message && Array.isArray(message.content)) {
+      for (const item of message.content) {
+        if (!item || typeof item !== "object")
+          continue;
+        const it = item;
+        if (it.type === "tool_result") {
+          const content = it.content;
+          let text;
+          if (typeof content === "string") {
+            text = content;
+          } else if (Array.isArray(content)) {
+            text = content.map((c) => c && typeof c === "object" && typeof c.text === "string" ? c.text : "").filter(Boolean).join(" ");
+          } else {
+            text = JSON.stringify(content ?? null);
+          }
+          const isErr = it.is_error === true;
+          emit(isErr ? "error" : "tool_call", `→ ${text.slice(0, 300)}${text.length > 300 ? "…" : ""}`);
+        }
+      }
+    }
+  } else if (t === "result" && typeof e.result === "string") {
+    emit("agent", e.result);
+  } else if (t === "error") {
+    emit("error", typeof e.message === "string" ? e.message : "claude error");
+  }
+}
+function compactJson(v) {
+  try {
+    const s = JSON.stringify(v);
+    return s.length > 200 ? s.slice(0, 200) + "…" : s;
+  } catch {
+    return "?";
+  }
+}
+async function collectArtifacts(sandbox) {
+  const out = [];
+  await mkdir2(sandbox.artifact_dir, { recursive: true });
+  const entries = await readdir(sandbox.artifact_dir);
+  const sidecars = new Map;
+  for (const e of entries) {
+    if (e.endsWith(".meta.json")) {
+      try {
+        const raw = await readFile2(join7(sandbox.artifact_dir, e), "utf8");
+        sidecars.set(e.replace(/\.meta\.json$/, ""), JSON.parse(raw));
+      } catch {}
+    }
+  }
+  for (const e of entries) {
+    if (e.endsWith(".meta.json") || e === "mcp-config.json")
+      continue;
+    const hostPath = join7(sandbox.artifact_dir, e);
+    const stat = await readFile2(hostPath).then((b) => ({ size: b.byteLength }), () => null);
+    if (!stat)
+      continue;
+    const meta = sidecars.get(e);
+    out.push({
+      filename: e,
+      title: typeof meta?.title === "string" && meta.title || e.replace(/\.[^.]+$/, ""),
+      size_bytes: stat.size,
+      host_path: hostPath,
+      sandbox_path: typeof meta?.sandbox_path === "string" && meta.sandbox_path || undefined
+    });
+  }
+  return out;
+}
+function defaultMcpServerCommand() {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const isTsxRun = here.endsWith("/src");
+  const mcpServerPath = resolve(here, isTsxRun ? "./mcp-server.ts" : "./mcp-server.js");
+  return isTsxRun ? { command: "npx", args: ["--no-install", "tsx", mcpServerPath] } : { command: "node", args: ["--enable-source-maps", mcpServerPath] };
+}
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/repo-runs.ts
+var CLAUDE_BIN = process.env.BEEVIBE_CLAUDE_BIN ?? "claude";
+async function runRepoDispatch(deps, payload, abortSignal) {
+  const rr = payload.run_repo;
+  if (!rr) {
+    throw new Error("run_repo dispatch missing payload.run_repo");
+  }
+  console.log(`[daemon/repo-run] sess=${payload.session_id} repo_run=${rr.repo_run_id} repo=${rr.repo_url}`);
+  const buffer = [];
+  let flushTimer;
+  const flush = async () => {
+    if (buffer.length === 0)
+      return;
+    const events = buffer.splice(0);
+    try {
+      await deps.api.post("/runtime/events", { events });
+    } catch (err) {
+      console.warn("[daemon/repo-run] /runtime/events POST failed:", err instanceof Error ? err.message : String(err));
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      flush();
+    }, 250);
+  };
+  let pushedUpTo = 0;
+  const pushNew = (transcript) => {
+    for (let i = pushedUpTo;i < transcript.length; i++) {
+      const ev = transcript[i];
+      if (!ev)
+        continue;
+      buffer.push({
+        session_id: payload.session_id,
+        kind: mapKind(ev.kind),
+        content: ev.text
+      });
+    }
+    pushedUpTo = transcript.length;
+    if (buffer.length >= 16)
+      flush();
+    else
+      scheduleFlush();
+  };
+  const installLines = [];
+  let invocation;
+  const noteCommandFromToolCall = (text) => {
+    const m = text.match(/sandbox_exec\(\{?"?cmd"?:?\s*"([^"]+)"/);
+    if (!m)
+      return;
+    const cmd = m[1] ?? "";
+    if (!cmd)
+      return;
+    if (isInstallCommand(cmd))
+      installLines.push(cmd);
+    else
+      invocation = cmd;
+  };
+  const result = await runRepoAgent({
+    run_id: rr.repo_run_id,
+    repo_url: rr.repo_url,
+    goal: rr.goal,
+    input_url: rr.input_url,
+    input_filename: rr.input_filename,
+    claude_bin: CLAUDE_BIN,
+    max_runtime_seconds: (rr.limits?.wall_clock_minutes ?? 20) * 60,
+    on_state: (s) => {
+      pushNew(s.transcript);
+      for (let i = pushedUpTo - (s.transcript.length - 0);i < s.transcript.length; i++) {
+        if (i < 0)
+          continue;
+        const ev = s.transcript[i];
+        if (ev?.kind === "tool_call")
+          noteCommandFromToolCall(ev.text);
+      }
+      if (abortSignal?.aborted) {
+        buffer.push({
+          session_id: payload.session_id,
+          kind: "summary",
+          content: "[run cancelled by user]"
+        });
+        flush();
+      }
+    }
+  });
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = undefined;
+  }
+  await flush();
+  const status = result.status === "succeeded" ? "succeeded" : result.status === "blocked" ? "failed" : result.status === "failed" ? "failed" : "failed";
+  const artifacts = result.artifacts.map((a) => ({
+    filename: a.filename,
+    title: a.title,
+    size_bytes: a.size_bytes,
+    host_path: a.host_path,
+    sandbox_path: a.sandbox_path
+  }));
+  const done = {
+    session_id: payload.session_id,
+    status,
+    result_summary: result.status === "succeeded" ? `Exported ${artifacts.length} artifact${artifacts.length === 1 ? "" : "s"}.` : result.error ?? "Run did not produce an artifact.",
+    error: result.error,
+    run_repo: {
+      repo_run_id: rr.repo_run_id,
+      install_log: installLines.length ? installLines.join(`
+`) : undefined,
+      invocation,
+      artifacts
+    }
+  };
+  if (status === "succeeded") {
+    console.log(`[daemon/repo-run] sess=${payload.session_id} succeeded artifacts=${artifacts.length}`);
+  } else {
+    console.error(`[daemon/repo-run] sess=${payload.session_id} status=${status}` + (result.error ? `
+  error:
+    ${result.error.split(`
+`).join(`
+    `)}` : ""));
+  }
+  try {
+    await deps.api.post("/runtime/done", done);
+  } catch (err) {
+    console.error("[daemon/repo-run] /runtime/done POST failed:", err instanceof Error ? err.message : String(err));
+  }
+}
+function mapKind(kind) {
+  switch (kind) {
+    case "agent":
+      return "agent";
+    case "tool_call":
+      return "tool_call";
+    case "log":
+      return "summary";
+    case "error":
+      return "tool_result";
+  }
+}
+function isInstallCommand(cmd) {
+  return /^(pip\s|pip3\s|apt-get\s|apt\s|brew\s|npm\s+(install|i)|yarn\s+(add|install)|pnpm\s+(add|install)|git\s+clone)/.test(cmd.trim());
+}
+
+// src/spawner.ts
+async function runDispatch(deps, payload, abortSignal) {
+  if (payload.type === "run_repo") {
+    await runRepoDispatch({ api: deps.api }, payload, abortSignal);
+    return;
+  }
+  const syntheticAgent = {
+    id: payload.agent_id,
+    api_key: payload.agent_api_key,
+    hierarchy_level: payload.agent_hierarchy_level,
+    runtime_config: { type: payload.runtime_type }
+  };
+  const ws = await deps.workspaceManager.ensureWorkspace({ agent: syntheticAgent });
+  console.log(`[daemon/spawn] sess=${payload.session_id} agent=${payload.agent_id} runtime=${payload.runtime_type} type=${payload.type} cwd=${ws.path}`);
+  const registry = deps.runtimeRegistry ?? createDefaultRuntimeRegistry();
+  const runtime3 = registry[payload.runtime_type];
+  if (!runtime3) {
+    throw new Error(runtimeMissingError(payload.runtime_type));
+  }
+  const buffer = [];
+  let flushTimer;
+  const flush = async () => {
+    if (buffer.length === 0)
+      return;
+    const events = buffer.splice(0);
+    try {
+      await deps.api.post("/runtime/events", { events });
+    } catch (err) {
+      console.warn("[daemon/spawner] /runtime/events POST failed; events dropped:", err instanceof Error ? err.message : String(err));
+    }
+  };
+  const scheduleFlush = () => {
+    if (flushTimer)
+      return;
+    flushTimer = setTimeout(() => {
+      flushTimer = undefined;
+      flush();
+    }, 250);
+  };
+  const onStep = (step) => {
+    buffer.push({
+      session_id: payload.session_id,
+      kind: step.kind,
+      content: step.description,
+      tool_name: step.tool
+    });
+    if (buffer.length >= 16)
       flush();
     else
       scheduleFlush();
@@ -1206,12 +2613,22 @@ class Claimer {
   }
   async pollRuntime(runtimeId) {
     while (this.running && this.cfg.supervisor.hasCapacity()) {
-      const payload = await this.cfg.api.claim(runtimeId);
+      let payload;
+      try {
+        payload = await this.cfg.api.claim(runtimeId);
+      } catch (err) {
+        console.warn(`[daemon] claim failed for runtime=${runtimeId}:`, err instanceof Error ? err.message : String(err));
+        return;
+      }
       if (!payload)
         return;
       console.log(`[daemon/claim] sess=${payload.session_id} agent=${payload.agent_id} runtime=${runtimeId}`);
       const ctrl = this.cfg.supervisor.start(payload.session_id);
-      runDispatch({ api: this.cfg.api, workspaceManager: this.cfg.workspaceManager }, payload, ctrl.signal).catch((err) => console.error(`[daemon] dispatch ${payload.session_id} failed:`, err instanceof Error ? err.message : String(err))).finally(() => this.cfg.supervisor.finish(payload.session_id));
+      runDispatch({
+        api: this.cfg.api,
+        workspaceManager: this.cfg.workspaceManager,
+        runtimeRegistry: this.cfg.runtimeRegistry
+      }, payload, ctrl.signal).catch((err) => console.error(`[daemon] dispatch ${payload.session_id} failed:`, err instanceof Error ? err.message : String(err))).finally(() => this.cfg.supervisor.finish(payload.session_id));
     }
   }
 }
@@ -1219,14 +2636,14 @@ class Claimer {
 // src/skills-cache.ts
 import { promises as fs2 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join8 } from "node:path";
 function skillsCacheDir() {
-  return join4(homedir3(), ".beevibe", "skills");
+  return join8(homedir3(), ".beevibe", "skills");
 }
 var VERSION_FILE = ".version";
 async function readCachedVersion() {
   try {
-    return (await fs2.readFile(join4(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
+    return (await fs2.readFile(join8(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
   } catch {
     return;
   }
@@ -1247,19 +2664,19 @@ async function syncSkillsCache(api) {
     if (!dirent.isDirectory())
       continue;
     if (dirent.name === "beevibe" || dirent.name.startsWith("beevibe-")) {
-      await fs2.rm(join4(cache, dirent.name), { recursive: true, force: true });
+      await fs2.rm(join8(cache, dirent.name), { recursive: true, force: true });
     }
   }
   for (const skill of res.skills) {
-    const skillDir = join4(cache, skill.name);
+    const skillDir = join8(cache, skill.name);
     await fs2.mkdir(skillDir, { recursive: true, mode: 448 });
     for (const file of skill.files) {
-      const filePath = join4(skillDir, file.path);
-      await fs2.mkdir(join4(filePath, ".."), { recursive: true });
+      const filePath = join8(skillDir, file.path);
+      await fs2.mkdir(join8(filePath, ".."), { recursive: true });
       await fs2.writeFile(filePath, file.content, { mode: 384 });
     }
   }
-  await fs2.writeFile(join4(cache, VERSION_FILE), res.version, { mode: 384 });
+  await fs2.writeFile(join8(cache, VERSION_FILE), res.version, { mode: 384 });
   return cache;
 }
 
@@ -1338,6 +2755,7 @@ async function runStart() {
     api,
     supervisor,
     workspaceManager,
+    runtimeRegistry,
     runtimeIds: cfg.runtimes.map((r) => r.id)
   });
   claimer.start();
@@ -1353,16 +2771,46 @@ async function runStart() {
   };
   process.on("SIGINT", () => void stop("SIGINT"));
   process.on("SIGTERM", () => void stop("SIGTERM"));
+  process.on("unhandledRejection", (reason) => {
+    console.warn("[daemon] unhandledRejection (continuing):", reason instanceof Error ? reason.message : String(reason));
+  });
   await new Promise(() => {
     return;
   });
 }
 
+// src/sync.ts
+async function runSync() {
+  const config = loadConfig();
+  if (!config) {
+    throw new Error(`No daemon config at ${CONFIG_PATH}. Run 'beevibe-daemon setup' first.`);
+  }
+  const detected = await detectClis();
+  if (detected.length === 0) {
+    throw new Error(`No supported CLIs detected on PATH. beevibe currently looks for: ${KNOWN_CLIS.join(", ")}`);
+  }
+  const api = new ApiClient({
+    apiUrl: config.api_url,
+    daemonToken: config.daemon_token
+  });
+  const { status, body } = await api.post("/runtime/sync", {
+    runtimes: detected
+  });
+  if (status !== 200 || !body) {
+    throw new Error(`/runtime/sync failed: ${status}`);
+  }
+  const before = new Set(config.runtimes.map((r) => r.cli));
+  const added = body.runtimes.filter((r) => !before.has(r.cli));
+  const next = { ...config, runtimes: body.runtimes };
+  saveConfig(next);
+  return { added, runtimes: body.runtimes };
+}
+
 // src/update.ts
 import { createHash } from "node:crypto";
 import { createWriteStream, mkdtempSync, rmSync as rmSync2, chmodSync, renameSync } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { tmpdir as tmpdir5 } from "node:os";
+import { join as join9 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
@@ -1376,7 +2824,7 @@ var PLATFORM_ASSETS = {
   "linux-arm64": "beevibe-daemon-linux-arm64"
 };
 function currentVersion() {
-  return "0.1.2";
+  return "0.1.4";
 }
 function isCompiledBinary() {
   if (!process.versions.bun)
@@ -1489,8 +2937,8 @@ async function runUpdate(opts = {}) {
       return;
     }
   }
-  const stagingDir = mkdtempSync(join5(tmpdir2(), "beevibe-daemon-update-"));
-  const stagingPath = join5(stagingDir, asset);
+  const stagingDir = mkdtempSync(join9(tmpdir5(), "beevibe-daemon-update-"));
+  const stagingPath = join9(stagingDir, asset);
   try {
     console.log(`Downloading ${asset}…`);
     const downloadUrl = `${DOWNLOAD_BASE}/${latest}/${asset}`;
@@ -1548,6 +2996,7 @@ function printHelp() {
     "Commands:",
     "  setup    Register this machine with a beevibe api server.",
     "  start    Run the daemon: claim pending sessions and spawn the CLI.",
+    "  sync     Re-detect CLIs on PATH and register newly-installed ones.",
     "  update   Check for and install a newer daemon binary (brew/curl installs).",
     "",
     "setup flags:",
@@ -1589,6 +3038,16 @@ async function main() {
     await runStart();
     return;
   }
+  if (command === "sync") {
+    const result = await runSync();
+    if (result.added.length === 0) {
+      console.log("No new CLIs detected.");
+    } else {
+      console.log(`Added ${result.added.length} runtime(s): ${result.added.map((r) => `${r.cli} (${r.id})`).join(", ")}.`);
+      console.log("Restart the daemon to pick up the new runtime(s).");
+    }
+    return;
+  }
   if (command === "update") {
     const skipPrompt = rest.includes("--yes") || rest.includes("-y");
     await runUpdate({ skipPrompt });