@beevibe/daemon 0.1.1 → 0.1.3

package/dist/main.js

@@ -2,8 +2,206 @@
 
 // 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";
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function random(bytes) {
+  fillPool(bytes |= 0);
+  return pool.subarray(poolOffset - bytes, poolOffset);
+}
+function customRandom(alphabet, defaultSize, getRandom) {
+  let safeByteCutoff = 256 - 256 % alphabet.length;
+  if (safeByteCutoff === 256) {
+    let mask = alphabet.length - 1;
+    return (size = defaultSize) => {
+      if (!size)
+        return "";
+      let id = "";
+      while (true) {
+        let bytes = getRandom(size);
+        let i = size;
+        while (i--) {
+          id += alphabet[bytes[i] & mask];
+          if (id.length >= size)
+            return id;
+        }
+      }
+    };
+  }
+  let step = Math.ceil(1.6 * 256 * defaultSize / safeByteCutoff);
+  return (size = defaultSize) => {
+    if (!size)
+      return "";
+    let id = "";
+    while (true) {
+      let bytes = getRandom(step);
+      let i = step;
+      while (i--) {
+        if (bytes[i] < safeByteCutoff) {
+          id += alphabet[bytes[i] % alphabet.length];
+          if (id.length >= size)
+            return id;
+        }
+      }
+    }
+  };
+}
+function customAlphabet(alphabet, size = 21) {
+  return customRandom(alphabet, size, random);
+}
+
+// ../core/dist/domain/ids.js
+var alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var nanoid12 = customAlphabet(alphabet, 12);
+// ../core/dist/domain/core-memory.js
+var DEFAULT_BLOCK_TEMPLATES = {
+  ic: [
+    {
+      block_name: "tag_line",
+      char_limit: 100,
+      is_system: true,
+      initial_content: "",
+      description: "One-line headline of my enduring specialization — shown on agent " + "cards in the UI. Describes what I'm an expert in, not what " + "project I'm currently on. Examples: 'Go backend specialist " + "(Chi/sqlc, websockets)', 'Next.js + React UI lead'. Max 100 " + "chars. Update only when my specialization itself shifts."
+    },
+    {
+      block_name: "persona",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Who I am and how I work — my role and working style, persistent " + "across every project I touch. 1-3 sentences in first person. " + "Update when my self-conception genuinely shifts (acquired a " + "major capability, refined my approach). NOT my current project " + "(that's `active_context`), NOT my domain scope (that's `domain`)."
+    },
+    {
+      block_name: "domain",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "The areas I specialize in ACROSS all projects — my enduring " + "expertise. As I work on more projects in my domain, this can " + "deepen (becoming truly expert in narrower sub-areas). Bullet " + "format. Example: 'Go backend services: HTTP via Chi/echo, DB " + "via sqlc, websockets via gorilla, distribution via goreleaser.' " + "NOT project-specific paths (those go in `active_context`). NOT " + "the rules I follow (those go in `constraints`)."
+    },
+    {
+      block_name: "active_context",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "What I'm currently working on — the specific project and its " + "in-flight details. Bullet format. Example: 'Project: " + "github.com/multica-ai/multica. Local clone: /tmp/multica-repo. " + "Owned paths in this project: server/cmd/**, server/internal/**. " + "Current task: task_xfQpuEHWjbvk.' Transient — rewrite when the " + "project changes. This is where ALL project/codebase-specific " + "details live, NOT in `domain`."
+    },
+    {
+      block_name: "constraints",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Hard rules I follow — non-negotiable conventions and " + "coordination boundaries. Mix of persistent rules ('queries " + "always via sqlc — never hand-write the DB layer') and " + "project-specific rules ('read /CLAUDE.md before changes in " + "this codebase'). Bullet format. Reference docs by path, not " + "content."
+    }
+  ],
+  team: [
+    {
+      block_name: "tag_line",
+      char_limit: 100,
+      is_system: true,
+      initial_content: "",
+      description: "One-line headline of my enduring role — shown on agent cards. " + "Describes the team I lead, not the project we're on. Examples: " + "'Daniel's team — orchestrates 3 backend/frontend/platform " + "specialists', 'Solo lead — driving a small team for hire'. " + "Max 100 chars."
+    },
+    {
+      block_name: "persona",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Who I am as a team lead — my orchestration style and how I " + "delegate. 1-3 sentences in first person. Persistent across " + "projects. NOT my team roster (that's `team_members`), NOT the " + "current work (that's `active_work`)."
+    },
+    {
+      block_name: "team_members",
+      char_limit: 3000,
+      is_system: true,
+      initial_content: "",
+      description: "Roster of my direct reports — for each: name, agent_id, " + "specialization (NOT project assignment — same agents stay over " + "time as we work different projects). Bullet format. Update " + "when subordinates are spawned/archived/reassigned."
+    },
+    {
+      block_name: "active_work",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "What my team is currently working on — the active project + " + "high-level work in flight across specialists. Bullet format. " + "Example: 'Project: github.com/multica-ai/multica. Backend " + "specialist running CLI audit (task_xfQpuEHWjbvk); Frontend on " + "standby.' Transient — rewrite on project shifts."
+    },
+    {
+      block_name: "patterns",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Cross-project patterns I've observed in how my team operates — " + "what works, what trips them up. Persistent. Example: 'When I " + "assign an audit task, the IC tends to produce thorough work " + "products but forgets to save_memory mid-pass.' NOT specific " + "findings about a codebase (those go in archival memory via " + "save_memory)."
+    }
+  ],
+  org: [
+    {
+      block_name: "tag_line",
+      char_limit: 100,
+      is_system: true,
+      initial_content: "",
+      description: "One-line headline of my org-level role — shown on agent cards. " + "Describes the scope I oversee, not the current project. " + "Examples: 'Eng org lead — 3 teams (product/platform/infra)'. " + "Max 100 chars."
+    },
+    {
+      block_name: "persona",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Who I am as an org leader — my decision style and how I balance " + "across teams. 1-3 sentences. Persistent."
+    },
+    {
+      block_name: "teams",
+      char_limit: 3000,
+      is_system: true,
+      initial_content: "",
+      description: "Teams under my oversight — for each: name, team-lead agent_id, " + "scope. Persistent identity. Bullet format."
+    },
+    {
+      block_name: "strategy",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Cross-project / cross-team direction I'm driving. Higher-level " + "than active_work. Examples: 'Q2 focus: ship Multica self-host " + "v1', 'Hiring: prioritize backend over frontend this quarter'."
+    },
+    {
+      block_name: "decisions",
+      char_limit: 2000,
+      is_system: true,
+      initial_content: "",
+      description: "Cross-team decisions I've resolved — bullet log. Each entry: " + "what was decided, when, why. Persistent record so the same " + "question doesn't come back up."
+    }
+  ]
+};
+// ../core/dist/domain/memory.js
+var FACT_TYPE_DESCRIPTIONS = {
+  belief: "A position you hold based on multiple sessions of evidence. A lasting view, " + "not a fleeting reaction to one session.",
+  pattern: "A recurring observation about the codebase or the domain you work in — " + "knowledge another agent could reuse. NOT a pattern about your own behavior " + "(your search habits, your memory-keeping, how you should have responded next " + "time). Save the thing you learned about the world, not a note-to-self about " + "how to behave.",
+  gotcha: "A non-obvious thing-that-bites — a footgun that's easy to step on, where the " + "surprise itself is the value. Concrete and reusable across future tasks in " + "the same area.",
+  preference: `A user's stated durable rule. Trigger words: "always", "from now on", ` + '"every time", "as a default", "going forward". Do NOT save preferences ' + "for one-off requests scoped to a specific task, session, or work-product " + '("after this task", "for this audit", "now"). When in doubt, just do the ' + "thing once without saving — the user can restate it if they want it to stick.",
+  decision: 'A chosen path with rationale. The "why" that future-you (or another agent) ' + "needs to understand why the codebase / approach looks the way it does — not " + 'the mechanical "what" (read the code for that).'
+};
+// ../core/dist/domain/runtime.js
+var KNOWN_CLIS = ["claude", "codex", "opencode"];
+var RUNTIME_HEARTBEAT_INTERVAL_MS = 15000;
+// ../core/dist/auth/api-key.js
+var KEY_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var nanoid24 = customAlphabet(KEY_ALPHABET, 24);
+// ../core/dist/auth/password.js
+import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { promisify } from "node:util";
+var scryptAsync = promisify(scrypt);
+var SCRYPT_N = 16384;
+var SCRYPT_R = 8;
+var SCRYPT_MAXMEM = 128 * SCRYPT_N * SCRYPT_R * 2;
 // src/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
