@sma1lboy/kobe 0.5.13 → 0.5.16

package/dist/bin/kobed.js

@@ -1,6 +1,36 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -18,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
@@ -48,6 +99,7 @@ function serializeTask(task) {
     pinned: task.pinned ?? false,
     permissionMode: task.permissionMode,
     model: task.model,
+    vendor: task.vendor,
     createdAt: task.createdAt,
     updatedAt: task.updatedAt
   };
@@ -315,6 +367,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";
@@ -419,10 +551,152 @@ var init_binary = __esm(() => {
   };
 });
 
+// src/engine/claude-code-local/models.ts
+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_MODELS, LONG_CTX = 1e6, STD_CTX = 200000;
+var init_models = __esm(() => {
+  CLAUDE_MODELS = [
+    { vendor: "claude", id: "claude-opus-4-7[1m]", label: "Opus 4.7 1M", hint: "long context, default" },
+    { vendor: "claude", id: "claude-opus-4-7", label: "Opus 4.7", hint: "most capable, slowest" },
+    { 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,
+    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, "-");
@@ -493,11 +767,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))
@@ -592,7 +866,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 {
@@ -676,7 +950,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));
@@ -728,17 +1002,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();
 }
@@ -750,7 +1018,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 {
@@ -863,47 +1131,981 @@ async function* parseStreamJson(lines, opts = {}) {
       }
       continue;
     }
