@sma1lboy/kobe 0.5.15 → 0.5.17

package/dist/bin/kobed.js

@@ -48,17 +48,38 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // src/daemon/paths.ts
+import { createHash } from "crypto";
 import { homedir, tmpdir } from "os";
 import { join } from "path";
-function defaultDaemonSocketPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
+function shortHomeTag(homeDir) {
+  return createHash("sha1").update(homeDir).digest("hex").slice(0, 8);
+}
+function fitSocketPath(naturalPath, homeDir, role, pidTag) {
+  if (Buffer.byteLength(naturalPath, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
+    return naturalPath;
+  const tag = shortHomeTag(homeDir);
+  const suffix = pidTag === undefined ? "" : `-${pidTag}`;
+  const fallback = join(tmpdir(), `kobe-${tag}-${role}${suffix}.sock`);
+  if (Buffer.byteLength(fallback, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
+    return fallback;
+  throw new Error(`kobe socket path exceeds ${SOCKET_PATH_SAFETY_LIMIT} bytes even after fallback: ${fallback}`);
+}
+function defaultDaemonSocketPath(homeDir) {
+  const explicit = homeDir ?? process.env.KOBE_HOME_DIR;
+  if (explicit && explicit.length > 0) {
+    return fitSocketPath(join(explicit, ".kobe", "daemon.sock"), explicit, "daemon");
+  }
   const runtimeDir = process.env.XDG_RUNTIME_DIR;
-  if (runtimeDir && runtimeDir.length > 0)
-    return join(runtimeDir, "kobe.sock");
-  return join(homeDir, ".kobe", "daemon.sock");
+  if (runtimeDir && runtimeDir.length > 0) {
+    return fitSocketPath(join(runtimeDir, "kobe.sock"), runtimeDir, "daemon");
+  }
+  const home = homedir();
+  return fitSocketPath(join(home, ".kobe", "daemon.sock"), home, "daemon");
 }
 function defaultDaemonPidPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
   return join(homeDir, ".kobe", "daemon.pid");
 }
+var SOCKET_PATH_SAFETY_LIMIT = 100;
 var init_paths = () => {};
 
 // src/daemon/protocol.ts
@@ -78,6 +99,8 @@ function serializeTask(task) {
     pinned: task.pinned ?? false,
     permissionMode: task.permissionMode,
     model: task.model,
+    modelEffort: task.modelEffort,
+    vendor: task.vendor,
     createdAt: task.createdAt,
     updatedAt: task.updatedAt
   };
@@ -345,6 +368,86 @@ var init_daemon_process = __esm(() => {
   init_client();
 });
 
+// src/session/usage-metrics.ts
+function totalContextTokens(u) {
+  return u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+}
+function parseTimestampMs(value) {
+  const ms = new Date(value).getTime();
+  return Number.isFinite(ms) ? ms : null;
+}
+function mergeIntervals(intervals) {
+  if (intervals.length === 0)
+    return [];
+  const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs);
+  const first = sorted[0];
+  if (!first)
+    return [];
+  const merged = [{ startMs: first.startMs, endMs: first.endMs }];
+  for (let i = 1;i < sorted.length; i++) {
+    const current = sorted[i];
+    const last = merged[merged.length - 1];
+    if (!current || !last)
+      continue;
+    if (current.startMs <= last.endMs) {
+      last.endMs = Math.max(last.endMs, current.endMs);
+    } else {
+      merged.push({ startMs: current.startMs, endMs: current.endMs });
+    }
+  }
+  return merged;
+}
+function durationMs(intervals) {
+  return intervals.reduce((total, interval) => total + (interval.endMs - interval.startMs), 0);
+}
+function deriveSessionUsageMetrics(past) {
+  let latestUsage;
+  let latestUsageTimestampMs = null;
+  let lastUserTimestampMs = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const intervals = [];
+  for (const message of past) {
+    const timestampMs = parseTimestampMs(message.timestamp);
+    if (message.role === "user" && timestampMs !== null) {
+      lastUserTimestampMs = timestampMs;
+      continue;
+    }
+    if (message.role !== "assistant" || !message.usage)
+      continue;
+    if (timestampMs !== null && (latestUsageTimestampMs === null || timestampMs > latestUsageTimestampMs)) {
+      latestUsageTimestampMs = timestampMs;
+      latestUsage = message.usage;
+    } else if (latestUsage === undefined) {
+      latestUsage = message.usage;
+    }
+    inputTokens += message.usage.input_tokens;
+    outputTokens += message.usage.output_tokens;
+    if (timestampMs !== null && lastUserTimestampMs !== null && timestampMs > lastUserTimestampMs) {
+      intervals.push({ startMs: lastUserTimestampMs, endMs: timestampMs });
+    }
+  }
+  if (!latestUsage)
+    return;
+  const totalDurationMs = durationMs(mergeIntervals(intervals));
+  if (totalDurationMs <= 0)
+    return latestUsage;
+  return {
+    ...latestUsage,
+    total_speed_tokens_per_second: (inputTokens + outputTokens) / (totalDurationMs / 1000)
+  };
+}
+function withTotalSpeedForTurn(usage, startedAtIso, endedAtIso) {
+  const startMs = startedAtIso ? parseTimestampMs(startedAtIso) : null;
+  const endMs = parseTimestampMs(endedAtIso);
+  if (startMs === null || endMs === null || endMs <= startMs)
+    return usage;
+  return {
+    ...usage,
+    total_speed_tokens_per_second: (usage.input_tokens + usage.output_tokens) / ((endMs - startMs) / 1000)
+  };
+}
+
 // src/engine/claude-code-local/binary.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync2, statSync } from "fs";
@@ -449,10 +552,175 @@ var init_binary = __esm(() => {
   };
 });
 
+// src/engine/claude-code-local/models.ts
+function opus47EffortChoices(id, label) {
+  return CLAUDE_OPUS_EFFORT_LEVELS.map((effort) => ({
+    vendor: "claude",
+    id,
+    effort,
+    level: effort,
+    label: `${label} \xB7 ${effort}`,
+    hint: effort === "max" ? "deepest reasoning" : `${effort} effort`
+  }));
+}
+function parseContextWindowSize(modelIdentifier) {
+  const delimitedMatch = /(?:\(|\[)\s*(\d+(?:[,_]\d+)*(?:\.\d+)?)\s*([km])\s*(?:\)|\])/i.exec(modelIdentifier);
+  if (delimitedMatch?.[1] && delimitedMatch[2]) {
+    const parsed2 = Number.parseFloat(delimitedMatch[1].replace(/[,_]/g, ""));
+    if (Number.isFinite(parsed2) && parsed2 > 0) {
+      return Math.round(parsed2 * (delimitedMatch[2].toLowerCase() === "m" ? 1e6 : 1000));
+    }
+  }
+  const contextMatch = /\b(\d+(?:[,_]\d+)*(?:\.\d+)?)\s*([km])(?:\s*(?:token\s*)?context)?\b/i.exec(modelIdentifier);
+  if (!contextMatch?.[1] || !contextMatch[2])
+    return null;
+  const parsed = Number.parseFloat(contextMatch[1].replace(/[,_]/g, ""));
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return null;
+  return Math.round(parsed * (contextMatch[2].toLowerCase() === "m" ? 1e6 : 1000));
+}
+function claudeContextWindowFor(modelId) {
+  const parsed = parseContextWindowSize(modelId);
+  if (parsed !== null)
+    return parsed;
+  if (modelId.includes("[1m]"))
+    return LONG_CTX;
+  const inCatalog = CLAUDE_MODELS.some((m) => m.id === modelId);
+  if (inCatalog)
+    return STD_CTX;
+  if (modelId.includes("1m") || modelId.includes("[1M]"))
+    return LONG_CTX;
+  return STD_CTX;
+}
+var CLAUDE_OPUS_EFFORT_LEVELS, CLAUDE_MODELS, LONG_CTX = 1e6, STD_CTX = 200000;
+var init_models = __esm(() => {
+  CLAUDE_OPUS_EFFORT_LEVELS = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max"
+  ];
+  CLAUDE_MODELS = [
+    { vendor: "claude", id: "claude-opus-4-7[1m]", label: "Opus 4.7 1M", hint: "long context, default" },
+    ...opus47EffortChoices("claude-opus-4-7[1m]", "Opus 4.7 1M"),
+    { vendor: "claude", id: "claude-opus-4-7", label: "Opus 4.7", hint: "most capable, slowest" },
+    ...opus47EffortChoices("claude-opus-4-7", "Opus 4.7"),
+    { vendor: "claude", id: "claude-sonnet-4-6[1m]", label: "sonnet 4.6 (1M)", hint: "long context" },
+    { vendor: "claude", id: "claude-sonnet-4-6", label: "sonnet 4.6" },
+    { vendor: "claude", id: "claude-haiku-4-5-20251001", label: "haiku 4.5", hint: "fastest, cheapest" }
+  ];
+});
+
+// src/engine/claude-code-local/settings.ts
+import { readFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+function readClaudeSettings() {
+  if (cached !== undefined)
+    return cached;
+  try {
+    const raw = readFileSync(SETTINGS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+      cached = null;
+      return null;
+    }
+    const obj = parsed;
+    const model = typeof obj.model === "string" && obj.model.length > 0 ? obj.model : undefined;
+    cached = { model };
+    return cached;
+  } catch {
+    cached = null;
+    return null;
+  }
+}
+function resolveClaudeDefaultModelId() {
+  const settings = readClaudeSettings();
+  if (settings?.model && settings.model.length > 0)
+    return settings.model;
+  return CLAUDE_FALLBACK_DEFAULT_MODEL_ID;
+}
+var SETTINGS_PATH, cached, CLAUDE_FALLBACK_DEFAULT_MODEL_ID = "claude-opus-4-7[1m]";
+var init_settings = __esm(() => {
+  SETTINGS_PATH = join3(homedir3(), ".claude", "settings.json");
+});
+
+// src/engine/claude-code-local/capabilities.ts
+var claudeCapabilities, claudeIdentity;
+var init_capabilities = __esm(() => {
+  init_models();
+  init_settings();
+  claudeCapabilities = {
+    vendorId: "claude",
+    label: "Claude Code",
+    models: CLAUDE_MODELS,
+    permissionModes: [
+      { id: "default", label: "default" },
+      { id: "plan", label: "plan mode" }
+    ],
+    defaultModelId: resolveClaudeDefaultModelId,
+    contextWindowFor: claudeContextWindowFor
+  };
+  claudeIdentity = {
+    vendorId: "claude",
+    productName: "Claude Code",
+    shortName: "Claude",
+    assistantName: "Claude",
+    inputPlaceholder: "Ask Claude\u2026"
+  };
+});
+
+// src/engine/claude-code-local/normalize.ts
+function normalizeClaudeContent(content) {
+  if (typeof content === "string") {
+    return content.length > 0 ? [{ type: "text", text: content }] : [];
+  }
+  if (!Array.isArray(content))
+    return [];
+  const out = [];
+  for (const block of content) {
+    if (typeof block === "string") {
+      if (block.length > 0)
+        out.push({ type: "text", text: block });
+      continue;
+    }
+    if (!block || typeof block !== "object")
+      continue;
+    const b = block;
+    if (b.type === "text" && typeof b.text === "string") {
+      out.push({ type: "text", text: b.text });
+      continue;
+    }
+    if (b.type === "tool_use") {
+      out.push({
+        type: "tool_call",
+        callId: typeof b.id === "string" ? b.id : "",
+        name: typeof b.name === "string" ? b.name : "",
+        input: b.input
+      });
+      continue;
+    }
+    if (b.type === "tool_result") {
+      out.push({
+        type: "tool_result",
+        callId: typeof b.tool_use_id === "string" ? b.tool_use_id : "",
+        output: b.content,
+        isError: b.is_error === true
+      });
+      continue;
+    }
+    if (b.type === "thinking" && typeof b.thinking === "string") {
+      out.push({ type: "thinking", text: b.thinking });
+    }
+  }
+  return out;
+}
+
 // src/engine/claude-code-local/history.ts
 import { randomUUID } from "crypto";
 import { appendFile, mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import path2 from "path";
 function encodeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
@@ -523,11 +791,11 @@ function extractMessage(record, fallbackSessionId) {
     return null;
   if (!("content" in inner))
     return null;
-  const content = inner.content;
+  const blocks = normalizeClaudeContent(inner.content);
   const ts = typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString();
   const sid = typeof record.sessionId === "string" ? record.sessionId : fallbackSessionId;
   const usage = extractUsage(inner.usage);
-  return usage ? { role, content, timestamp: ts, sessionId: sid, usage } : { role, content, timestamp: ts, sessionId: sid };
+  return usage ? { role, blocks, timestamp: ts, sessionId: sid, usage } : { role, blocks, timestamp: ts, sessionId: sid };
 }
 function extractUsage(v) {
   if (!isObject(v))
@@ -622,7 +890,7 @@ var defaultDeps2;
 var init_history = __esm(() => {
   defaultDeps2 = {
     projectsDir() {
-      return path2.join(homedir3(), ".claude", "projects");
+      return path2.join(homedir4(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -658,7 +926,12 @@ class SessionRegistry {
     }
     this.handles.set(handle.sessionId, handle);
   }
-  unregister(sessionId) {
+  unregister(sessionId, proc) {
+    if (proc) {
+      const existing = this.handles.get(sessionId);
+      if (existing && existing.proc !== proc)
+        return;
+    }
     this.handles.delete(sessionId);
   }
   get(sessionId) {
@@ -706,7 +979,7 @@ function delay(ms) {
 
 // src/engine/claude-code-local/sessions.ts
 import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import path3 from "path";
 async function listSessionsForCwd(cwd, deps = defaultDeps3) {
   const projectDir = path3.join(deps.projectsDir(), encodeCwd(cwd));
@@ -758,17 +1031,11 @@ function extractFirstUserMessage(lines) {
   return null;
 }
 function stringifyContent(content) {
-  if (typeof content === "string")
-    return content.trim();
-  if (!Array.isArray(content))
-    return "";
+  const blocks = normalizeClaudeContent(content);
   const parts = [];
-  for (const block of content) {
-    if (!isObject2(block))
-      continue;
-    if (block.type === "text" && typeof block.text === "string") {
-      parts.push(block.text);
-    }
+  for (const b of blocks) {
+    if (b.type === "text")
+      parts.push(b.text);
   }
   return parts.join(" ").trim();
 }
@@ -780,7 +1047,7 @@ var init_sessions = __esm(() => {
   init_history();
   defaultDeps3 = {
     projectsDir() {
-      return path3.join(homedir4(), ".claude", "projects");
+      return path3.join(homedir5(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -824,6 +1091,9 @@ function buildArgs(opts) {
   if (opts.model) {
     args.push("--model", opts.model);
   }
+  if (opts.modelEffort) {
+    args.push("--effort", opts.modelEffort);
+  }
   if (opts.permissionMode) {
     args.push("--permission-mode", opts.permissionMode);
   }
@@ -924,6 +1194,13 @@ async function* parseStreamJson(lines, opts = {}) {
         };
       }
       const subtype = typeof msg.subtype === "string" ? msg.subtype : "success";
+      const isApiError = msg.is_error === true || typeof msg.api_error_status === "number";
+      if (isApiError) {
+        const status = typeof msg.api_error_status === "number" ? ` ${msg.api_error_status}` : "";
+        const result = typeof msg.result === "string" ? msg.result.trim() : "";
+        yield { type: "error", message: result ? `claude API error${status}: ${result}` : `claude API error${status}` };
+        return;
+      }
       if (subtype === "success") {
         yield { type: "done" };
       } else {
@@ -973,6 +1250,8 @@ function stringifyErr(err) {
 
 // src/engine/claude-code-local/index.ts
 class ClaudeCodeLocal {
+  identity = claudeIdentity;
+  capabilities = claudeCapabilities;
   registry = new SessionRegistry;
   running = new Map;
   binaryPathResolver;
@@ -1015,7 +1294,9 @@ class ClaudeCodeLocal {
     };
   }
   async readHistory(sessionId) {
-    return readHistory(sessionId);
+    const messages = await readHistory(sessionId);
+    const usageMetrics = deriveSessionUsageMetrics(messages);
+    return { messages, ...usageMetrics ? { usageMetrics } : {} };
   }
   async deleteHistory(sessionId) {
     return deleteHistory(sessionId);
@@ -1049,6 +1330,7 @@ class ClaudeCodeLocal {
       cwd: args.cwd,
       prompt: args.prompt,
       model: args.opts?.model,
+      modelEffort: args.opts?.modelEffort,
       permissionMode: cliPermissionMode,
       env: args.opts?.env,
       resumeSessionId: args.resumeSessionId
@@ -1074,7 +1356,8 @@ class ClaudeCodeLocal {
         waiters: [],
         closed: false,
         completedNaturally: false,
-        prompt: args.prompt
+        prompt: args.prompt,
+        spawnedAtIso: new Date().toISOString()
       };
       this.running.set(sessionId, session);
       this.registry.register({
@@ -1103,7 +1386,8 @@ class ClaudeCodeLocal {
       });
       try {
         for await (const ev of events) {
-          queue.push(ev);
+          const enriched = enrichUsageEvent(ev, session?.spawnedAtIso);
+          queue.push(enriched);
           if (ev.type === "done" && session) {
             session.completedNaturally = true;
           }
@@ -1122,7 +1406,7 @@ class ClaudeCodeLocal {
         if (session) {
           session.closed = true;
           this.notify(session);
-          this.registry.unregister(session.sessionId);
+          this.registry.unregister(session.sessionId, spawned.proc);
         }
         if (!bound) {
           rejectHandle(new Error("claude exited without emitting a session id"));
@@ -1153,20 +1437,1022 @@ function drainStream(stream) {
   s.on("data", () => {});
   s.on("error", () => {});
 }
+function enrichUsageEvent(ev, startedAtIso) {
+  if (ev.type !== "usage")
+    return ev;
+  return { type: "usage", ...withTotalSpeedForTurn(ev, startedAtIso, new Date().toISOString()) };
+}
 var init_claude_code_local = __esm(() => {
   init_binary();
+  init_capabilities();
   init_history();
   init_sessions();
   init_spawn();
 });
 
+// src/engine/codex-local/binary.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
+import { homedir as homedir6 } from "os";
+import path4 from "path";
+async function findCodexBinary(deps = defaultDeps4) {
+  const checked = [];
+  const tryPath = (p) => {
+    if (!p)
+      return;
+    checked.push(p);
+    return deps.fileExists(p) ? p : undefined;
+  };
+  const whichResult = deps.which("codex");
+  if (whichResult) {
+    checked.push(`which:${whichResult}`);
+    if (deps.fileExists(whichResult))
+      return whichResult;
+  }
+  const home = deps.home();
+  for (const p of ["/opt/homebrew/bin/codex", "/usr/local/bin/codex", "/usr/bin/codex", "/bin/codex"]) {
+    const candidate = tryPath(p);
+    if (candidate)
+      return candidate;
+  }
+  const nvmBin = deps.env("NVM_BIN");
+  if (nvmBin) {
+    const candidate = tryPath(path4.join(nvmBin, "codex"));
+    if (candidate)
+      return candidate;
+  }
+  for (const rel of [".local/bin/codex", ".bun/bin/codex", "bin/codex"]) {
+    const candidate = tryPath(path4.join(home, rel));
+    if (candidate)
+      return candidate;
+  }
+  throw new CodexBinaryNotFoundError(checked);
+}
+var CodexBinaryNotFoundError, defaultDeps4;
+var init_binary2 = __esm(() => {
+  CodexBinaryNotFoundError = class CodexBinaryNotFoundError extends Error {
+    checkedPaths;
+    constructor(checkedPaths) {
+      super(`Codex CLI binary not found. Checked: ${checkedPaths.join(", ")}. Ensure 'codex' is on PATH (e.g. \`brew install codex\` or the official installer).`);
+      this.name = "CodexBinaryNotFoundError";
+      this.checkedPaths = checkedPaths;
+    }
+  };
+  defaultDeps4 = {
+    fileExists(p) {
+      try {
+        return statSync2(p).isFile();
+      } catch {
+        return false;
+      }
+    },
+    env(name) {
+      return process.env[name];
+    },
+    home() {
+      return homedir6();
+    },
+    which(name) {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      const out = spawnSync2(cmd, [name], { encoding: "utf8" });
+      if (out.status !== 0)
+        return;
+      const first = out.stdout.split(`
+`).map((l) => l.trim()).filter(Boolean)[0];
+      if (!first)
+        return;
+      if (first.startsWith("codex:") && first.includes("aliased to")) {
+        const aliasTarget = first.split("aliased to")[1]?.trim();
+        return aliasTarget && existsSync3(aliasTarget) ? aliasTarget : undefined;
+      }
+      return first;
+    },
+    readdir(p) {
+      try {
+        const fs = __require("fs");
+        return fs.readdirSync(p);
+      } catch {
+        return [];
+      }
+    }
+  };
+});
+
+// src/engine/codex-local/models.ts
+function codexContextWindowFor(_modelId) {
+  return DEFAULT_CTX;
+}
+var CODEX_GPT55_EFFORT_LEVELS, CODEX_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini", DEFAULT_CTX = 400000;
+var init_models2 = __esm(() => {
+  CODEX_GPT55_EFFORT_LEVELS = [
+    "none",
+    "low",
+    "medium",
+    "high",
+    "xhigh"
+  ];
+  CODEX_MODELS = [
+    { vendor: "codex", id: "gpt-5.5", label: "GPT-5.5", hint: "latest, ChatGPT-account compatible" },
+    ...CODEX_GPT55_EFFORT_LEVELS.map((effort) => ({
+      vendor: "codex",
+      id: "gpt-5.5",
+      effort,
+      level: effort,
+      label: `GPT-5.5 \xB7 ${effort}`,
+      hint: effort === "none" ? "no reasoning effort" : `${effort} reasoning`
+    })),
+    { vendor: "codex", id: "gpt-5.4", label: "GPT-5.4", hint: "stable" },
+    { vendor: "codex", id: "gpt-5.4-mini", label: "GPT-5.4 mini", hint: "fastest, always supported" }
+  ];
+});
+
+// src/engine/codex-local/settings.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join4 } from "path";
+function readModelFromConfig() {
+  try {
+    const raw = readFileSync2(CONFIG_PATH, "utf8");
+    let inTable = false;
+    for (const line of raw.split(`
+`)) {
+      const t = line.trim();
+      if (t.startsWith("[") && t.endsWith("]")) {
+        inTable = true;
+        continue;
+      }
+      if (inTable)
+        continue;
+      const m = /^model\s*=\s*"([^"]+)"/.exec(t);
+      if (m)
+        return m[1] ?? null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function resolveCodexDefaultModelId() {
+  if (cached2 === undefined)
+    cached2 = readModelFromConfig();
+  return cached2 ?? CODEX_FALLBACK_DEFAULT_MODEL_ID;
+}
+var CONFIG_PATH, cached2;
+var init_settings2 = __esm(() => {
+  init_models2();
+  CONFIG_PATH = join4(homedir7(), ".codex", "config.toml");
+});
+
+// src/engine/codex-local/capabilities.ts
+var codexCapabilities, codexIdentity;
+var init_capabilities2 = __esm(() => {
+  init_models2();
+  init_settings2();
+  codexCapabilities = {
+    vendorId: "codex",
+    label: "Codex",
+    models: CODEX_MODELS,
+    permissionModes: [
+      { id: "default", label: "full access" },
+      { id: "plan", label: "plan mode" }
+    ],
+    defaultModelId: resolveCodexDefaultModelId,
+    contextWindowFor: codexContextWindowFor
+  };
+  codexIdentity = {
+    vendorId: "codex",
+    productName: "Codex",
+    shortName: "Codex",
+    assistantName: "Codex",
+    inputPlaceholder: "Ask Codex\u2026"
+  };
+});
+
+// src/engine/codex-local/normalize.ts
+function normalizeCodexContent(raw) {
+  if (typeof raw === "string") {
+    return raw.length > 0 ? [{ type: "text", text: raw }] : [];
+  }
+  if (!Array.isArray(raw))
+    return [];
+  const blocks = [];
+  for (const item of raw) {
+    if (typeof item === "string") {
+      if (item.length > 0)
+        blocks.push({ type: "text", text: item });
+      continue;
+    }
+    if (!isObject4(item))
+      continue;
+    const t = typeof item.type === "string" ? item.type : undefined;
+    if (t === "input_text" || t === "output_text") {
+      const text = typeof item.text === "string" ? item.text : "";
+      if (text.length > 0)
+        blocks.push({ type: "text", text });
+      continue;
+    }
+    if (t)
+      blocks.push({ type: "text", text: `[codex: ${t}]` });
+  }
+  return blocks;
+}
+function isObject4(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// src/engine/codex-local/synthetic.ts
+function isSyntheticCodexUserRow(blocks) {
+  if (blocks.length === 0)
+    return false;
+  for (const b of blocks) {
+    if (b.type !== "text")
+      return false;
+    const t = (b.text ?? "").trim();
+    if (!isEnvironmentContextEnvelope(t) && !isInstructionsEnvelope(t))
+      return false;
+  }
+  return true;
+}
+function visibleCodexUserText(content) {
+  const blocks = normalizeCodexContent(content);
+  if (isSyntheticCodexUserRow(blocks))
+    return null;
+  const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
+  return text.length > 0 ? text : null;
+}
+function isEnvironmentContextEnvelope(text) {
+  return text.startsWith("<environment_context>") && text.endsWith("</environment_context>");
+}
+function isInstructionsEnvelope(text) {
+  return text.startsWith("# AGENTS.md instructions for ") && text.includes(`
+<INSTRUCTIONS>
+`) && text.endsWith("</INSTRUCTIONS>");
+}
+var init_synthetic = () => {};
+
+// src/engine/codex-local/history.ts
+import { readFile as readFile3, readdir as readdir3, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import path5 from "path";
+async function listRolloutFiles(deps = defaultDeps5) {
+  const root = deps.sessionsDir();
+  const years = (await deps.readdir(root)).sort().reverse();
+  const out = [];
+  for (const y of years) {
+    const yp = path5.join(root, y);
+    const months = (await deps.readdir(yp)).sort().reverse();
+    for (const m of months) {
+      const mp = path5.join(yp, m);
+      const days = (await deps.readdir(mp)).sort().reverse();
+      for (const d of days) {
+        const dp = path5.join(mp, d);
+        const files = (await deps.readdir(dp)).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl"));
+        files.sort().reverse();
+        for (const f of files)
+          out.push(path5.join(dp, f));
+      }
+    }
+  }
+  return out;
+}
+async function findRolloutFile(sessionId, deps = defaultDeps5) {
+  const all = await listRolloutFiles(deps);
+  for (const p of all) {
+    if (path5.basename(p).endsWith(`-${sessionId}.jsonl`))
+      return p;
+  }
+  return;
+}
+async function readHistoryWithMetrics(sessionId, deps = defaultDeps5) {
+  const file = await findRolloutFile(sessionId, deps);
+  if (!file)
+    return { messages: [] };
+  let raw;
+  try {
+    raw = await deps.readFile(file);
+  } catch {
+    return { messages: [] };
+  }
+  const messages = sortByTimestamp2(parseJsonl2(raw, sessionId));
+  const usageMetrics = deriveCodexUsageMetrics(raw);
+  return { messages, ...usageMetrics ? { usageMetrics } : {} };
+}
+async function deleteHistory2(sessionId, deps = defaultDeps5) {
+  const file = await findRolloutFile(sessionId, deps);
+  if (!file)
+    return;
+  try {
+    await unlink2(file);
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+}
+function sortByTimestamp2(messages) {
+  return messages.map((msg, idx) => ({ msg, idx })).sort((a, b) => {
+    if (a.msg.timestamp < b.msg.timestamp)
+      return -1;
+    if (a.msg.timestamp > b.msg.timestamp)
+      return 1;
+    return a.idx - b.idx;
+  }).map((entry) => entry.msg);
+}
+function parseJsonl2(raw, sessionId) {
+  const out = [];
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isObject5(parsed))
+      continue;
+    if (parsed.type !== "response_item")
+      continue;
+    const payload = isObject5(parsed.payload) ? parsed.payload : undefined;
+    if (!payload)
+      continue;
+    if (payload.type !== "message")
+      continue;
+    const role = payload.role;
+    if (role !== "user" && role !== "assistant" && role !== "system")
+      continue;
+    const blocks = normalizeCodexContent(payload.content);
+    if (role === "user" && isSyntheticCodexUserRow(blocks))
+      continue;
+    const ts = typeof parsed.timestamp === "string" ? parsed.timestamp : new Date().toISOString();
+    out.push({ role, blocks, timestamp: ts, sessionId });
+  }
+  return out;
+}
+function deriveCodexUsageMetrics(raw) {
+  let latestUsage;
+  let latestUsageTimestampMs = null;
+  let lastUserTimestampMs = null;
+  let inputTokens = 0;
+  let outputTokens = 0;
+  const intervals = [];
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!isObject5(parsed))
+      continue;
+    const timestampMs = typeof parsed.timestamp === "string" ? parseTimestampMs2(parsed.timestamp) : null;
+    if (parsed.type === "response_item") {
+      const payload = isObject5(parsed.payload) ? parsed.payload : undefined;
+      if (payload?.type === "message" && payload.role === "user" && timestampMs !== null) {
+        const blocks = normalizeCodexContent(payload.content);
+        if (!isSyntheticCodexUserRow(blocks))
+          lastUserTimestampMs = timestampMs;
+      }
+      continue;
+    }
+    if (parsed.type !== "turn.completed")
+      continue;
+    const usage = isObject5(parsed.usage) ? parsed.usage : undefined;
+    if (!usage)
+      continue;
+    const snapshot = codexUsageToSnapshot(usage);
+    if (!snapshot)
+      continue;
+    if (timestampMs !== null && (latestUsageTimestampMs === null || timestampMs > latestUsageTimestampMs)) {
+      latestUsageTimestampMs = timestampMs;
+      latestUsage = snapshot;
+    } else if (latestUsage === undefined) {
+      latestUsage = snapshot;
+    }
+    inputTokens += snapshot.input_tokens;
+    outputTokens += snapshot.output_tokens;
+    if (timestampMs !== null && lastUserTimestampMs !== null && timestampMs > lastUserTimestampMs) {
+      intervals.push({ startMs: lastUserTimestampMs, endMs: timestampMs });
+    }
+  }
+  if (!latestUsage)
+    return;
+  const durationMs2 = mergedDurationMs(intervals);
+  if (durationMs2 <= 0)
+    return latestUsage;
+  return {
+    ...latestUsage,
+    total_speed_tokens_per_second: (inputTokens + outputTokens) / (durationMs2 / 1000)
+  };
+}
+function codexUsageToSnapshot(usage) {
+  const input = numberOr(usage.input_tokens, 0);
+  const output = numberOr(usage.output_tokens, 0) + numberOr(usage.reasoning_output_tokens, 0);
+  const cacheRead = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : undefined;
+  if (input <= 0 && output <= 0 && cacheRead === undefined)
+    return;
+  return {
+    input_tokens: input,
+    output_tokens: output,
+    ...cacheRead !== undefined ? { cache_read_input_tokens: cacheRead } : {}
+  };
+}
+function parseTimestampMs2(value) {
+  const ms = new Date(value).getTime();
+  return Number.isFinite(ms) ? ms : null;
+}
+function mergedDurationMs(intervals) {
+  if (intervals.length === 0)
+    return 0;
+  const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs);
+  let total = 0;
+  let current = sorted[0];
+  if (!current)
+    return 0;
+  for (let i = 1;i < sorted.length; i++) {
+    const next = sorted[i];
+    if (!next)
+      continue;
+    if (next.startMs <= current.endMs) {
+      current = { startMs: current.startMs, endMs: Math.max(current.endMs, next.endMs) };
+    } else {
+      total += current.endMs - current.startMs;
+      current = next;
+    }
+  }
+  total += current.endMs - current.startMs;
+  return total;
+}
+function numberOr(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function isObject5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var defaultDeps5;
+var init_history2 = __esm(() => {
+  init_synthetic();
+  defaultDeps5 = {
+    sessionsDir() {
+      return path5.join(homedir8(), ".codex", "sessions");
+    },
+    async readdir(p) {
+      try {
+        return await readdir3(p);
+      } catch {
+        return [];
+      }
+    },
+    async readFile(p) {
+      return await readFile3(p, "utf8");
+    }
+  };
+});
+
+// src/engine/codex-local/sessions.ts
+import { open, stat as stat2 } from "fs/promises";
+async function listSessionsForCwd2(cwd, deps) {
+  const files = await listRolloutFiles(deps);
+  const out = [];
+  for (const file of files) {
+    const meta = await tryReadMeta(file);
+    if (!meta)
+      continue;
+    if (meta.cwd !== cwd)
+      continue;
+    out.push({
+      sessionId: meta.sessionId,
+      mtimeMs: meta.mtimeMs,
+      firstUserMessage: meta.firstUserMessage,
+      messageCount: meta.messageCount
+    });
+  }
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+async function tryReadMeta(file) {
+  let st;
+  try {
+    st = await stat2(file);
+  } catch {
+    return null;
+  }
+  let sessionId;
+  let cwd;
+  let firstUser = null;
+  let messageCount = 0;
+  const handle = await open(file, "r").catch(() => null);
+  if (!handle)
+    return null;
+  try {
+    let buf = "";
+    const processLine = (line) => {
+      const parsed = safeParse(line);
+      if (!parsed)
+        return;
+      if (parsed.type === "session_meta") {
+        const payload = parsed.payload;
+        if (isObject6(payload)) {
+          if (typeof payload.id === "string")
+            sessionId = payload.id;
+          if (typeof payload.cwd === "string")
+            cwd = payload.cwd;
+        }
+        return;
+      }
+      if (parsed.type === "response_item" && isObject6(parsed.payload)) {
+        const p = parsed.payload;
+        if (p.type === "message") {
+          messageCount++;
+          if (!firstUser && p.role === "user") {
+            const text = visibleCodexUserText(p.content);
+            if (text)
+              firstUser = text.slice(0, PREVIEW_CHAR_CAP);
+          }
+        }
+      }
+    };
+    const reader = handle.createReadStream({ encoding: "utf8" });
+    for await (const chunk of reader) {
+      buf += chunk;
+      let nl = buf.indexOf(`
+`);
+      while (nl !== -1) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        nl = buf.indexOf(`
+`);
+        processLine(line);
+      }
+    }
+    if (buf.trim())
+      processLine(buf);
+  } finally {
+    await handle.close().catch(() => {});
+  }
+  if (!sessionId || !cwd)
+    return null;
+  return {
+    sessionId,
+    cwd,
+    mtimeMs: st.mtimeMs,
+    firstUserMessage: firstUser,
+    messageCount
+  };
+}
+function safeParse(line) {
+  const t = line.trim();
+  if (!t)
+    return null;
+  try {
+    const v = JSON.parse(t);
+    return isObject6(v) ? v : null;
+  } catch {
+    return null;
+  }
+}
+function isObject6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var PREVIEW_CHAR_CAP = 200;
+var init_sessions2 = __esm(() => {
+  init_history2();
+  init_synthetic();
+});
+
+// src/engine/codex-local/spawn.ts
+import { spawn as spawn3 } from "child_process";
+function spawnCodexProcess(opts) {
+  const args = buildArgs2(opts);
+  const proc = spawn3(opts.binaryPath, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  try {
+    proc.stdin.end();
+  } catch {}
+  return {
+    proc,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    args
+  };
+}
+function buildArgs2(opts) {
+  const isResume = !!opts.resumeSessionId;
+  const args = ["exec"];
+  if (isResume) {
+    args.push("resume", opts.resumeSessionId);
+  }
+  args.push("--json", "--skip-git-repo-check");
+  if (opts.model) {
+    args.push("-m", opts.model);
+  }
+  if (opts.modelEffort) {
+    args.push("-c", `model_reasoning_effort="${opts.modelEffort}"`);
+  }
+  if (!isResume) {
+    args.push("-C", opts.cwd);
+    if (opts.permissionMode === "plan")
+      args.push("-s", "read-only");
+  }
+  if (opts.permissionMode !== "plan") {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  if (opts.extraArgs && opts.extraArgs.length > 0) {
+    args.push(...opts.extraArgs);
+  }
+  args.push(opts.prompt);
+  return args;
+}
+var init_spawn2 = () => {};
+
+// src/engine/codex-local/stream.ts
+async function* parseStreamJson2(lines, opts = {}) {
+  let sessionIdEmitted = false;
+  const toolNameById = new Map;
+  const startedByItemId = new Set;
+  for await (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch (err) {
+      yield { type: "error", message: `codex stream-json parse failed: ${stringifyErr2(err)}` };
+      continue;
+    }
+    if (!isObject7(msg))
+      continue;
+    const type = typeof msg.type === "string" ? msg.type : undefined;
+    if (!type)
+      continue;
+    if (type === "session_meta" || type === "thread.started") {
+      const sid = codexSessionId(msg);
+      if (sid && !sessionIdEmitted) {
+        sessionIdEmitted = true;
+        opts.onSessionId?.(sid);
+      }
+      continue;
+    }
+    if (type === "turn.started")
+      continue;
+    if (type === "item.started" || type === "item.completed") {
+      const item = isObject7(msg.item) ? msg.item : undefined;
+      if (!item)
+        continue;
+      const itemId = typeof item.id === "string" ? item.id : undefined;
+      const itemType = typeof item.type === "string" ? item.type : "tool";
+      if (itemType === "agent_message") {
+        if (type !== "item.completed")
+          continue;
+        const text = typeof item.text === "string" ? item.text : "";
+        if (text)
+          yield { type: "assistant.delta", text };
+        continue;
+      }
+      if (itemId) {
+        toolNameById.set(itemId, itemType);
+      }
+      if (type === "item.started") {
+        if (itemId)
+          startedByItemId.add(itemId);
+        const input = stripIdAndType(item);
+        yield { type: "tool.start", name: itemType, input };
+        continue;
+      }
+      if (itemId && !startedByItemId.has(itemId)) {
+        const input = stripIdAndType(item);
+        yield { type: "tool.start", name: itemType, input };
+      }
+      if (itemId)
+        startedByItemId.delete(itemId);
+      const output = stripIdAndType(item);
+      yield { type: "tool.result", name: itemType, output };
+      continue;
+    }
+    if (type === "turn.completed") {
+      const usage = isObject7(msg.usage) ? msg.usage : undefined;
+      if (usage) {
+        const inTok = numberOr2(usage.input_tokens, 0);
+        const outTok = numberOr2(usage.output_tokens, 0) + numberOr2(usage.reasoning_output_tokens, 0);
+        const cacheRead = typeof usage.cached_input_tokens === "number" ? usage.cached_input_tokens : undefined;
+        yield {
+          type: "usage",
+          input_tokens: inTok,
+          output_tokens: outTok,
+          ...cacheRead !== undefined ? { cache_read_input_tokens: cacheRead } : {}
+        };
+      }
+      yield { type: "done" };
+      return;
+    }
+    if (type === "error") {
+      const message = typeof msg.message === "string" ? msg.message : "codex emitted an error";
+      yield { type: "error", message };
+      return;
+    }
+  }
+}
+async function* readLines2(stream) {
+  let buf = "";
+  for await (const chunk of stream) {
+    const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+    buf += text;
+    let nl = buf.indexOf(`
+`);
+    while (nl !== -1) {
+      yield buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      nl = buf.indexOf(`
+`);
+    }
+  }
+  if (buf.length > 0)
+    yield buf;
+}
+function isObject7(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function codexSessionId(msg) {
+  if (msg.type === "session_meta") {
+    const payload = isObject7(msg.payload) ? msg.payload : undefined;
+    const id2 = payload?.id;
+    return typeof id2 === "string" && id2.length > 0 ? id2 : undefined;
+  }
+  const id = msg.thread_id;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+function numberOr2(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function stripIdAndType(item) {
+  const { id: _id, type: _type, ...rest } = item;
+  return rest;
+}
+function stringifyErr2(err) {
+  if (err instanceof Error)
+    return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// src/engine/codex-local/index.ts
+class CodexLocal {
+  identity = codexIdentity;
+  capabilities = codexCapabilities;
+  registry = new SessionRegistry;
+  running = new Map;
+  binaryPathResolver;
+  stopGraceMs;
+  constructor(opts = {}) {
+    this.binaryPathResolver = opts.binaryPathResolver ?? findCodexBinary;
+    this.stopGraceMs = opts.stopGraceMs ?? 5000;
+  }
+  async spawn(cwd, prompt, opts) {
+    return this.start({ cwd, prompt, opts });
+  }
+  async resume(sessionId, prompt, opts) {
+    const cwd = opts?.cwd ?? opts?.env?.KOBE_RESUME_CWD ?? process.cwd();
+    return this.start({ cwd, prompt, opts, resumeSessionId: sessionId });
+  }
+  stream(handle) {
+    const sid = handle.sessionId;
+    const self = this;
+    return {
+      async* [Symbol.asyncIterator]() {
+        const session = self.running.get(sid);
+        if (!session)
+          return;
+        let idx = 0;
+        while (true) {
+          if (idx < session.queue.length) {
+            const ev = session.queue[idx++];
+            if (!ev)
+              continue;
+            yield ev;
+            if (ev.type === "done" || ev.type === "error")
+              return;
+            continue;
+          }
+          if (session.closed)
+            return;
+          await new Promise((resolve2) => session.waiters.push(resolve2));
+        }
+      }
+    };
+  }
+  async readHistory(sessionId) {
+    return readHistoryWithMetrics(sessionId);
+  }
+  async deleteHistory(sessionId) {
+    return deleteHistory2(sessionId);
+  }
+  async listSessions(cwd) {
+    return listSessionsForCwd2(cwd);
+  }
+  async stop(handle) {
+    const sid = handle.sessionId;
+    await this.registry.kill(sid, this.stopGraceMs);
+    const session = this.running.get(sid);
+    if (session) {
+      session.closed = true;
+      this.notify(session);
+      this.running.delete(sid);
+    }
+  }
+  async start(args) {
+    const binaryPath = await this.binaryPathResolver();
+    const spawned = spawnCodexProcess({
+      binaryPath,
+      cwd: args.cwd,
+      prompt: args.prompt,
+      model: args.opts?.model,
+      modelEffort: args.opts?.modelEffort,
+      permissionMode: args.opts?.permissionMode,
+      env: args.opts?.env,
+      resumeSessionId: args.resumeSessionId
+    });
+    let resolveHandle = () => {};
+    let rejectHandle = () => {};
+    const handlePromise = new Promise((res, rej) => {
+      resolveHandle = res;
+      rejectHandle = rej;
+    });
+    const queue = [];
+    let session;
+    let bound = false;
+    let stderrTail = "";
+    const bind = (sessionId) => {
+      if (bound) {
+        if (session && session.sessionId !== sessionId) {
+          queue.push({
+            type: "error",
+            message: `codex resumed to a different session id (got ${sessionId}, expected ${session.sessionId})`
+          });
+          this.notify(session);
+        }
+        return;
+      }
+      bound = true;
+      session = {
+        sessionId,
+        cwd: args.cwd,
+        spawned,
+        queue,
+        waiters: [],
+        closed: false,
+        spawnedAtIso: new Date().toISOString()
+      };
+      this.running.set(sessionId, session);
+      this.registry.register({
+        sessionId,
+        cwd: args.cwd,
+        proc: spawned.proc,
+        startedAt: Date.now(),
+        prompt: args.prompt
+      });
+      resolveHandle({ sessionId, cwd: args.cwd });
+    };
+    if (args.resumeSessionId) {
+      try {
+        bind(args.resumeSessionId);
+      } catch (err) {
+        try {
+          spawned.proc.kill("SIGKILL");
+        } catch {}
+        rejectHandle(err);
+        throw err;
+      }
+    }
+    captureStderrTail(spawned.stderr, (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CAP);
+    });
+    const exitInfo = {
+      code: null,
+      signal: null,
+      seen: false
+    };
+    const exitObserved = new Promise((resolve2) => {
+      spawned.proc.once("exit", (code, signal) => {
+        exitInfo.code = code;
+        exitInfo.signal = signal;
+        exitInfo.seen = true;
+        if (!bound) {
+          rejectHandle(new Error(formatExitMsg("codex exited before session id was captured", code, signal, stderrTail)));
+        }
+        resolve2();
+      });
+    });
+    (async () => {
+      const events = parseStreamJson2(readLines2(spawned.stdout), {
+        onSessionId: (sid) => bind(sid)
+      });
+      try {
+        for await (const ev of events) {
+          const enriched = enrichUsageEvent2(ev, session?.spawnedAtIso);
+          queue.push(enriched);
+          if (session)
+            this.notify(session);
+          if ((enriched.type === "done" || enriched.type === "error") && session) {
+            this.registry.unregister(session.sessionId, spawned.proc);
+          }
+        }
+      } catch (err) {
+        const ev = {
+          type: "error",
+          message: `codex parser failure: ${err instanceof Error ? err.message : String(err)}`
+        };
+        queue.push(ev);
+        if (session)
+          this.notify(session);
+      } finally {
+        await Promise.race([exitObserved, new Promise((r) => setTimeout(r, 500))]);
+        if (session) {
+          const code = exitInfo.code;
+          const lastEv = queue[queue.length - 1];
+          if (exitInfo.seen && typeof code === "number" && code !== 0 && lastEv?.type !== "error") {
+            queue.push({
+              type: "error",
+              message: formatExitMsg("codex exited", code, exitInfo.signal, stderrTail)
+            });
+          }
+          session.closed = true;
+          this.notify(session);
+          this.registry.unregister(session.sessionId, spawned.proc);
+          if (this.running.get(session.sessionId) === session) {
+            this.running.delete(session.sessionId);
+          }
+        }
+        if (!bound) {
+          rejectHandle(new Error("codex exited without emitting a session id"));
+        }
+      }
+    })();
+    spawned.proc.once("error", (err) => {
+      if (!bound)
+        rejectHandle(err);
+    });
+    return handlePromise;
+  }
+  notify(session) {
+    const waiters = session.waiters;
+    session.waiters = [];
+    for (const w of waiters)
+      w();
+  }
+}
+function captureStderrTail(stream, onChunk) {
+  const s = stream;
+  s.on("data", (chunk) => {
+    onChunk(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
+  });
+  s.on("error", () => {});
+}
+function formatExitMsg(prefix, code, signal, stderrTail) {
+  const parts = [prefix];
+  if (typeof code === "number")
+    parts.push(`(code=${code}${signal ? `, signal=${signal}` : ""})`);
+  else if (signal)
+    parts.push(`(signal=${signal})`);
+  const detail = stderrTail.trim().split(/\r?\n/).filter(Boolean).slice(-3).join(" | ");
+  if (detail)
+    parts.push(`: ${detail}`);
+  return parts.join(" ").replace(/ : /, ": ");
+}
+function enrichUsageEvent2(ev, startedAtIso) {
+  if (ev.type !== "usage")
+    return ev;
+  return { type: "usage", ...withTotalSpeedForTurn(ev, startedAtIso, new Date().toISOString()) };
+}
+var STDERR_TAIL_CAP;
+var init_codex_local = __esm(() => {
+  init_binary2();
+  init_capabilities2();
+  init_history2();
+  init_sessions2();
+  init_spawn2();
+  STDERR_TAIL_CAP = 4 * 1024;
+});
+
 // src/orchestrator/bridge/server.ts
-import { mkdir as mkdir2, unlink as unlink2 } from "fs/promises";
+import { mkdir as mkdir2, unlink as unlink3 } from "fs/promises";
 import { createServer } from "net";
 import { dirname as dirname2 } from "path";
 async function startBridgeServer(orch, socketPath) {
   await mkdir2(dirname2(socketPath), { recursive: true });
-  await unlink2(socketPath).catch(() => {});
+  await unlink3(socketPath).catch(() => {});
   const conns = new Set;
   const server = createServer((conn) => {
     conns.add(conn);
@@ -1207,7 +2493,7 @@ async function startBridgeServer(orch, socketPath) {
         conn.destroy();
       conns.clear();
       await new Promise((resolve2) => server.close(() => resolve2()));
-      await unlink2(socketPath).catch(() => {});
+      await unlink3(socketPath).catch(() => {});
     }
   };
 }
@@ -1300,23 +2586,19 @@ __export(exports_bridge, {
   bridgeSocketPathForHome: () => bridgeSocketPathForHome
 });
 import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir5, tmpdir as tmpdir2 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join5 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function bridgeSocketPathForHome(home, pid = process.pid) {
-  const runDir = join3(home, ".kobe", "run");
-  const preferred = join3(runDir, `bridge-${pid}.sock`);
-  const macTempSocket = process.platform === "darwin" && preferred.startsWith(tmpdir2());
-  if (preferred.length <= UNIX_SOCKET_PATH_LIMIT && !macTempSocket)
-    return preferred;
-  const shortTmp = process.platform === "darwin" ? "/tmp" : tmpdir2();
-  return join3(shortTmp, `kobe-bridge-${pid}.sock`);
+  const runDir = join5(home, ".kobe", "run");
+  return fitSocketPath(join5(runDir, `bridge-${pid}.sock`), home, "bridge", pid);
 }
 async function startBridge(orch, opts = {}) {
-  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir5();
-  const runDir = join3(home, ".kobe", "run");
+  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir9();
+  const runDir = join5(home, ".kobe", "run");
   const socketPath = bridgeSocketPathForHome(home);
-  const mcpConfigPath = join3(runDir, `mcp-${process.pid}.json`);
+  const mcpConfigPath = join5(runDir, `mcp-${process.pid}.json`);
+  await mkdir3(runDir, { recursive: true });
   const server = await startBridgeServer(orch, socketPath);
   await mkdir3(runDir, { recursive: true });
   const moduleExt = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
@@ -1339,8 +2621,8 @@ async function startBridge(orch, opts = {}) {
     }
   };
 }
-var UNIX_SOCKET_PATH_LIMIT = 103;
 var init_bridge = __esm(() => {
+  init_paths();
   init_server();
 });
 
@@ -2572,134 +3854,83 @@ var init_dev = __esm(() => {
   }
 });
 
-// src/engine/claude-settings.ts
-import { readFileSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join4 } from "path";
-function readClaudeSettings() {
-  if (cached !== undefined)
-    return cached;
-  try {
-    const raw = readFileSync(SETTINGS_PATH, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") {
-      cached = null;
-      return null;
-    }
-    const obj = parsed;
-    const model = typeof obj.model === "string" && obj.model.length > 0 ? obj.model : undefined;
-    cached = { model };
-    return cached;
-  } catch {
-    cached = null;
-    return null;
+// src/engine/registry.ts
+function getCapabilities(vendor) {
+  return ENGINE_REGISTRY[vendor] ?? defaultCapabilities;
+}
+function getIdentity(vendor) {
+  return ENGINE_IDENTITIES[vendor] ?? defaultIdentity;
+}
+function capabilitiesForModelId(modelId) {
+  if (!modelId)
+    return defaultCapabilities;
+  for (const caps of Object.values(ENGINE_REGISTRY)) {
+    if (!caps)
+      continue;
+    if (caps.models.some((m) => m.id === modelId))
+      return caps;
   }
+  return defaultCapabilities;
 }
-function resolveDefaultModelId() {
-  const settings = readClaudeSettings();
-  if (settings?.model && settings.model.length > 0)
-    return settings.model;
-  return FALLBACK_DEFAULT_MODEL_ID;
-}
-var SETTINGS_PATH, cached, FALLBACK_DEFAULT_MODEL_ID = "claude-opus-4-7[1m]";
-var init_claude_settings = __esm(() => {
-  SETTINGS_PATH = join4(homedir6(), ".claude", "settings.json");
-});
-
-// src/session/usage-metrics.ts
-function totalContextTokens(u) {
-  return u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
-}
-function parseTimestampMs(value) {
-  const ms = new Date(value).getTime();
-  return Number.isFinite(ms) ? ms : null;
-}
-function mergeIntervals(intervals) {
-  if (intervals.length === 0)
-    return [];
-  const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs);
-  const first = sorted[0];
-  if (!first)
-    return [];
-  const merged = [{ startMs: first.startMs, endMs: first.endMs }];
-  for (let i = 1;i < sorted.length; i++) {
-    const current = sorted[i];
-    const last = merged[merged.length - 1];
-    if (!current || !last)
+function allModels() {
+  const seen = new Set;
+  const out = [];
+  for (const caps of Object.values(ENGINE_REGISTRY)) {
+    if (!caps)
       continue;
-    if (current.startMs <= last.endMs) {
-      last.endMs = Math.max(last.endMs, current.endMs);
-    } else {
-      merged.push({ startMs: current.startMs, endMs: current.endMs });
+    for (const m of caps.models) {
+      const key = `${m.vendor}:${m.id}:${m.effort ?? ""}`;
+      if (seen.has(key))
+        continue;
+      seen.add(key);
+      out.push(m);
     }
   }
-  return merged;
-}
-function durationMs(intervals) {
-  return intervals.reduce((total, interval) => total + (interval.endMs - interval.startMs), 0);
+  return out;
 }
-function deriveSessionUsageMetrics(past) {
-  let latestUsage;
-  let latestUsageTimestampMs = null;
-  let lastUserTimestampMs = null;
-  let inputTokens = 0;
-  let outputTokens = 0;
-  const intervals = [];
-  for (const message of past) {
-    const timestampMs = parseTimestampMs(message.timestamp);
-    if (message.role === "user" && timestampMs !== null) {
-      lastUserTimestampMs = timestampMs;
-      continue;
-    }
-    if (message.role !== "assistant" || !message.usage)
+function modelLabelFor(modelId, effort) {
+  const resolved = modelId ?? defaultCapabilities.defaultModelId();
+  for (const caps of Object.values(ENGINE_REGISTRY)) {
+    if (!caps)
       continue;
-    if (timestampMs !== null && (latestUsageTimestampMs === null || timestampMs > latestUsageTimestampMs)) {
-      latestUsageTimestampMs = timestampMs;
-      latestUsage = message.usage;
-    } else if (latestUsage === undefined) {
-      latestUsage = message.usage;
-    }
-    inputTokens += message.usage.input_tokens;
-    outputTokens += message.usage.output_tokens;
-    if (timestampMs !== null && lastUserTimestampMs !== null && timestampMs > lastUserTimestampMs) {
-      intervals.push({ startMs: lastUserTimestampMs, endMs: timestampMs });
-    }
-  }
-  if (!latestUsage)
-    return;
-  const totalDurationMs = durationMs(mergeIntervals(intervals));
-  if (totalDurationMs <= 0)
-    return latestUsage;
-  return {
-    ...latestUsage,
-    total_speed_tokens_per_second: (inputTokens + outputTokens) / (totalDurationMs / 1000)
+    const match = caps.models.find((m) => m.id === resolved && (effort === undefined || m.effort === effort));
+    if (match)
+      return match.label;
+  }
+  if (effort)
+    return `${resolved} \xB7 ${effort}`;
+  return resolved;
+}
+var ENGINE_REGISTRY, ENGINE_IDENTITIES, defaultCapabilities, defaultIdentity;
+var init_registry = __esm(() => {
+  init_capabilities();
+  init_capabilities2();
+  ENGINE_REGISTRY = {
+    claude: claudeCapabilities,
+    codex: codexCapabilities
   };
-}
-function withTotalSpeedForTurn(usage, startedAtIso, endedAtIso) {
-  const startMs = startedAtIso ? parseTimestampMs(startedAtIso) : null;
-  const endMs = parseTimestampMs(endedAtIso);
-  if (startMs === null || endMs === null || endMs <= startMs)
-    return usage;
-  return {
-    ...usage,
-    total_speed_tokens_per_second: (usage.input_tokens + usage.output_tokens) / ((endMs - startMs) / 1000)
+  ENGINE_IDENTITIES = {
+    claude: claudeIdentity,
+    codex: codexIdentity
   };
-}
+  defaultCapabilities = claudeCapabilities;
+  defaultIdentity = claudeIdentity;
+});
 
 // src/env.ts
-import { homedir as homedir7 } from "os";
-import { join as join5 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join6 } from "path";
 function isDev() {
   return process.env.KOBE_DEV === "1";
 }
 function homeDir() {
-  return process.env.KOBE_HOME_DIR ?? homedir7();
+  return process.env.KOBE_HOME_DIR ?? homedir10();
 }
 function kobeStateDir() {
-  return join5(homeDir(), ".kobe");
+  return join6(homeDir(), ".kobe");
 }
 function kvStatePath() {
-  return join5(homeDir(), ".config", "kobe", "state.json");
+  return join6(homeDir(), ".config", "kobe", "state.json");
 }
 var init_env = () => {};
 
@@ -2714,11 +3945,11 @@ __export(exports_repos, {
   getSavedRepos: () => getSavedRepos,
   addSavedRepo: () => addSavedRepo
 });
-import { spawnSync as spawnSync2 } from "child_process";
-import { mkdirSync, readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { mkdirSync, readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync } from "fs";
 import { dirname as dirname3 } from "path";
 function resolveRepoRoot(absPath) {
-  const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
+  const r = spawnSync3("git", ["rev-parse", "--show-toplevel"], {
     cwd: absPath,
     encoding: "utf8",
     shell: false
@@ -2752,7 +3983,7 @@ function statePath() {
 }
 function load() {
   try {
-    const text = readFileSync2(statePath(), "utf8");
+    const text = readFileSync3(statePath(), "utf8");
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -2761,11 +3992,11 @@ function load() {
   return {};
 }
 function save(state) {
-  const path4 = statePath();
-  mkdirSync(dirname3(path4), { recursive: true });
-  const tmp = `${path4}.tmp`;
+  const path6 = statePath();
+  mkdirSync(dirname3(path6), { recursive: true });
+  const tmp = `${path6}.tmp`;
   writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
-  renameSync(tmp, path4);
+  renameSync(tmp, path6);
 }
 function getSavedRepos() {
   const state = load();
@@ -2829,7 +4060,15 @@ function nextChatTabSeq(tabs) {
       max = t.seq;
   return max + 1;
 }
-var toTaskId = (id) => id;
+function worktreeSlug(task) {
+  if (task.kind === "main")
+    return "";
+  if (!task.worktreePath)
+    return "";
+  const match = task.worktreePath.match(/([^/\\]+)[/\\]*$/);
+  return match ? match[1] ?? "" : "";
+}
+var toTaskId = (id) => id, DEFAULT_TASK_VENDOR = "claude";
 
 // src/orchestrator/index/ulid.ts
 function encodeTime(now, len) {
@@ -2891,7 +4130,7 @@ var init_ulid = __esm(() => {
 });
 
 // src/orchestrator/metadata-suggester.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 
 class MetadataSuggester {
   binaryPromise = null;
@@ -2920,7 +4159,7 @@ class MetadataSuggester {
     return new Promise((resolve2) => {
       let proc;
       try {
-        proc = spawn3(binary, ["-p", builder(trimmed)], {
+        proc = spawn4(binary, ["-p", builder(trimmed)], {
           stdio: ["ignore", "pipe", "ignore"],
           env: process.env
         });
@@ -3069,10 +4308,10 @@ class InMemoryPendingInputBroker {
 }
 
 // src/orchestrator/pr/build.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 function git(cwd, args) {
   try {
-    const out = spawnSync3("git", args.slice(), {
+    const out = spawnSync4("git", args.slice(), {
       cwd,
       encoding: "utf8",
       timeout: GIT_TIMEOUT_MS
@@ -3122,7 +4361,7 @@ var init_build = () => {};
 
 // src/orchestrator/pr/instructions.ts
 import { promises as fs } from "fs";
-import path4 from "path";
+import path6 from "path";
 function dirtyCountSentence(n) {
   if (n <= 0)
     return "There are no uncommitted changes.";
@@ -3150,7 +4389,7 @@ function renderPRInstructions(template, state) {
 async function loadPRInstructionsTemplate(worktreePath) {
   if (!worktreePath)
     return DEFAULT_PR_INSTRUCTIONS_TEMPLATE;
-  const file = path4.join(worktreePath, ".kobe", "pr-instructions.md");
+  const file = path6.join(worktreePath, ".kobe", "pr-instructions.md");
   try {
     const text = await fs.readFile(file, "utf8");
     if (text.length === 0)
@@ -3201,10 +4440,11 @@ class SessionPump {
   }
   async run(taskId, tabId, handle) {
     const tabKey = chatRunStateKey(taskId, tabId);
+    const engine = this.env.engineFor(taskId, tabId);
     let killedForInput = false;
     let terminalEvent = null;
     try {
-      for await (const ev of this.env.engine.stream(handle)) {
+      for await (const ev of engine.stream(handle)) {
         const inputReq = detectUserInputFromEngineEvent(ev);
         if (inputReq) {
           this.env.dispatch(taskId, tabId, ev);
@@ -3218,7 +4458,7 @@ class SessionPump {
           });
           killedForInput = true;
           try {
-            await this.env.engine.stop(handle);
+            await engine.stop(handle);
           } catch {}
           break;
         }
@@ -3231,7 +4471,7 @@ class SessionPump {
     } finally {
       if (!killedForInput) {
         try {
-          await this.env.engine.stop(handle);
+          await engine.stop(handle);
         } catch {}
       }
     }
@@ -3242,6 +4482,548 @@ var init_session_pump = __esm(() => {
   init_core();
 });
 
+// src/orchestrator/worktree/animal-names.ts
+var ANIMAL_NAMES;
+var init_animal_names = __esm(() => {
+  ANIMAL_NAMES = [
+    "aardvark",
+    "addax",
+    "adder",
+    "agouti",
+    "albatross",
+    "alpaca",
+    "anaconda",
+    "anchovy",
+    "anglerfish",
+    "anole",
+    "anteater",
+    "antelope",
+    "ape",
+    "argali",
+    "armadillo",
+    "avocet",
+    "axolotl",
+    "baboon",
+    "badger",
+    "banteng",
+    "barracuda",
+    "basilisk",
+    "bass",
+    "bat",
+    "beagle",
+    "bear",
+    "beaver",
+    "bee",
+    "beetle",
+    "beluga",
+    "betta",
+    "bison",
+    "blackbird",
+    "blenny",
+    "bluebird",
+    "bluegill",
+    "boar",
+    "bobcat",
+    "bonito",
+    "bovid",
+    "buffalo",
+    "bullfrog",
+    "bunting",
+    "bushbuck",
+    "butterfly",
+    "buzzard",
+    "caiman",
+    "camel",
+    "canary",
+    "capybara",
+    "caracal",
+    "cardinal",
+    "caribou",
+    "carp",
+    "cassowary",
+    "caterpillar",
+    "catfish",
+    "chameleon",
+    "chamois",
+    "char",
+    "cheetah",
+    "chickadee",
+    "chimp",
+    "chinchilla",
+    "chipmunk",
+    "chough",
+    "cicada",
+    "civet",
+    "clam",
+    "clownfish",
+    "cobra",
+    "cockatoo",
+    "condor",
+    "coot",
+    "copperhead",
+    "coral",
+    "cormorant",
+    "cougar",
+    "coyote",
+    "crab",
+    "crane",
+    "crawfish",
+    "crayfish",
+    "cricket",
+    "crocodile",
+    "crow",
+    "cuckoo",
+    "curlew",
+    "cuttlefish",
+    "deer",
+    "dikdik",
+    "dingo",
+    "dolphin",
+    "donkey",
+    "dormouse",
+    "dotterel",
+    "dove",
+    "dragonfly",
+    "dromedary",
+    "duck",
+    "dugong",
+    "dunlin",
+    "eagle",
+    "echidna",
+    "eel",
+    "egret",
+    "eider",
+    "eland",
+    "elephant",
+    "elk",
+    "emu",
+    "ermine",
+    "falcon",
+    "fawn",
+    "ferret",
+    "finch",
+    "firefly",
+    "flamingo",
+    "flounder",
+    "fox",
+    "frog",
+    "gadwall",
+    "gannet",
+    "gaur",
+    "gazelle",
+    "gecko",
+    "gemsbok",
+    "gerbil",
+    "gharial",
+    "gibbon",
+    "gnu",
+    "goat",
+    "goby",
+    "godwit",
+    "goldfish",
+    "goose",
+    "gopher",
+    "goral",
+    "gorilla",
+    "goshawk",
+    "grackle",
+    "grasshopper",
+    "grayling",
+    "grebe",
+    "grouse",
+    "guanaco",
+    "guillemot",
+    "guineafowl",
+    "guppy",
+    "halibut",
+    "hammerhead",
+    "hamster",
+    "hare",
+    "harrier",
+    "hartebeest",
+    "hawk",
+    "hedgehog",
+    "heron",
+    "herring",
+    "hippo",
+    "hornbill",
+    "hornet",
+    "horse",
+    "hummingbird",
+    "hyena",
+    "ibex",
+    "ibis",
+    "iguana",
+    "impala",
+    "indri",
+    "jacana",
+    "jackal",
+    "jaguar",
+    "jay",
+    "jellyfish",
+    "jerboa",
+    "junco",
+    "kakapo",
+    "kangaroo",
+    "kestrel",
+    "killdeer",
+    "kingfisher",
+    "kinglet",
+    "kite",
+    "kiwi",
+    "koala",
+    "kookaburra",
+    "krait",
+    "krill",
+    "kudu",
+    "ladybug",
+    "lamprey",
+    "langur",
+    "lapwing",
+    "lark",
+    "lemming",
+    "lemur",
+    "leopard",
+    "limpet",
+    "lion",
+    "lionfish",
+    "lizard",
+    "llama",
+    "lobster",
+    "locust",
+    "loon",
+    "lorikeet",
+    "loris",
+    "lynx",
+    "macaque",
+    "macaw",
+    "mackerel",
+    "magpie",
+    "mallard",
+    "mamba",
+    "mammoth",
+    "manatee",
+    "mandrill",
+    "manta",
+    "mantis",
+    "marlin",
+    "marmoset",
+    "marmot",
+    "marten",
+    "meerkat",
+    "merganser",
+    "mink",
+    "minnow",
+    "mole",
+    "mongoose",
+    "monitor",
+    "monkey",
+    "moose",
+    "moth",
+    "mouflon",
+    "mouse",
+    "mudpuppy",
+    "mule",
+    "muntjac",
+    "musk",
+    "muskox",
+    "muskrat",
+    "mussel",
+    "mustang",
+    "narwhal",
+    "newt",
+    "nightingale",
+    "numbat",
+    "nuthatch",
+    "nyala",
+    "ocelot",
+    "octopus",
+    "okapi",
+    "opossum",
+    "orangutan",
+    "orca",
+    "oriole",
+    "oryx",
+    "osprey",
+    "ostrich",
+    "otter",
+    "owl",
+    "oyster",
+    "oystercatcher",
+    "paca",
+    "panda",
+    "pangolin",
+    "panther",
+    "parakeet",
+    "parrot",
+    "parrotfish",
+    "partridge",
+    "peafowl",
+    "pelican",
+    "penguin",
+    "perch",
+    "petrel",
+    "pheasant",
+    "pigeon",
+    "pika",
+    "pike",
+    "pintail",
+    "pipefish",
+    "platypus",
+    "plover",
+    "pollock",
+    "pony",
+    "porcupine",
+    "porpoise",
+    "possum",
+    "ptarmigan",
+    "puffin",
+    "puma",
+    "pupfish",
+    "python",
+    "quail",
+    "quetzal",
+    "quokka",
+    "quoll",
+    "rabbit",
+    "raccoon",
+    "rail",
+    "rat",
+    "rattler",
+    "raven",
+    "ray",
+    "redpoll",
+    "reindeer",
+    "remora",
+    "rhino",
+    "roadrunner",
+    "robin",
+    "rook",
+    "sable",
+    "sailfish",
+    "salamander",
+    "salmon",
+    "sandpiper",
+    "sardine",
+    "scallop",
+    "scaup",
+    "scorpion",
+    "seahorse",
+    "seal",
+    "serval",
+    "shark",
+    "shearwater",
+    "shrew",
+    "shrike",
+    "shrimp",
+    "siskin",
+    "sitatunga",
+    "skate",
+    "skink",
+    "skua",
+    "skunk",
+    "sloth",
+    "smelt",
+    "snail",
+    "snipe",
+    "solenodon",
+    "sparrow",
+    "spider",
+    "springbok",
+    "squid",
+    "squirrel",
+    "starfish",
+    "starling",
+    "stilt",
+    "stingray",
+    "stoat",
+    "stork",
+    "sunbird",
+    "sunfish",
+    "swallow",
+    "swan",
+    "swift",
+    "swordfish",
+    "tahr",
+    "takin",
+    "tamarin",
+    "tanager",
+    "tapir",
+    "tarantula",
+    "tarpon",
+    "tarsier",
+    "teal",
+    "tenrec",
+    "terrapin",
+    "tern",
+    "tetra",
+    "thrasher",
+    "thrush",
+    "tiger",
+    "toad",
+    "tortoise",
+    "toucan",
+    "treecreeper",
+    "treefrog",
+    "trout",
+    "tuatara",
+    "tuna",
+    "turkey",
+    "turtle",
+    "urchin",
+    "urial",
+    "vicuna",
+    "viper",
+    "vole",
+    "vulture",
+    "wagtail",
+    "wallaby",
+    "walleye",
+    "walrus",
+    "warbler",
+    "warthog",
+    "waterbuck",
+    "weasel",
+    "wildebeest",
+    "wolf",
+    "wolverine",
+    "wombat",
+    "woodcock",
+    "woodpecker",
+    "wrasse",
+    "wren",
+    "yak",
+    "zebra",
+    "zebu",
+    "zorilla"
+  ];
+});
+
+// src/orchestrator/worktree/paths.ts
+import fs2 from "fs";
+import path7 from "path";
+function worktreeRootFor(repo) {
+  if (!path7.isAbsolute(repo)) {
+    throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
+  }
+  return path7.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
+}
+function worktreePathFor(repo, slug) {
+  if (!slug || /[/\\\0]/.test(slug)) {
+    throw new Error(`worktreePathFor: invalid slug: ${JSON.stringify(slug)}`);
+  }
+  return path7.join(worktreeRootFor(repo), slug);
+}
+function listWorktreeDirNames(repo) {
+  const root = worktreeRootFor(repo);
+  try {
+    return fs2.readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function isKobeManagedPath(repo, candidate) {
+  if (!path7.isAbsolute(repo) || !path7.isAbsolute(candidate))
+    return false;
+  const root = canonicalize(worktreeRootFor(repo));
+  const target = canonicalize(candidate);
+  const rel = path7.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
+}
+function canonicalize(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return path7.resolve(p);
+  }
+}
+var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
+var init_paths2 = () => {};
+
+// src/orchestrator/worktree/slug-allocator.ts
+class SlugAllocator {
+  activeSlugs;
+  random;
+  pool;
+  pendingByRepo = new Map;
+  chain = Promise.resolve();
+  constructor(activeSlugs, options = {}) {
+    this.activeSlugs = activeSlugs;
+    this.random = options.random ?? Math.random;
+    this.pool = options.pool ?? ANIMAL_NAMES;
+    if (this.pool.length === 0) {
+      throw new Error("SlugAllocator: animal pool cannot be empty");
+    }
+  }
+  async allocate(repo) {
+    const previous = this.chain;
+    let release;
+    this.chain = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    await previous;
+    try {
+      return this.pickLocked(repo);
+    } finally {
+      release();
+    }
+  }
+  commit(repo, slug) {
+    this.deletePending(repo, slug);
+  }
+  cancel(repo, slug) {
+    this.deletePending(repo, slug);
+  }
+  pickLocked(repo) {
+    const occupied = this.occupiedSlugs(repo);
+    const candidates = this.pool.filter((n) => !occupied.has(n));
+    if (candidates.length > 0) {
+      const pick = candidates[Math.floor(this.random() * candidates.length)];
+      this.addPending(repo, pick);
+      return pick;
+    }
+    const base = this.pool[Math.floor(this.random() * this.pool.length)];
+    for (let v = 2;; v++) {
+      const candidate = `${base}-v${v}`;
+      if (!occupied.has(candidate)) {
+        this.addPending(repo, candidate);
+        return candidate;
+      }
+    }
+  }
+  occupiedSlugs(repo) {
+    const set = new Set(this.pendingByRepo.get(repo) ?? []);
+    for (const slug of this.activeSlugs(repo)) {
+      if (slug)
+        set.add(slug);
+    }
+    for (const dir of listWorktreeDirNames(repo)) {
+      set.add(dir);
+    }
+    return set;
+  }
+  addPending(repo, slug) {
+    let pending = this.pendingByRepo.get(repo);
+    if (!pending) {
+      pending = new Set;
+      this.pendingByRepo.set(repo, pending);
+    }
+    pending.add(slug);
+  }
+  deletePending(repo, slug) {
+    const pending = this.pendingByRepo.get(repo);
+    if (!pending)
+      return;
+    pending.delete(slug);
+    if (pending.size === 0)
+      this.pendingByRepo.delete(repo);
+  }
+}
+var init_slug_allocator = __esm(() => {
+  init_animal_names();
+  init_paths2();
+});
+
 // src/orchestrator/core.ts
 var exports_core = {};
 __export(exports_core, {
@@ -3291,7 +5073,8 @@ function summarizeWorktreeError(raw, repo, baseRef) {
 }
 
 class Orchestrator {
-  engine;
+  engines;
+  fallbackEngine;
   store;
   worktrees;
   metadataSuggester;
@@ -3303,16 +5086,38 @@ class Orchestrator {
   requestIdCounter = 0;
   sessionPump;
   pendingWorktreeOpts = new Map;
+  slugAllocator;
+  ensureWorktreeLatches = new Map;
   tasksAcc;
   setTasks;
   unsubscribeStore;
   runStateAcc;
   setRunState;
   constructor(deps) {
-    this.engine = deps.engine;
+    const built = {};
+    let fallback;
+    if (deps.engines) {
+      for (const [vendor, eng] of Object.entries(deps.engines)) {
+        if (!eng)
+          continue;
+        built[vendor] = eng;
+        fallback ??= eng;
+      }
+    }
+    if (deps.engine) {
+      const v = deps.engine.capabilities.vendorId;
+      built[v] ??= deps.engine;
+      fallback ??= deps.engine;
+    }
+    if (!fallback) {
+      throw new Error("Orchestrator: no usable engine found; both deps.engine and deps.engines were examined but contained no valid engines.");
+    }
+    this.engines = built;
+    this.fallbackEngine = fallback;
     this.store = deps.store;
     this.worktrees = deps.worktrees;
     this.metadataSuggester = deps.metadataSuggester ?? new MetadataSuggester;
+    this.slugAllocator = new SlugAllocator((repo) => this.store.list().filter((t) => t.repo === repo && !t.archived).map((t) => worktreeSlug(t)).filter((s) => s.length > 0));
     const [tasks, setTasks] = createSignal(this.store.list());
     this.tasksAcc = tasks;
     this.setTasks = (next) => setTasks(() => next);
@@ -3323,13 +5128,89 @@ class Orchestrator {
     this.runStateAcc = runState;
     this.setRunState = (next) => setRunState(() => next);
     this.sessionPump = new SessionPump({
-      engine: this.engine,
+      engineFor: (taskId, tabId) => this.engineForTaskTabId(taskId, tabId),
       broker: this.pendingInputBroker,
       dispatch: (taskId, tabId, ev) => this.dispatchEvent(taskId, tabId, ev),
       nextRequestId: () => `req-${++this.requestIdCounter}`,
       onPendingInputChange: () => this.bumpRunState()
     });
   }
+  engineForVendor(vendor) {
+    const v = vendor ?? DEFAULT_TASK_VENDOR;
+    return this.engines[v] ?? this.fallbackEngine;
+  }
+  engineForTask(task) {
+    return this.engineForVendor(task.vendor);
+  }
+  vendorForTab(task, tab) {
+    return tab.vendor ?? task.vendor ?? "claude";
+  }
+  modelForTab(task, tab, engine) {
+    return tab.model ?? task.model ?? engine.capabilities.defaultModelId();
+  }
+  modelEffortForTab(task, tab) {
+    return tab.modelEffort ?? task.modelEffort;
+  }
+  engineForTab(task, tab) {
+    return this.engineForVendor(this.vendorForTab(task, tab));
+  }
+  async engineForTabRun(task, tab) {
+    if (!tab.sessionId || tab.vendor)
+      return this.engineForTab(task, tab);
+    const resolved = await this.findEngineWithHistory(tab.sessionId, this.vendorForTab(task, tab));
+    if (resolved.vendor && resolved.vendor !== tab.vendor) {
+      await this.updateTab(task.id, tab.id, { vendor: resolved.vendor });
+    }
+    return resolved.engine;
+  }
+  async findEngineWithHistory(sessionId, preferredVendor) {
+    const candidates = [];
+    if (preferredVendor)
+      candidates.push([preferredVendor, this.engineForVendor(preferredVendor)]);
+    for (const [vendor, engine] of Object.entries(this.engines)) {
+      if (!engine || vendor === preferredVendor)
+        continue;
+      candidates.push([vendor, engine]);
+    }
+    if (candidates.length === 0)
+      candidates.push([undefined, this.fallbackEngine]);
+    let fallback = candidates[0] ?? [undefined, this.fallbackEngine];
+    let fallbackHistory;
+    for (const [vendor, engine] of candidates) {
+      try {
+        const history = await engine.readHistory(sessionId);
+        if (!fallbackHistory) {
+          fallback = [vendor, engine];
+          fallbackHistory = history;
+        }
+        if (history.messages.length > 0 || history.usageMetrics)
+          return { engine, vendor, history };
+      } catch {}
+    }
+    return { engine: fallback[1], vendor: fallback[0], history: fallbackHistory };
+  }
+  engineForTaskId(taskId) {
+    const task = this.store.get(taskId);
+    return task ? this.engineForTask(task) : this.fallbackEngine;
+  }
+  engineForTaskTabId(taskId, tabId) {
+    const task = this.store.get(taskId);
+    if (!task)
+      return this.fallbackEngine;
+    const tab = task.tabs.find((t) => t.id === tabId);
+    return tab ? this.engineForTab(task, tab) : this.engineForTask(task);
+  }
+  engineForSessionId(sessionId) {
+    for (const task of this.store.list()) {
+      for (const tab of task.tabs) {
+        if (tab.sessionId === sessionId)
+          return this.engineForTab(task, tab);
+      }
+      if (task.sessionId === sessionId)
+        return this.engineForTask(task);
+    }
+    return this.fallbackEngine;
+  }
   bumpRunState() {
     const next = new Map;
     for (const tabKey2 of this.pendingInputBroker.awaitingTabKeys()) {
@@ -3434,26 +5315,49 @@ class Orchestrator {
   async ensureWorktree(task) {
     if (task.worktreePath)
       return task;
+    const inflight = this.ensureWorktreeLatches.get(task.id);
+    if (inflight) {
+      await inflight;
+      return this.requireTask(task.id);
+    }
+    const latch = this.doEnsureWorktree(task);
+    this.ensureWorktreeLatches.set(task.id, latch);
+    try {
+      return await latch;
+    } finally {
+      this.ensureWorktreeLatches.delete(task.id);
+    }
+  }
+  async doEnsureWorktree(task) {
     const opts = this.pendingWorktreeOpts.get(task.id);
     const branch = opts?.branch ?? `kobe/tmp-${task.id.slice(-8).toLowerCase()}`;
     const baseRef = opts?.baseRef;
+    const slug = await this.slugAllocator.allocate(task.repo);
     let info;
     try {
       info = await this.worktrees.createForTask({
         repo: task.repo,
-        taskId: task.id,
+        slug,
         branch,
         baseRef
       });
     } catch (err) {
+      this.slugAllocator.cancel(task.repo, slug);
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(summarizeWorktreeError(message, task.repo, baseRef ?? null), { cause: err });
     }
-    this.pendingWorktreeOpts.delete(task.id);
-    return await this.store.update(task.id, {
-      branch: info.branch,
-      worktreePath: info.path
-    });
+    try {
+      this.pendingWorktreeOpts.delete(task.id);
+      const updated = await this.store.update(task.id, {
+        branch: info.branch,
+        worktreePath: info.path
+      });
+      this.slugAllocator.commit(task.repo, slug);
+      return updated;
+    } catch (err) {
+      this.slugAllocator.cancel(task.repo, slug);
+      throw err;
+    }
   }
   async maybeRenameTempBranch(taskId, tabId, prompt) {
     if (!prompt || prompt.trim().length === 0)
@@ -3549,14 +5453,17 @@ class Orchestrator {
     if (prompt && prompt.trim().length > 0) {
       this.dispatchEvent(task.id, targetTab.id, { type: "user.inject", text: prompt });
     }
-    const modelToUse = task.model ?? resolveDefaultModelId();
+    const engine = targetTab.sessionId ? await this.engineForTabRun(task, targetTab) : this.engineForTab(task, targetTab);
+    const modelToUse = this.modelForTab(task, targetTab, engine);
+    const modelEffortToUse = this.modelEffortForTab(task, targetTab);
     let handle;
     if (targetTab.sessionId) {
-      handle = await this.engine.resume(targetTab.sessionId, promptToSend, {
+      handle = await engine.resume(targetTab.sessionId, promptToSend, {
         cwd: task.worktreePath,
         env: { KOBE_RESUME_CWD: task.worktreePath },
         permissionMode: task.permissionMode,
-        model: modelToUse
+        model: modelToUse,
+        modelEffort: modelEffortToUse
       });
     } else {
       let releaseLatch = () => {};
@@ -3565,9 +5472,10 @@ class Orchestrator {
       });
       this.firstSpawnLatches.set(key, latch);
       try {
-        handle = await this.engine.spawn(task.worktreePath, promptToSend, {
+        handle = await engine.spawn(task.worktreePath, promptToSend, {
           permissionMode: task.permissionMode,
-          model: modelToUse
+          model: modelToUse,
+          modelEffort: modelEffortToUse
         });
         await this.updateTab(task.id, targetTab.id, { sessionId: handle.sessionId });
         if (task.title === PLACEHOLDER_TASK_TITLE && prompt && prompt.trim().length > 0) {
@@ -3640,7 +5548,7 @@ class Orchestrator {
       text: "(turn interrupted \u2014 sending new prompt)"
     });
     try {
-      await this.engine.stop(handle);
+      await this.engineForTask(task).stop(handle);
     } finally {
       this.handles.delete(key);
       this.bumpRunState();
@@ -3682,11 +5590,13 @@ class Orchestrator {
       return;
     await this.store.update(task.id, { permissionMode: mode });
   }
-  async setModel(id, model) {
+  async setModel(id, model, tabId, modelEffort) {
     const task = this.requireTask(id);
-    if (task.model === model)
+    const tab = this.resolveTab(task, tabId);
+    const vendor = model ? capabilitiesForModelId(model).vendorId : this.vendorForTab(task, tab);
+    if (tab.model === model && tab.modelEffort === modelEffort && this.vendorForTab(task, tab) === vendor)
       return;
-    await this.store.update(task.id, { model });
+    await this.updateTab(task.id, tab.id, { model, modelEffort, vendor });
   }
   async setTitle(id, title) {
     const task = this.requireTask(id);
@@ -3750,7 +5660,7 @@ class Orchestrator {
     }
     if (task.sessionId) {
       try {
-        await this.engine.deleteHistory(task.sessionId);
+        await this.engineForTask(task).deleteHistory(task.sessionId);
       } catch (err) {
         console.error(`[kobe orchestrator] deleteTask: deleteHistory failed for ${task.id}:`, err);
       }
@@ -3759,15 +5669,15 @@ class Orchestrator {
     await this.store.remove(task.id);
   }
   async readHistory(sessionId) {
-    try {
-      return await this.engine.readHistory(sessionId);
-    } catch {
-      return [];
-    }
+    return (await this.readHistoryWithMetrics(sessionId)).messages;
   }
   async readHistoryWithMetrics(sessionId) {
-    const messages = await this.readHistory(sessionId);
-    const usageMetrics = deriveSessionUsageMetrics(messages);
+    const preferred = this.engineForSessionId(sessionId);
+    const { history } = await this.findEngineWithHistory(sessionId, preferred.capabilities.vendorId);
+    if (!history)
+      return { messages: [] };
+    const messages = [...history.messages];
+    const usageMetrics = history.usageMetrics;
     return {
       messages,
       ...usageMetrics ? { usageMetrics } : {}
@@ -3777,14 +5687,16 @@ class Orchestrator {
     const task = this.requireTask(id);
     if (!task.worktreePath)
       return [];
+    const tab = this.resolveTab(task);
     try {
-      return await this.engine.listSessions(task.worktreePath);
+      return await this.engineForTab(task, tab).listSessions(task.worktreePath);
     } catch {
       return [];
     }
   }
   async openSessionInTab(id, sessionId, opts = {}) {
     const task = this.requireTask(id);
+    const active = this.resolveTab(task);
     const existing = task.tabs.find((t) => t.sessionId === sessionId);
     if (existing) {
       await this.setActiveTab(task.id, existing.id);
@@ -3795,6 +5707,8 @@ class Orchestrator {
       sessionId,
       seq: nextChatTabSeq(task.tabs),
       createdAt: new Date().toISOString(),
+      model: active.model ?? task.model,
+      vendor: this.vendorForTab(task, active),
       ...opts.title ? { title: opts.title } : {}
     };
     await this.store.update(task.id, { tabs: [...task.tabs, tab], activeTabId: tab.id });
@@ -3822,11 +5736,14 @@ class Orchestrator {
   }
   async createTab(id, opts = {}) {
     const task = this.requireTask(id);
+    const active = this.resolveTab(task);
     const tab = {
       id: ulid(),
       sessionId: null,
       seq: nextChatTabSeq(task.tabs),
       createdAt: new Date().toISOString(),
+      model: active.model ?? task.model,
+      vendor: this.vendorForTab(task, active),
       ...opts.title ? { title: opts.title } : {}
     };
     const tabs = [...task.tabs, tab];
@@ -3906,7 +5823,7 @@ class Orchestrator {
     if (!handle)
       return;
     try {
-      await this.engine.stop(handle);
+      await this.engineForTaskId(taskId).stop(handle);
     } finally {
       this.handles.delete(key);
       this.bumpRunState();
@@ -3915,12 +5832,13 @@ class Orchestrator {
   async stopAllTabsForTask(taskId) {
     const prefix = `${taskId}:`;
     const keys = Array.from(this.handles.keys()).filter((k) => k.startsWith(prefix));
+    const engine = this.engineForTaskId(taskId);
     for (const key of keys) {
       const handle = this.handles.get(key);
       if (!handle)
         continue;
       try {
-        await this.engine.stop(handle);
+        await engine.stop(handle);
       } catch {}
       this.handles.delete(key);
     }
@@ -4046,12 +5964,13 @@ function deriveTitleFromPrompt(prompt) {
 var CONCURRENCY_CAP = 20, PLACEHOLDER_TASK_TITLE = "(new task)", IllegalTransitionError, ConcurrencyCapError, PRPreconditionError, TaskNotFoundError, CannotDeleteMainTaskError, TITLE_CHAR_CAP = 40;
 var init_core = __esm(() => {
   init_dev();
-  init_claude_settings();
+  init_registry();
   init_repos();
   init_ulid();
   init_metadata_suggester();
   init_pr();
   init_session_pump();
+  init_slug_allocator();
   IllegalTransitionError = class IllegalTransitionError extends Error {
     from;
     to;
@@ -4091,9 +6010,9 @@ var init_core = __esm(() => {
 });
 
 // src/orchestrator/index/store.ts
-import { mkdir as mkdir4, open, readFile as readFile3, rename, unlink as unlink3 } from "fs/promises";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname4, join as join6 } from "path";
+import { mkdir as mkdir4, open as open2, readFile as readFile4, rename, unlink as unlink4 } from "fs/promises";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname4, join as join7 } from "path";
 
 class TaskIndexStore {
   homeDir;
@@ -4105,9 +6024,9 @@ class TaskIndexStore {
   listeners = new Set;
   saveChain = Promise.resolve();
   constructor(options = {}) {
-    this.homeDir = options.homeDir ?? homedir8();
-    this.kobeDir = join6(this.homeDir, ".kobe");
-    this.path = join6(this.kobeDir, "tasks.json");
+    this.homeDir = options.homeDir ?? homedir11();
+    this.kobeDir = join7(this.homeDir, ".kobe");
+    this.path = join7(this.kobeDir, "tasks.json");
     this.tmpPath = `${this.path}.tmp`;
   }
   subscribe(listener) {
@@ -4132,7 +6051,7 @@ class TaskIndexStore {
   async load() {
     let raw;
     try {
-      raw = await readFile3(this.path, "utf8");
+      raw = await readFile4(this.path, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -4169,7 +6088,7 @@ class TaskIndexStore {
     const payload = this.snapshot();
     const json = `${JSON.stringify(payload, null, 2)}
 `;
-    const handle = await open(this.tmpPath, "w", 420);
+    const handle = await open2(this.tmpPath, "w", 420);
     try {
       await handle.writeFile(json, "utf8");
       await handle.sync();
@@ -4197,7 +6116,17 @@ class TaskIndexStore {
       activeTabId = activeIn && tabsIn.some((t) => t.id === activeIn) ? activeIn : tabsIn[0]?.id ?? "";
     } else {
       const tabId = ulid();
-      tabs = [{ id: tabId, sessionId: sessionId ?? null, seq: 1, createdAt: now }];
+      tabs = [
+        {
+          id: tabId,
+          sessionId: sessionId ?? null,
+          seq: 1,
+          createdAt: now,
+          ...rest.model ? { model: rest.model } : {},
+          ...rest.modelEffort ? { modelEffort: rest.modelEffort } : {},
+          vendor: rest.vendor ?? DEFAULT_TASK_VENDOR
+        }
+      ];
       activeTabId = tabId;
     }
     const firstSession = tabs[0]?.sessionId ?? null;
@@ -4264,13 +6193,13 @@ class TaskIndexStore {
   }
   async _unlinkForTests() {
     try {
-      await unlink3(this.path);
+      await unlink4(this.path);
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
     }
     try {
-      await unlink3(this.tmpPath);
+      await unlink4(this.tmpPath);
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
@@ -4360,7 +6289,10 @@ function coerceTask(value) {
         sessionId: tt.sessionId ?? null,
         seq,
         createdAt: tt.createdAt,
-        ...typeof tt.title === "string" ? { title: tt.title } : {}
+        ...typeof tt.title === "string" ? { title: tt.title } : {},
+        ...typeof tt.model === "string" ? { model: tt.model } : {},
+        ...isModelEffortLevel(tt.modelEffort) ? { modelEffort: tt.modelEffort } : {},
+        ...isVendorId(tt.vendor) ? { vendor: tt.vendor } : {}
       };
       tabs.push(tab);
     }
@@ -4393,6 +6325,8 @@ function coerceTask(value) {
     kind: v.kind === "main" ? "main" : "task",
     permissionMode: isPermissionMode(v.permissionMode) ? v.permissionMode : undefined,
     model: typeof v.model === "string" ? v.model : undefined,
+    modelEffort: isModelEffortLevel(v.modelEffort) ? v.modelEffort : undefined,
+    vendor: resolveTaskVendor(v.vendor, typeof v.model === "string" ? v.model : undefined),
     createdAt: v.createdAt,
     updatedAt: v.updatedAt
   };
@@ -4400,20 +6334,36 @@ function coerceTask(value) {
 function isPermissionMode(v) {
   return v === "default" || v === "plan";
 }
+function isModelEffortLevel(v) {
+  return v === "none" || v === "minimal" || v === "low" || v === "medium" || v === "high" || v === "xhigh" || v === "max";
+}
+function isVendorId(v) {
+  return typeof v === "string" && v in ENGINE_REGISTRY;
+}
+function resolveTaskVendor(rawVendor, modelId) {
+  const stored = isVendorId(rawVendor) ? rawVendor : DEFAULT_TASK_VENDOR;
+  if (!modelId)
+    return stored;
+  const matched = Object.values(ENGINE_REGISTRY).some((caps) => caps?.models.some((m) => m.id === modelId));
+  if (!matched)
+    return stored;
+  return capabilitiesForModelId(modelId).vendorId;
+}
 function isTaskStatus(s) {
   return s === "backlog" || s === "in_progress" || s === "in_review" || s === "done" || s === "canceled" || s === "error";
 }
 var init_store = __esm(() => {
+  init_registry();
   init_ulid();
 });
 
 // src/orchestrator/worktree/git.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 function git2(args, opts) {
   if (!opts.cwd) {
     throw new Error("git(): cwd is required; refusing to inherit from process.cwd()");
   }
-  const proc = spawnSync4("git", [...args], {
+  const proc = spawnSync5("git", [...args], {
     cwd: opts.cwd,
     env: opts.env ? { ...process.env, ...opts.env } : process.env,
     encoding: "utf8",
@@ -4449,42 +6399,9 @@ var init_git = __esm(() => {
   };
 });
 
-// src/orchestrator/worktree/paths.ts
-import fs2 from "fs";
-import path5 from "path";
-function worktreeRootFor(repo) {
-  if (!path5.isAbsolute(repo)) {
-    throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
-  }
-  return path5.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
-}
-function worktreePathFor(repo, taskId) {
-  if (!taskId || /[/\\\0]/.test(taskId)) {
-    throw new Error(`worktreePathFor: invalid taskId: ${JSON.stringify(taskId)}`);
-  }
-  return path5.join(worktreeRootFor(repo), taskId);
-}
-function isKobeManagedPath(repo, candidate) {
-  if (!path5.isAbsolute(repo) || !path5.isAbsolute(candidate))
-    return false;
-  const root = canonicalize(worktreeRootFor(repo));
-  const target = canonicalize(candidate);
-  const rel = path5.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
-}
-function canonicalize(p) {
-  try {
-    return fs2.realpathSync(p);
-  } catch {
-    return path5.resolve(p);
-  }
-}
-var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
-var init_paths2 = () => {};
-
 // src/orchestrator/worktree/manager.ts
 import fs3 from "fs";
-import path6 from "path";
+import path8 from "path";
 
 class GitWorktreeManager {
   async create(repo, branch, worktreePath, baseRef) {
@@ -4502,7 +6419,7 @@ class GitWorktreeManager {
       }
       throw new Error(`create(): ${worktreePath} exists but is not a registered git worktree`);
     }
-    fs3.mkdirSync(path6.dirname(worktreePath), { recursive: true });
+    fs3.mkdirSync(path8.dirname(worktreePath), { recursive: true });
     const branchExists = this.branchExists(repo, branch);
     const args = branchExists ? ["worktree", "add", worktreePath, branch] : baseRef ? ["worktree", "add", "-b", branch, worktreePath, baseRef] : ["worktree", "add", "-b", branch, worktreePath];
     git2(args, { cwd: repo });
@@ -4516,7 +6433,7 @@ class GitWorktreeManager {
     return info;
   }
   async createForTask(args) {
-    const target = worktreePathFor(args.repo, args.taskId);
+    const target = worktreePathFor(args.repo, args.slug);
     return this.create(args.repo, args.branch, target, args.baseRef);
   }
   async remove(worktreePath, opts) {
@@ -4557,8 +6474,8 @@ class GitWorktreeManager {
       if (!entry.branch || entry.detached)
         continue;
       const canonEntry = canonicalize2(entry.path);
-      const rel = path6.relative(canonRoot, canonEntry);
-      const callerPath = path6.join(callerRoot, rel);
+      const rel = path8.relative(canonRoot, canonEntry);
+      const callerPath = path8.join(callerRoot, rel);
       const dirty = await this.isDirty(entry.path);
       infos.push({
         path: callerPath,
@@ -4619,9 +6536,9 @@ class GitWorktreeManager {
       const gitDir = out.stdout.trim();
       if (!gitDir)
         return null;
-      const absolute = path6.isAbsolute(gitDir) ? gitDir : path6.resolve(worktreePath, gitDir);
-      const base = path6.basename(absolute);
-      return base === ".git" ? path6.dirname(absolute) : absolute;
+      const absolute = path8.isAbsolute(gitDir) ? gitDir : path8.resolve(worktreePath, gitDir);
+      const base = path8.basename(absolute);
+      return base === ".git" ? path8.dirname(absolute) : absolute;
     } catch (err) {
       if (err instanceof GitCommandError)
         return null;
@@ -4661,7 +6578,7 @@ function parsePorcelain(out) {
   return records;
 }
 function requireAbsolute(name, value) {
-  if (!value || !path6.isAbsolute(value)) {
+  if (!value || !path8.isAbsolute(value)) {
     throw new Error(`${name} must be an absolute path, got: ${JSON.stringify(value)}`);
   }
 }
@@ -4669,7 +6586,7 @@ function canonicalize2(p) {
   try {
     return fs3.realpathSync(p);
   } catch {
-    return path6.resolve(p);
+    return path8.resolve(p);
   }
 }
 var init_manager = __esm(() => {
@@ -4680,22 +6597,26 @@ var init_manager = __esm(() => {
 // src/bin/kobed.ts
 init_daemon_process();
 init_client();
-import { unlink as unlink5 } from "fs/promises";
+import { unlink as unlink6 } from "fs/promises";
 
 // src/core/index.ts
 init_claude_code_local();
+init_codex_local();
 init_bridge();
 init_core();
 init_store();
 init_manager();
-import { homedir as homedir9 } from "os";
+import { homedir as homedir12 } from "os";
 async function createKobeCore(options = {}) {
-  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir9();
+  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir12();
   const store = new TaskIndexStore({ homeDir: homeDir2 });
   await store.load();
   const worktrees = new GitWorktreeManager;
-  const engine = options.engine ?? new ClaudeCodeLocal;
-  const orchestrator = new Orchestrator({ engine, store, worktrees });
+  const engines = options.engines ?? (options.engine ? { [options.engine.capabilities.vendorId]: options.engine } : {
+    claude: new ClaudeCodeLocal,
+    codex: new CodexLocal
+  });
+  const orchestrator = new Orchestrator({ engines, store, worktrees });
   const bridge = options.startMcpBridge === false ? null : await startBridge(orchestrator, { homeDir: homeDir2 });
   return {
     homeDir: homeDir2,
@@ -4716,16 +6637,16 @@ init_paths();
 // src/daemon/server.ts
 init_repos();
 init_paths();
-import { mkdir as mkdir5, readFile as readFile5, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, unlink as unlink5, writeFile as writeFile4 } from "fs/promises";
 import { createServer as createServer2 } from "net";
 import { dirname as dirname5 } from "path";
 
 // src/engine/claude-code-local/plan-usage.ts
 import { execFile } from "child_process";
-import { createHash } from "crypto";
-import { readFile as readFile4 } from "fs/promises";
-import { homedir as homedir10, userInfo } from "os";
-import { join as join7 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile5 } from "fs/promises";
+import { homedir as homedir13, userInfo } from "os";
+import { join as join8 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
@@ -4736,7 +6657,7 @@ function keychainServiceName() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
   if (!configDir)
     return `${KEYCHAIN_BASE}${KEYCHAIN_SUFFIX}`;
-  const hash = createHash("sha256").update(configDir).digest("hex").slice(0, 8);
+  const hash = createHash2("sha256").update(configDir).digest("hex").slice(0, 8);
   return `${KEYCHAIN_BASE}${KEYCHAIN_SUFFIX}-${hash}`;
 }
 function keychainAccount() {
@@ -4760,10 +6681,10 @@ async function readKeychainToken() {
   }
 }
 async function readPlainTextToken() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join7(homedir10(), ".claude");
-  const path7 = join7(configDir, ".credentials.json");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join8(homedir13(), ".claude");
+  const path9 = join8(configDir, ".credentials.json");
   try {
-    const raw = await readFile4(path7, "utf8");
+    const raw = await readFile5(path9, "utf8");
     return parseStoredOAuth(raw);
   } catch {
     return null;
@@ -4876,7 +6797,7 @@ function createPlanUsagePoller(options) {
 }
 // src/daemon/rc-bridge.ts
 init_binary();
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 var ENV_ID_RE = /Environment ID:\s*(env_[A-Za-z0-9]+)/;
 var DEEPLINK_RE = /https:\/\/claude\.ai\/code\?environment=([A-Za-z0-9_]+)/;
 var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]/g;
@@ -4884,7 +6805,7 @@ function createRcBridge(options = {}) {
   const stopGraceMs = options.stopGraceMs ?? 5000;
   const readyTimeoutMs = options.readyTimeoutMs ?? 30000;
   const binaryPathResolver = options.binaryPathResolver ?? findClaudeBinary;
-  const spawner = options.spawner ?? ((cmd, args, cwd) => spawn4(cmd, [...args], {
+  const spawner = options.spawner ?? ((cmd, args, cwd) => spawn5(cmd, [...args], {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env }
@@ -5058,7 +6979,7 @@ async function startDaemonServer(orch, options = {}) {
   let nextClientId = 1;
   await mkdir5(dirname5(socketPath), { recursive: true });
   await mkdir5(dirname5(pidPath), { recursive: true });
-  await unlink4(socketPath).catch(() => {});
+  await unlink5(socketPath).catch(() => {});
   const server = createServer2((socket) => {
     const client = {
       id: nextClientId++,
@@ -5103,8 +7024,8 @@ async function startDaemonServer(orch, options = {}) {
         client.socket.destroy();
       }
       await new Promise((resolve2) => server.close(() => resolve2()));
-      await unlink4(socketPath).catch(() => {});
-      await unlink4(pidPath).catch(() => {});
+      await unlink5(socketPath).catch(() => {});
+      await unlink5(pidPath).catch(() => {});
     }
   };
   planUsagePoller.start();
@@ -5218,7 +7139,11 @@ async function startDaemonServer(orch, options = {}) {
       }
       case "task.model": {
         const taskId = requireString2(payload, "taskId");
-        await orch.setModel(taskId, optionalString2(payload, "model"));
+        const modelEffort = optionalString2(payload, "modelEffort");
+        if (modelEffort !== undefined && modelEffort !== "none" && modelEffort !== "minimal" && modelEffort !== "low" && modelEffort !== "medium" && modelEffort !== "high" && modelEffort !== "xhigh" && modelEffort !== "max") {
+          throw new Error("modelEffort must be a supported effort level");
+        }
+        await orch.setModel(taskId, optionalString2(payload, "model"), optionalString2(payload, "tabId"), modelEffort);
         broadcastTaskUpdated(orch, clients, taskId);
         return {};
       }
@@ -5417,7 +7342,7 @@ async function startDaemonServer(orch, options = {}) {
 }
 async function readPidFile(pidPath) {
   try {
-    const raw = await readFile5(pidPath, "utf8");
+    const raw = await readFile6(pidPath, "utf8");
     const pid = Number(raw.trim());
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -5455,8 +7380,7 @@ async function readTaskHistory(orch, taskId, requestedSessionId, limit, before)
   const sessionId = requestedSessionId ?? task?.tabs.find((t) => t.id === task.activeTabId)?.sessionId ?? task?.sessionId;
   if (!sessionId)
     return { messages: [], nextBefore: null, hasMore: false };
-  const messages = await orch.readHistory(sessionId);
-  const usageMetrics = deriveSessionUsageMetrics(messages);
+  const { messages, usageMetrics } = await orch.readHistoryWithMetrics(sessionId);
   const beforeIdx = before ? messages.findIndex((m) => `${m.timestamp}:${m.sessionId}` === before) : -1;
   const end = beforeIdx >= 0 ? beforeIdx : messages.length;
   const start = Math.max(0, end - limit);
@@ -5602,7 +7526,7 @@ async function main() {
         await new Promise((resolve2) => setTimeout(resolve2, 100));
       } catch {}
     }
-    await unlink5(socketPath).catch(() => {});
+    await unlink6(socketPath).catch(() => {});
     const next = await connectOrStartDaemon();
     next.close();
     console.log(`kobed: restarted, listening on ${socketPath}`);