@@ -25,8 +223,30 @@ 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
-var KNOWN_CLIS = ["claude", "codex", "opencode"];
 async function runSetup(options) {
   if (!/^https?:\/\//.test(options.apiUrl)) {
     throw new Error("--api must be an http(s) URL");
@@ -36,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(", ")}`);
   }
@@ -66,26 +286,11 @@ 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, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
+import { isAbsolute, join as join2 } from "node:path";
 
 // ../core/dist/services/skills/sync.js
 import { promises as fs } from "node:fs";
@@ -216,35 +421,48 @@ class LocalWorkspaceManager {
   root;
   constructor(config) {
     this.config = config;
-    this.root = config.workspaceRoot ?? join2(homedir2(), ".beevibe", "workspaces");
+    this.root = config.workspaceRoot || join2(homedir2(), ".beevibe", "workspaces");
+    if (!isAbsolute(this.root)) {
+      throw new Error(`LocalWorkspaceManager: workspaceRoot must be absolute, got "${this.root}"`);
+    }
   }
-  async ensureWorkspace({ agent }) {
-    const path2 = join2(this.root, agent.id);
+  async ensureWorkspace({ agent: agent2 }) {
+    const path2 = join2(this.root, agent2.id);
     mkdirSync2(path2, { recursive: true, mode: 448 });
+    if (!agent2.api_key) {
+      throw new Error(`Cannot write mcp-config.json for agent ${agent2.id}: agent.api_key is missing`);
+    }
     const configPath = join2(path2, "mcp-config.json");
-    if (!existsSync2(configPath)) {
-      if (!agent.api_key) {
-        throw new Error(`Cannot write mcp-config.json for agent ${agent.id}: agent.api_key is missing`);
+    const expected = buildMcpConfig(agent2.api_key, this.config.mcpServerUrl);
+    const needsWrite = !existsSync2(configPath) || readFileSync2(configPath, "utf-8") !== expected;
+    if (needsWrite) {
+      writeFileSync2(configPath, expected, { mode: 384 });
+    }
+    const workspace2 = { path: path2 };
+    const runtime3 = this.config.runtimeRegistry[agent2.runtime_config.type];
+    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`);
       }