-    if (type === "user") {
-      const content = extractContentBlocks(msg);
-      for (const block of content) {
-        if (!isObject3(block))
+    if (type === "user") {
+      const content = extractContentBlocks(msg);
+      for (const block of content) {
+        if (!isObject3(block))
+          continue;
+        const blockType = typeof block.type === "string" ? block.type : undefined;
+        if (blockType === "tool_result") {
+          const id = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
+          const name = id && toolNameById.get(id) || "tool";
+          const output = "content" in block ? block.content : undefined;
+          yield { type: "tool.result", name, output };
+        }
+      }
+      continue;
+    }
+    if (type === "result") {
+      const usage = isObject3(msg.usage) ? msg.usage : undefined;
+      if (usage) {
+        const inTok = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
+        const outTok = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
+        const cacheRead = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : undefined;
+        const cacheCreate = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : undefined;
+        yield {
+          type: "usage",
+          input_tokens: inTok,
+          output_tokens: outTok,
+          ...cacheRead !== undefined ? { cache_read_input_tokens: cacheRead } : {},
+          ...cacheCreate !== undefined ? { cache_creation_input_tokens: cacheCreate } : {}
+        };
+      }
+      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 {
+        yield { type: "error", message: `claude session ended: ${subtype}` };
+      }
+      return;
+    }
+  }
+}
+async function* readLines(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 isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function extractContentBlocks(msg) {
+  if (Array.isArray(msg.content))
+    return msg.content;
+  const inner = msg.message;
+  if (isObject3(inner) && Array.isArray(inner.content))
+    return inner.content;
+  return [];
+}
+function stringifyErr(err) {
+  if (err instanceof Error)
+    return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// src/engine/claude-code-local/index.ts
+class ClaudeCodeLocal {
+  identity = claudeIdentity;
+  capabilities = claudeCapabilities;
+  registry = new SessionRegistry;
+  running = new Map;
+  binaryPathResolver;
+  stopGraceMs;
+  constructor(opts = {}) {
+    this.binaryPathResolver = opts.binaryPathResolver ?? findClaudeBinary;
+    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) {
+    const messages = await readHistory(sessionId);
+    const usageMetrics = deriveSessionUsageMetrics(messages);
+    return { messages, ...usageMetrics ? { usageMetrics } : {} };
+  }
+  async deleteHistory(sessionId) {
+    return deleteHistory(sessionId);
+  }
+  async listSessions(cwd) {
+    return listSessionsForCwd(cwd);
+  }
+  async stop(handle) {
+    const sid = handle.sessionId;
+    const session = this.running.get(sid);
+    const shouldRescue = !!session && !session.completedNaturally && session.prompt.trim().length > 0;
+    const rescuePrompt = session?.prompt ?? "";
+    const rescueCwd = session?.cwd ?? handle.cwd;
+    await this.registry.kill(sid, this.stopGraceMs);
+    if (session) {
+      session.closed = true;
+      this.notify(session);
+      this.running.delete(sid);
+    }
+    if (shouldRescue) {
+      try {
+        await appendInterruptedUserPrompt(sid, rescueCwd, rescuePrompt);
+      } catch {}
+    }
+  }
+  async start(args) {
+    const binaryPath = await this.binaryPathResolver();
+    const cliPermissionMode = args.opts?.permissionMode === "plan" ? "plan" : "bypassPermissions";
+    const spawned = spawnClaudeProcess({
+      binaryPath,
+      cwd: args.cwd,
+      prompt: args.prompt,
+      model: args.opts?.model,
+      permissionMode: cliPermissionMode,
+      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;
+    const bind = (sessionId) => {
+      if (bound)
+        return;
+      bound = true;
+      session = {
+        sessionId,
+        cwd: args.cwd,
+        spawned,
+        queue,
+        waiters: [],
+        closed: false,
+        completedNaturally: false,
+        prompt: args.prompt,
+        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;
+      }
+    }
+    (async () => {
+      const events = parseStreamJson(readLines(spawned.stdout), {
+        onSessionId: (sid) => bind(sid)
+      });
+      try {
+        for await (const ev of events) {
+          const enriched = enrichUsageEvent(ev, session?.spawnedAtIso);
+          queue.push(enriched);
+          if (ev.type === "done" && session) {
+            session.completedNaturally = true;
+          }
+          if (session)
+            this.notify(session);
+        }
+      } catch (err) {
+        const ev = {
+          type: "error",
+          message: `parser failure: ${err instanceof Error ? err.message : String(err)}`
+        };
+        queue.push(ev);
+        if (session)
+          this.notify(session);
+      } finally {
+        if (session) {
+          session.closed = true;
+          this.notify(session);
+          this.registry.unregister(session.sessionId);
+        }
+        if (!bound) {
+          rejectHandle(new Error("claude exited without emitting a session id"));
+        }
+      }
+    })();
+    drainStream(spawned.stderr);
+    spawned.proc.once("error", (err) => {
+      if (!bound)
+        rejectHandle(err);
+    });
+    spawned.proc.once("exit", () => {
+      if (!bound) {
+        rejectHandle(new Error("claude exited before session id was captured"));
+      }
+    });
+    return handlePromise;
+  }
+  notify(session) {
+    const waiters = session.waiters;
+    session.waiters = [];
+    for (const w of waiters)
+      w();
+  }
+}
+function drainStream(stream) {
+  const s = 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_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini", DEFAULT_CTX = 400000;
+var init_models2 = __esm(() => {
+  CODEX_MODELS = [
+    { vendor: "codex", id: "gpt-5.5", label: "GPT-5.5", hint: "latest, ChatGPT-account compatible" },
+    { 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,
+    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/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" && isEnvironmentContextEnvelope(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 (!isEnvironmentContextEnvelope(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 isEnvironmentContextEnvelope(blocks) {
+  if (blocks.length === 0)
+    return false;
+  for (const b of blocks) {
+    if (b.type !== "text")
+      return false;
+    const t = (b.text ?? "").trim();
+    if (!t.startsWith("<environment_context>") || !t.endsWith("</environment_context>"))
+      return false;
+  }
+  return true;
+}
+function isObject5(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var defaultDeps5;
+var init_history2 = __esm(() => {
+  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 = "";
+    let lineCount = 0;
+    const processLine = (line) => {
+      lineCount++;
+      const parsed = safeParse(line);
+      if (parsed) {
+        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;
+          }
+        } else if (parsed.type === "response_item" && isObject6(parsed.payload)) {
+          const p = parsed.payload;
+          if (p.type === "message") {
+            messageCount++;
+            if (!firstUser && p.role === "user") {
+              firstUser = extractText(p.content)?.slice(0, PREVIEW_CHAR_CAP) ?? null;
+            }
+          }
+        }
+      }
+      return lineCount >= PREVIEW_HEAD_LINES;
+    };
+    const reader = handle.createReadStream({ encoding: "utf8" });
+    outer:
+      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(`
+`);
+          if (processLine(line))
+            break outer;
+        }
+      }
+    if (lineCount < PREVIEW_HEAD_LINES && 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 extractText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return null;
+  for (const item of content) {
+    if (typeof item === "string" && item.length > 0)
+      return item;
+    if (isObject6(item)) {
+      const t = item.type;
+      if ((t === "input_text" || t === "output_text" || t === "text") && typeof item.text === "string") {
+        return item.text;
+      }
+    }
+  }
+  return null;
+}
+function isObject6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var PREVIEW_HEAD_LINES = 40, PREVIEW_CHAR_CAP = 200;
+var init_sessions2 = __esm(() => {
+  init_history2();
+});
+
+// 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 (!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 === "thread.started") {
+      const sid = typeof msg.thread_id === "string" ? msg.thread_id : undefined;
+      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 blockType = typeof block.type === "string" ? block.type : undefined;
-        if (blockType === "tool_result") {
-          const id = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
-          const name = id && toolNameById.get(id) || "tool";
-          const output = "content" in block ? block.content : undefined;
-          yield { type: "tool.result", name, output };
-        }
+        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 === "result") {
-      const usage = isObject3(msg.usage) ? msg.usage : undefined;
+    if (type === "turn.completed") {
+      const usage = isObject7(msg.usage) ? msg.usage : undefined;
       if (usage) {
-        const inTok = typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
-        const outTok = typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
-        const cacheRead = typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : undefined;
-        const cacheCreate = typeof usage.cache_creation_input_tokens === "number" ? usage.cache_creation_input_tokens : undefined;
+        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 } : {},
-          ...cacheCreate !== undefined ? { cache_creation_input_tokens: cacheCreate } : {}
+          ...cacheRead !== undefined ? { cache_read_input_tokens: cacheRead } : {}
         };
       }
-      const subtype = typeof msg.subtype === "string" ? msg.subtype : "success";
-      if (subtype === "success") {
-        yield { type: "done" };
-      } else {
-        yield { type: "error", message: `claude session ended: ${subtype}` };
-      }
+      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* readLines(stream) {
+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);
@@ -920,18 +2122,17 @@ async function* readLines(stream) {
   if (buf.length > 0)
     yield buf;
 }
-function isObject3(v) {
+function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function extractContentBlocks(msg) {
-  if (Array.isArray(msg.content))
-    return msg.content;
-  const inner = msg.message;
-  if (isObject3(inner) && Array.isArray(inner.content))
-    return inner.content;
-  return [];
+function numberOr2(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
 }
-function stringifyErr(err) {
+function stripIdAndType(item) {
+  const { id: _id, type: _type, ...rest } = item;
+  return rest;
+}
+function stringifyErr2(err) {
   if (err instanceof Error)
     return err.message;
   try {
@@ -941,14 +2142,16 @@ function stringifyErr(err) {
   }
 }
 
-// src/engine/claude-code-local/index.ts
-class ClaudeCodeLocal {
+// 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 ?? findClaudeBinary;
+    this.binaryPathResolver = opts.binaryPathResolver ?? findCodexBinary;
     this.stopGraceMs = opts.stopGraceMs ?? 5000;
   }
   async spawn(cwd, prompt, opts) {
@@ -985,41 +2188,32 @@ class ClaudeCodeLocal {
     };
   }
   async readHistory(sessionId) {
-    return readHistory(sessionId);
+    return readHistoryWithMetrics(sessionId);
   }
   async deleteHistory(sessionId) {
-    return deleteHistory(sessionId);
+    return deleteHistory2(sessionId);
   }
   async listSessions(cwd) {
-    return listSessionsForCwd(cwd);
+    return listSessionsForCwd2(cwd);
   }
   async stop(handle) {
     const sid = handle.sessionId;
-    const session = this.running.get(sid);
-    const shouldRescue = !!session && !session.completedNaturally && session.prompt.trim().length > 0;
-    const rescuePrompt = session?.prompt ?? "";
-    const rescueCwd = session?.cwd ?? handle.cwd;
     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);
     }
-    if (shouldRescue) {
-      try {
-        await appendInterruptedUserPrompt(sid, rescueCwd, rescuePrompt);
-      } catch {}
-    }
   }
   async start(args) {
     const binaryPath = await this.binaryPathResolver();
-    const cliPermissionMode = args.opts?.permissionMode === "plan" ? "plan" : "bypassPermissions";
-    const spawned = spawnClaudeProcess({
+    const spawned = spawnCodexProcess({
       binaryPath,
       cwd: args.cwd,
       prompt: args.prompt,
       model: args.opts?.model,
-      permissionMode: cliPermissionMode,
+      permissionMode: args.opts?.permissionMode,
       env: args.opts?.env,
       resumeSessionId: args.resumeSessionId
     });
@@ -1043,8 +2237,7 @@ class ClaudeCodeLocal {
         queue,
         waiters: [],
         closed: false,
-        completedNaturally: false,
-        prompt: args.prompt
+        spawnedAtIso: new Date().toISOString()
       };
       this.running.set(sessionId, session);
       this.registry.register({
@@ -1068,22 +2261,20 @@ class ClaudeCodeLocal {
       }
     }
     (async () => {
-      const events = parseStreamJson(readLines(spawned.stdout), {
+      const events = parseStreamJson2(readLines2(spawned.stdout), {
         onSessionId: (sid) => bind(sid)
       });
       try {
         for await (const ev of events) {
-          queue.push(ev);
-          if (ev.type === "done" && session) {
-            session.completedNaturally = true;
-          }
+          const enriched = enrichUsageEvent2(ev, session?.spawnedAtIso);
+          queue.push(enriched);
           if (session)
             this.notify(session);
         }
       } catch (err) {
         const ev = {
           type: "error",
-          message: `parser failure: ${err instanceof Error ? err.message : String(err)}`
+          message: `codex parser failure: ${err instanceof Error ? err.message : String(err)}`
         };
         queue.push(ev);
         if (session)
@@ -1093,20 +2284,21 @@ class ClaudeCodeLocal {
           session.closed = true;
           this.notify(session);
           this.registry.unregister(session.sessionId);
+          this.running.delete(session.sessionId);
         }
         if (!bound) {
-          rejectHandle(new Error("claude exited without emitting a session id"));
+          rejectHandle(new Error("codex exited without emitting a session id"));
         }
       }
     })();
-    drainStream(spawned.stderr);
+    drainStream2(spawned.stderr);
     spawned.proc.once("error", (err) => {
       if (!bound)
         rejectHandle(err);
     });
     spawned.proc.once("exit", () => {
       if (!bound) {
-        rejectHandle(new Error("claude exited before session id was captured"));
+        rejectHandle(new Error("codex exited before session id was captured"));
       }
     });
     return handlePromise;
@@ -1118,25 +2310,31 @@ class ClaudeCodeLocal {
       w();
   }
 }
-function drainStream(stream) {
+function drainStream2(stream) {
   const s = stream;
   s.on("data", () => {});
   s.on("error", () => {});
 }
-var init_claude_code_local = __esm(() => {
-  init_binary();
-  init_history();
-  init_sessions();
-  init_spawn();
+function enrichUsageEvent2(ev, startedAtIso) {
+  if (ev.type !== "usage")
+    return ev;
+  return { type: "usage", ...withTotalSpeedForTurn(ev, startedAtIso, new Date().toISOString()) };
+}
+var init_codex_local = __esm(() => {
+  init_binary2();
+  init_capabilities2();
+  init_history2();
+  init_sessions2();
+  init_spawn2();
 });
 
 // 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);
@@ -1177,7 +2375,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(() => {});
     }
   };
 }
@@ -1270,23 +2468,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";
@@ -1309,8 +2503,8 @@ async function startBridge(orch, opts = {}) {
     }
   };
 }
-var UNIX_SOCKET_PATH_LIMIT = 103;
 var init_bridge = __esm(() => {
+  init_paths();
   init_server();
 });
 
@@ -2542,137 +3736,81 @@ 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}`;
+      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) {
+  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);
+    if (match)
+      return match.label;
+  }
+  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");
-}
-function tmuxBin() {
-  return process.env.KOBE_TMUX_BIN ?? "tmux";
+  return join6(homeDir(), ".config", "kobe", "state.json");
 }
 var init_env = () => {};
 
@@ -2687,11 +3825,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
@@ -2725,7 +3863,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;
@@ -2734,11 +3872,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();
@@ -2802,7 +3940,7 @@ function nextChatTabSeq(tabs) {
       max = t.seq;
   return max + 1;
 }
-var toTaskId = (id) => id;
+var toTaskId = (id) => id, DEFAULT_TASK_VENDOR = "claude";
 
 // src/orchestrator/index/ulid.ts
 function encodeTime(now, len) {
@@ -2864,7 +4002,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;
@@ -2893,7 +4031,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
         });
@@ -3042,10 +4180,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
@@ -3095,7 +4233,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.";
@@ -3123,7 +4261,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)
@@ -3174,10 +4312,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);
@@ -3191,7 +4330,7 @@ class SessionPump {
           });
           killedForInput = true;
           try {
-            await this.env.engine.stop(handle);
+            await engine.stop(handle);
           } catch {}
           break;
         }
@@ -3204,7 +4343,7 @@ class SessionPump {
     } finally {
       if (!killedForInput) {
         try {
-          await this.env.engine.stop(handle);
+          await engine.stop(handle);
         } catch {}
       }
     }
@@ -3264,7 +4403,8 @@ function summarizeWorktreeError(raw, repo, baseRef) {
 }
 
 class Orchestrator {
-  engine;
+  engines;
+  fallbackEngine;
   store;
   worktrees;
   metadataSuggester;
@@ -3282,7 +4422,26 @@ class Orchestrator {
   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;
@@ -3296,13 +4455,86 @@ 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();
+  }
+  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()) {
@@ -3522,10 +4754,11 @@ 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);
     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,
@@ -3538,7 +4771,7 @@ 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
         });
@@ -3613,7 +4846,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();
@@ -3655,11 +4888,13 @@ class Orchestrator {
       return;
     await this.store.update(task.id, { permissionMode: mode });
   }
-  async setModel(id, model) {
+  async setModel(id, model, tabId) {
     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 && this.vendorForTab(task, tab) === vendor)
       return;
-    await this.store.update(task.id, { model });
+    await this.updateTab(task.id, tab.id, { model, vendor });
   }
   async setTitle(id, title) {
     const task = this.requireTask(id);
@@ -3723,7 +4958,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);
       }
@@ -3732,15 +4967,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 } : {}
@@ -3750,14 +4985,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);
@@ -3768,6 +5005,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 });
@@ -3795,11 +5034,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];
@@ -3879,7 +5121,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();
@@ -3888,12 +5130,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);
     }
@@ -4019,7 +5262,7 @@ 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();
@@ -4064,9 +5307,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;
@@ -4078,9 +5321,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) {
@@ -4105,7 +5348,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") {
@@ -4142,7 +5385,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();
@@ -4170,7 +5413,16 @@ 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 } : {},
+          vendor: rest.vendor ?? DEFAULT_TASK_VENDOR
+        }
+      ];
       activeTabId = tabId;
     }
     const firstSession = tabs[0]?.sessionId ?? null;
@@ -4237,13 +5489,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;
@@ -4333,7 +5585,9 @@ 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 } : {},
+        ...isVendorId(tt.vendor) ? { vendor: tt.vendor } : {}
       };
       tabs.push(tab);
     }
@@ -4366,6 +5620,7 @@ function coerceTask(value) {
     kind: v.kind === "main" ? "main" : "task",
     permissionMode: isPermissionMode(v.permissionMode) ? v.permissionMode : undefined,
     model: typeof v.model === "string" ? v.model : undefined,
+    vendor: resolveTaskVendor(v.vendor, typeof v.model === "string" ? v.model : undefined),
     createdAt: v.createdAt,
     updatedAt: v.updatedAt
   };
@@ -4373,20 +5628,33 @@ function coerceTask(value) {
 function isPermissionMode(v) {
   return v === "default" || v === "plan";
 }
+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",
@@ -4424,32 +5692,32 @@ var init_git = __esm(() => {
 
 // src/orchestrator/worktree/paths.ts
 import fs2 from "fs";
-import path5 from "path";
+import path7 from "path";
 function worktreeRootFor(repo) {
-  if (!path5.isAbsolute(repo)) {
+  if (!path7.isAbsolute(repo)) {
     throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
   }
-  return path5.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
+  return path7.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);
+  return path7.join(worktreeRootFor(repo), taskId);
 }
 function isKobeManagedPath(repo, candidate) {
-  if (!path5.isAbsolute(repo) || !path5.isAbsolute(candidate))
+  if (!path7.isAbsolute(repo) || !path7.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);
+  const rel = path7.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path7.isAbsolute(rel);
 }
 function canonicalize(p) {
   try {
     return fs2.realpathSync(p);
   } catch {
-    return path5.resolve(p);
+    return path7.resolve(p);
   }
 }
 var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
@@ -4457,7 +5725,7 @@ 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) {
@@ -4475,7 +5743,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 });
@@ -4530,8 +5798,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,
@@ -4592,9 +5860,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;
@@ -4634,7 +5902,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)}`);
   }
 }
@@ -4642,7 +5910,7 @@ function canonicalize2(p) {
   try {
     return fs3.realpathSync(p);
   } catch {
-    return path6.resolve(p);
+    return path8.resolve(p);
   }
 }
 var init_manager = __esm(() => {
@@ -4653,22 +5921,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,
@@ -4689,16 +5961,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";
@@ -4709,7 +5981,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() {
@@ -4733,10 +6005,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;
@@ -4849,7 +6121,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;
@@ -4857,7 +6129,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 }
@@ -5031,7 +6303,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++,
@@ -5076,8 +6348,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();
@@ -5191,7 +6463,7 @@ async function startDaemonServer(orch, options = {}) {
       }
       case "task.model": {
         const taskId = requireString2(payload, "taskId");
-        await orch.setModel(taskId, optionalString2(payload, "model"));
+        await orch.setModel(taskId, optionalString2(payload, "model"), optionalString2(payload, "tabId"));
         broadcastTaskUpdated(orch, clients, taskId);
         return {};
       }
@@ -5390,7 +6662,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 {
@@ -5428,8 +6700,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);
@@ -5575,7 +6846,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}`);