-      writeFileSync2(configPath, buildMcpConfig(agent.api_key, this.config.mcpServerUrl), {
-        mode: 384
+      await runtime3.prepareWorkspace({
+        workspace: workspace2,
+        agentApiKey: agent2.api_key,
+        mcpServerUrl: this.config.mcpServerUrl
       });
     }
-    const workspace = { path: path2 };
-    const runtime = this.config.runtimeRegistry[agent.runtime_config.type];
-    if (!runtime) {
-      throw new Error(`No runtime registered for agent ${agent.id} (runtime_config.type='${agent.runtime_config.type}')`);
-    }
     await syncSkills({
       sourceDir: this.config.skillsSourceDir,
-      targetDir: runtime.skillsDir(workspace),
-      filter: tierFilterFor(agent.hierarchy_level),
+      targetDir: runtime3.skillsDir(workspace2),
+      filter: tierFilterFor(agent2.hierarchy_level),
       namespacePrefix: "beevibe"
     });
-    return workspace;
+    return workspace2;
   }
-  async removeWorkspace(workspace) {
-    rmSync(workspace.path, { recursive: true, force: true });
+  async removeWorkspace(workspace2) {
+    rmSync(workspace2.path, { recursive: true, force: true });
   }
 }
 function buildMcpConfig(apiKey, mcpServerUrl) {
@@ -447,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 [
@@ -480,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",
@@ -594,12 +826,15 @@ function parseClaudeMessages(messages, exitCode) {
   } : undefined;
   return {
     status: succeeded ? "completed" : "failed",
-    output: output || (succeeded ? "Session completed." : `CLI exited with code ${exitCode}`),
+    output: output || (succeeded ? "Session completed." : bareCliExitMessage(exitCode)),
     transcript: transcript || undefined,
     usage,
     cli_session_id: sessionId
   };
 }
+function bareCliExitMessage(exitCode) {
+  return `CLI exited with code ${exitCode}`;
+}
 
 // ../core/dist/adapters/claude-code/runtime.js
 var NESTING_GUARD_VARS = [
@@ -641,16 +876,19 @@ class ClaudeCodeRuntime {
       args.push("--max-turns", String(maxTurns));
     if (context.resume_session_id)
       args.push("--resume", context.resume_session_id);
+    if (context.disallowed_tools?.length) {
+      args.push("--disallowedTools", context.disallowed_tools.join(","));
+    }
     if (context.system_prompt_append.length > 0) {
       args.push("--append-system-prompt", context.system_prompt_append);
     }
-    const env = { ...process.env };
+    const env2 = { ...process.env };
     for (const key of NESTING_GUARD_VARS)
-      delete env[key];
+      delete env2[key];
     for (const key of ANTHROPIC_AUTH_VARS)
-      delete env[key];
+      delete env2[key];
     if (context.env)
-      Object.assign(env, context.env);
+      Object.assign(env2, context.env);
     const messages = [];
     let pending = "";
     const handleLine = (line) => {
@@ -668,7 +906,7 @@ class ClaudeCodeRuntime {
       command: this.config.command ?? "claude",
       args,
       cwd,
-      env,
+      env: env2,
       stdin: context.intent,
       abortSignal: context.abort_signal,
       onSpawn: ({ pid, process_group_id }) => {
@@ -700,10 +938,14 @@ class ClaudeCodeRuntime {
       };
     }
     const parsed = parseClaudeMessages(messages, 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
+      process_group_id: result.process_group_id ?? undefined,
+      exit_code: result.exitCode,
+      ...stderrTail ? { stderr: stderrTail } : {}
     };
   }
   async healthCheck() {
@@ -724,15 +966,710 @@ class ClaudeCodeRuntime {
     }
   }
   async shutdown() {}
-  skillsDir(workspace) {
-    return join3(workspace.path, ".claude", "skills");
+  skillsDir(workspace2) {
+    return join3(workspace2.path, ".claude", "skills");
+  }
+}
+
+// ../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 {
+    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);
+}
+
+// ../core/dist/adapters/codex/runtime.js
+var OPENAI_AUTH_VARS = ["OPENAI_API_KEY", "OPENAI_AUTH_TOKEN"];
+
+class CodexRuntime {
+  config;
+  type = "codex";
+  prepared = new Map;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  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 });
+      },
+      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("[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 {
+      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 {
+        healthy: false,
+        error: `Command not found: ${this.config.command ?? "codex"}`
+      };
+    }
+  }
+  async shutdown() {}
+  skillsDir(workspace2) {
+    return join4(workspace2.path, ".codex", "skills");
+  }
+  prepareWorkspace(context) {
+    this.prepared.set(context.workspace.path, {
+      agentApiKey: context.agentApiKey,
+      mcpServerUrl: context.mcpServerUrl
+    });
+  }
+}
+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 "";
+  }
+}
+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({})
+    claude: new ClaudeCodeRuntime({}),
+    codex: new CodexRuntime({}),
+    opencode: new OpenCodeRuntime({})
   };
 }
 
@@ -794,16 +1731,22 @@ class ApiClient {
     return `${this.cfg.apiUrl}${path2}`;
   }
 }
+
 // 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" }
+    runtime_config: { type: payload.runtime_type }
   };
   const ws = await deps.workspaceManager.ensureWorkspace({ agent: syntheticAgent });
-  const runtime = deps.runtime ?? new ClaudeCodeRuntime;
+  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(`No runtime registered for dispatch payload type '${payload.runtime_type}'`);
+  }
   const buffer = [];
   let flushTimer;
   const flush = async () => {
@@ -839,12 +1782,13 @@ async function runDispatch(deps, payload, abortSignal) {
   let result;
   let runError;
   try {
-    result = await runtime.execute({
+    result = await runtime3.execute({
       intent: payload.intent,
       workspace: ws,
       system_prompt_append: payload.system_prompt_append,
       model: payload.model,
       max_turns: payload.max_turns,
+      disallowed_tools: payload.disallowed_tools,
       env: payload.env,
       resume_session_id: payload.resume_session_id,
       abort_signal: abortSignal,
@@ -859,15 +1803,25 @@ async function runDispatch(deps, payload, abortSignal) {
   }
   await flush();
   const status = runError ? "failed" : result?.status === "completed" ? "succeeded" : result?.status === "cancelled" ? "cancelled" : "failed";
+  const errorDetail = runError?.message ?? result?.stderr;
   const done = {
     session_id: payload.session_id,
     status,
     cli_session_id: result?.cli_session_id,
     result_summary: result?.output ?? "",
-    exit_code: status === "succeeded" ? 0 : 1,
-    error: runError?.message,
+    exit_code: result?.exit_code ?? null,
+    error: errorDetail,
     usage: result?.usage
   };
+  if (status === "succeeded") {
+    console.log(`[daemon/spawn] sess=${payload.session_id} exit=0`);
+  } else {
+    console.error(`[daemon/spawn] sess=${payload.session_id} status=${status} exit=${done.exit_code}` + (errorDetail ? `
+  error:
+    ${errorDetail.split(`
+`).join(`
+    `)}` : ""));
+  }
   try {
     await deps.api.post("/runtime/done", done);
   } catch (err) {
@@ -877,7 +1831,6 @@ async function runDispatch(deps, payload, abortSignal) {
 
 // src/claimer.ts
 var DEFAULT_POLL_MS = 30000;
-var DEFAULT_HEARTBEAT_MS = 15000;
 var DEFAULT_WS_RECONNECT_MAX_MS = 30000;
 
 class Claimer {
@@ -894,7 +1847,7 @@ class Claimer {
   constructor(cfg) {
     this.cfg = cfg;
     this.pollIntervalMs = cfg.pollIntervalMs ?? DEFAULT_POLL_MS;
-    this.heartbeatIntervalMs = cfg.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_MS;
+    this.heartbeatIntervalMs = cfg.heartbeatIntervalMs ?? RUNTIME_HEARTBEAT_INTERVAL_MS;
     this.wsReconnectMaxDelayMs = cfg.wsReconnectMaxDelayMs ?? DEFAULT_WS_RECONNECT_MAX_MS;
   }
   start() {
@@ -988,11 +1941,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));
     }
   }
 }
@@ -1000,14 +1964,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 join6 } from "node:path";
 function skillsCacheDir() {
-  return join4(homedir3(), ".beevibe", "skills");
+  return join6(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(join6(skillsCacheDir(), VERSION_FILE), "utf8")).trim();
   } catch {
     return;
   }
@@ -1028,19 +1992,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(join6(cache, dirent.name), { recursive: true, force: true });
     }
   }
   for (const skill of res.skills) {
-    const skillDir = join4(cache, skill.name);
+    const skillDir = join6(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 = join6(skillDir, file.path);
+      await fs2.mkdir(join6(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(join6(cache, VERSION_FILE), res.version, { mode: 384 });
   return cache;
 }
 
@@ -1119,6 +2083,7 @@ async function runStart() {
     api,
     supervisor,
     workspaceManager,
+    runtimeRegistry,
     runtimeIds: cfg.runtimes.map((r) => r.id)
   });
   claimer.start();
@@ -1134,16 +2099,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 tmpdir4 } from "node:os";
+import { join as join7 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInterface } from "node:readline/promises";
@@ -1157,7 +2152,7 @@ var PLATFORM_ASSETS = {
   "linux-arm64": "beevibe-daemon-linux-arm64"
 };
 function currentVersion() {
-  return "0.1.1";
+  return "0.1.3";
 }
 function isCompiledBinary() {
   if (!process.versions.bun)
@@ -1270,8 +2265,8 @@ async function runUpdate(opts = {}) {
       return;
     }
   }
-  const stagingDir = mkdtempSync(join5(tmpdir2(), "beevibe-daemon-update-"));
-  const stagingPath = join5(stagingDir, asset);
+  const stagingDir = mkdtempSync(join7(tmpdir4(), "beevibe-daemon-update-"));
+  const stagingPath = join7(stagingDir, asset);
   try {
     console.log(`Downloading ${asset}…`);
     const downloadUrl = `${DOWNLOAD_BASE}/${latest}/${asset}`;
@@ -1329,6 +2324,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:",
@@ -1370,6 +2366,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 });