@sma1lboy/kobe 0.5.18 → 0.5.20

package/dist/bin/kobed.js

@@ -65,6 +65,9 @@ function fitSocketPath(naturalPath, homeDir, role, pidTag) {
   throw new Error(`kobe socket path exceeds ${SOCKET_PATH_SAFETY_LIMIT} bytes even after fallback: ${fallback}`);
 }
 function defaultDaemonSocketPath(homeDir) {
+  const override = process.env.KOBE_DAEMON_SOCKET_PATH;
+  if (override && override.length > 0)
+    return override;
   const explicit = homeDir ?? process.env.KOBE_HOME_DIR;
   if (explicit && explicit.length > 0) {
     return fitSocketPath(join(explicit, ".kobe", "daemon.sock"), explicit, "daemon");
@@ -77,6 +80,9 @@ function defaultDaemonSocketPath(homeDir) {
   return fitSocketPath(join(home, ".kobe", "daemon.sock"), home, "daemon");
 }
 function defaultDaemonPidPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
+  const override = process.env.KOBE_DAEMON_PID_PATH;
+  if (override && override.length > 0)
+    return override;
   return join(homeDir, ".kobe", "daemon.pid");
 }
 var SOCKET_PATH_SAFETY_LIMIT = 100;
@@ -180,7 +186,11 @@ class KobeDaemonClient {
     this.socket = null;
   }
   forceDisconnect() {
-    this.socket?.destroy();
+    const socket = this.socket;
+    if (!socket)
+      return;
+    this.socket = null;
+    socket.destroy();
   }
   on(name, handler) {
     let set = this.handlers.get(name);
@@ -241,7 +251,7 @@ class KobeDaemonClient {
     });
   }
   onSocketClose(which) {
-    if (this.socket !== which && this.socket !== null)
+    if (this.socket !== which)
       return;
     this.socket = null;
     for (const pending of this.pending.values())
@@ -300,6 +310,8 @@ var init_client = () => {};
 // src/client/daemon-process.ts
 import { spawn } from "child_process";
 import { existsSync } from "fs";
+import { unlink } from "fs/promises";
+import { homedir as homedir2 } from "os";
 import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
 async function ensureDaemonReachable() {
@@ -332,6 +344,53 @@ async function connectOrStartDaemon() {
   await client.connect();
   return client;
 }
+async function connectOrStartOwnedDaemon() {
+  const homeDir = process.env.KOBE_HOME_DIR ?? homedir2();
+  const socketPath = fitSocketPath(join2(homeDir, ".kobe", `daemon-${process.pid}.sock`), homeDir, "daemon", process.pid);
+  const pidPath = join2(homeDir, ".kobe", `daemon-${process.pid}.pid`);
+  await ensureOwnedDaemonReachable(socketPath, pidPath);
+  const client = new KobeDaemonClient(socketPath);
+  await client.connect();
+  return {
+    client,
+    socketPath,
+    pidPath,
+    stop: async () => {
+      try {
+        await client.request("daemon.stop");
+      } catch {} finally {
+        client.close();
+      }
+    }
+  };
+}
+async function ensureOwnedDaemonReachable(socketPath, pidPath) {
+  await unlink(socketPath).catch(() => {});
+  const { entry, runWithBun } = resolveKobedEntry();
+  const env = {
+    ...process.env,
+    KOBE_DAEMON_SOCKET_PATH: socketPath,
+    KOBE_DAEMON_PID_PATH: pidPath
+  };
+  const child = runWithBun ? spawn(process.execPath, [entry, "start"], {
+    detached: true,
+    stdio: "ignore",
+    env
+  }) : spawn(entry, ["start"], {
+    detached: true,
+    stdio: "ignore",
+    env
+  });
+  child.unref();
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (await testCanConnect(socketPath)) {
+      return;
+    }
+    await new Promise((resolveTimer) => setTimeout(resolveTimer, 100));
+  }
+  throw new Error(`kobe: owned daemon did not start at ${socketPath}`);
+}
 async function testCanConnect(socketPath) {
   const probe = new KobeDaemonClient(socketPath);
   try {
@@ -370,6 +429,8 @@ var init_daemon_process = __esm(() => {
 
 // src/session/usage-metrics.ts
 function totalContextTokens(u) {
+  if (typeof u.context_tokens === "number" && Number.isFinite(u.context_tokens))
+    return Math.max(0, u.context_tokens);
   return u.input_tokens + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
 }
 function parseTimestampMs(value) {
@@ -451,7 +512,7 @@ function withTotalSpeedForTurn(usage, startedAtIso, endedAtIso) {
 // src/engine/claude-code-local/binary.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync2, statSync } from "fs";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import path from "path";
 async function findClaudeBinary(deps = defaultDeps) {
   const checked = [];
@@ -524,7 +585,7 @@ var init_binary = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir2();
+      return homedir3();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -614,7 +675,7 @@ var init_models = __esm(() => {
 
 // src/engine/claude-code-local/settings.ts
 import { readFileSync } from "fs";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import { join as join3 } from "path";
 function readClaudeSettings() {
   if (cached !== undefined)
@@ -643,7 +704,7 @@ function resolveClaudeDefaultModelId() {
 }
 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");
+  SETTINGS_PATH = join3(homedir4(), ".claude", "settings.json");
 });
 
 // src/engine/claude-code-local/capabilities.ts
@@ -719,8 +780,8 @@ function normalizeClaudeContent(content) {
 
 // src/engine/claude-code-local/history.ts
 import { randomUUID } from "crypto";
-import { appendFile, mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
-import { homedir as homedir4 } from "os";
+import { appendFile, mkdir, readFile, readdir, unlink as unlink2, writeFile } from "fs/promises";
+import { homedir as homedir5 } from "os";
 import path2 from "path";
 function encodeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
@@ -746,7 +807,7 @@ async function deleteHistory(sessionId, deps = defaultDeps2) {
   for (const dir of projectDirs) {
     const candidate = path2.join(root, dir, `${sessionId}.jsonl`);
     try {
-      await unlink(candidate);
+      await unlink2(candidate);
     } catch (err) {
       if (err.code === "ENOENT")
         continue;
@@ -890,7 +951,7 @@ var defaultDeps2;
 var init_history = __esm(() => {
   defaultDeps2 = {
     projectsDir() {
-      return path2.join(homedir4(), ".claude", "projects");
+      return path2.join(homedir5(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -979,7 +1040,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 homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import path3 from "path";
 async function listSessionsForCwd(cwd, deps = defaultDeps3) {
   const projectDir = path3.join(deps.projectsDir(), encodeCwd(cwd));
@@ -1047,7 +1108,7 @@ var init_sessions = __esm(() => {
   init_history();
   defaultDeps3 = {
     projectsDir() {
-      return path3.join(homedir5(), ".claude", "projects");
+      return path3.join(homedir6(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -1450,10 +1511,363 @@ var init_claude_code_local = __esm(() => {
   init_spawn();
 });
 
+// src/env.ts
+import { homedir as homedir7 } from "os";
+import { join as join4 } from "path";
+function isDev() {
+  return process.env.KOBE_DEV === "1";
+}
+function homeDir() {
+  return process.env.KOBE_HOME_DIR ?? homedir7();
+}
+function kobeStateDir() {
+  return join4(homeDir(), ".kobe");
+}
+function kvStatePath() {
+  return join4(homeDir(), ".config", "kobe", "state.json");
+}
+var init_env = () => {};
+
+// src/engine/codex-local/app-server.ts
+import { spawn as spawn3 } from "child_process";
+import { readFileSync as readFileSync2 } from "fs";
+function resolveCodexBackend(env = process.env, readPreference = readCodexBackendPreference) {
+  if (env.KOBE_CODEX_BACKEND === "exec")
+    return "exec";
+  if (env.KOBE_CODEX_BACKEND === "app-server" || env.KOBE_CODEX_APP_SERVER === "1")
+    return "app-server";
+  return readPreference() ?? "app-server";
+}
+function readCodexBackendPreference() {
+  try {
+    const parsed = JSON.parse(readFileSync2(kvStatePath(), "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return;
+    const raw = parsed[CODEX_BACKEND_KV_KEY];
+    if (raw === "exec" || raw === "app-server")
+      return raw;
+  } catch {}
+  return;
+}
+function spawnCodexAppServerTurn(opts) {
+  const args = buildAppServerArgs(opts);
+  const proc = spawn3(opts.binaryPath, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  const rpc = new AppServerRpc(proc, opts);
+  rpc.run();
+  return {
+    proc,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    args,
+    ready: rpc.ready,
+    closed: rpc.closed
+  };
+}
+function buildAppServerArgs(opts) {
+  const mode = permissionPayloads(opts.permissionMode);
+  return ["app-server", "-c", `approval_policy="${mode.approvalPolicy}"`, "-c", `sandbox_mode="${mode.threadSandbox}"`];
+}
+function codexAppServerUsageToSnapshot(params) {
+  const root = asObject(params);
+  const tokenUsage = asObject(root?.tokenUsage ?? root?.token_usage);
+  const last = asObject(tokenUsage?.last);
+  if (!last)
+    return null;
+  const totalTokens = numberOr(last.totalTokens ?? last.total_tokens, 0);
+  const inputTokens = numberOr(last.inputTokens ?? last.input_tokens, 0);
+  const cachedInputTokens = numberOr(last.cachedInputTokens ?? last.cached_input_tokens, 0);
+  const outputTokens = numberOr(last.outputTokens ?? last.output_tokens, 0);
+  const contextWindow = numberOr(tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window, 0);
+  if (totalTokens <= 0 && inputTokens <= 0 && outputTokens <= 0 && cachedInputTokens <= 0)
+    return null;
+  return {
+    type: "usage",
+    input_tokens: Math.max(0, inputTokens - cachedInputTokens),
+    output_tokens: outputTokens,
+    ...cachedInputTokens > 0 ? { cache_read_input_tokens: cachedInputTokens } : {},
+    ...totalTokens > 0 ? { context_tokens: totalTokens } : {},
+    ...contextWindow > 0 ? { context_window_tokens: contextWindow } : {}
+  };
+}
+function codexAppServerItemNotificationToEvents(method, params) {
+  if (method !== "item/started" && method !== "item/completed")
+    return [];
+  const p = asObject(params);
+  const item = asObject(p?.item);
+  const itemType = typeof item?.type === "string" ? item.type : "tool";
+  if (isNonToolTranscriptItem(itemType))
+    return [];
+  const payload = stripItemHousekeeping(item ?? {});
+  if (method === "item/started")
+    return [{ type: "tool.start", name: itemType, input: payload }];
+  return [{ type: "tool.result", name: itemType, output: payload }];
+}
+
+class AppServerRpc {
+  proc;
+  opts;
+  pending = new Map;
+  readBuffer = "";
+  nextId = 1;
+  readyResolve = () => {};
+  readyReject = () => {};
+  ready = new Promise((resolve2, reject) => {
+    this.readyResolve = resolve2;
+    this.readyReject = reject;
+  });
+  closed;
+  constructor(proc, opts) {
+    this.proc = proc;
+    this.opts = opts;
+    this.closed = new Promise((resolve2) => {
+      proc.once("exit", (code, signal) => resolve2({ code, signal }));
+    });
+    proc.stdout.setEncoding("utf8");
+    proc.stdout.on("data", (chunk) => this.onStdout(chunk));
+    proc.stdout.on("error", () => {});
+    proc.stderr.on("error", () => {});
+    proc.once("error", (err) => {
+      this.readyReject(err);
+      this.rejectAll(err);
+    });
+  }
+  async run() {
+    try {
+      await this.call("initialize", {
+        clientInfo: {
+          name: "kobe",
+          title: "kobe",
+          version: "0.0.0"
+        },
+        capabilities: { experimentalApi: true }
+      });
+      this.notify("initialized", undefined);
+      const sessionId = this.opts.resumeSessionId ? await this.resumeThread(this.opts.resumeSessionId) : await this.startThread();
+      this.opts.onSessionId(sessionId);
+      this.readyResolve(sessionId);
+      await this.startTurn(sessionId);
+    } catch (err) {
+      this.readyReject(err);
+      this.opts.onEvent({ type: "error", message: `codex app-server failure: ${stringifyErr2(err)}` });
+      this.close();
+    }
+  }
+  async startThread() {
+    const mode = permissionPayloads(this.opts.permissionMode);
+    const result = asObject(await this.call("thread/start", {
+      cwd: this.opts.cwd,
+      model: this.opts.model ?? null,
+      approvalPolicy: mode.approvalPolicy,
+      sandbox: mode.threadSandbox,
+      ephemeral: false
+    }));
+    const thread = asObject(result?.thread);
+    const id = typeof thread?.id === "string" ? thread.id : undefined;
+    if (!id)
+      throw new Error("thread/start did not return a thread id");
+    return id;
+  }
+  async resumeThread(sessionId) {
+    const mode = permissionPayloads(this.opts.permissionMode);
+    const result = asObject(await this.call("thread/resume", {
+      threadId: sessionId,
+      cwd: this.opts.cwd,
+      model: this.opts.model ?? null,
+      approvalPolicy: mode.approvalPolicy,
+      sandbox: mode.threadSandbox
+    }));
+    const thread = asObject(result?.thread);
+    const id = typeof thread?.id === "string" ? thread.id : undefined;
+    if (!id)
+      throw new Error("thread/resume did not return a thread id");
+    return id;
+  }
+  async startTurn(sessionId) {
+    const mode = permissionPayloads(this.opts.permissionMode);
+    await this.call("turn/start", {
+      threadId: sessionId,
+      input: [{ type: "text", text: this.opts.prompt, text_elements: [] }],
+      cwd: this.opts.cwd,
+      model: this.opts.model ?? null,
+      effort: this.opts.modelEffort ?? null,
+      approvalPolicy: mode.approvalPolicy,
+      sandboxPolicy: mode.turnSandboxPolicy
+    });
+  }
+  call(method, params) {
+    const id = this.nextId++;
+    this.send({ jsonrpc: "2.0", id, method, params });
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+    });
+  }
+  notify(method, params) {
+    this.send(params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params });
+  }
+  send(payload) {
+    this.proc.stdin.write(`${JSON.stringify(payload)}
+`);
+  }
+  onStdout(chunk) {
+    this.readBuffer += chunk;
+    let lineEnd = this.readBuffer.indexOf(`
+`);
+    while (lineEnd !== -1) {
+      const line = this.readBuffer.slice(0, lineEnd).trim();
+      this.readBuffer = this.readBuffer.slice(lineEnd + 1);
+      if (line.length > 0)
+        this.handleLine(line);
+      lineEnd = this.readBuffer.indexOf(`
+`);
+    }
+  }
+  handleLine(line) {
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const record = asObject(msg);
+    if (!record)
+      return;
+    const id = typeof record.id === "number" ? record.id : undefined;
+    const method = typeof record.method === "string" ? record.method : undefined;
+    if (id !== undefined && this.pending.has(id)) {
+      const pending = this.pending.get(id);
+      this.pending.delete(id);
+      if (!pending)
+        return;
+      const error = asObject(record.error);
+      if (error)
+        pending.reject(new Error(typeof error.message === "string" ? error.message : "app-server request failed"));
+      else
+        pending.resolve(record.result);
+      return;
+    }
+    if (id !== undefined && method) {
+      this.rejectServerRequest(id, method);
+      return;
+    }
+    if (!method)
+      return;
+    this.handleNotification(method, record.params);
+  }
+  handleNotification(method, params) {
+    if (method === "thread/tokenUsage/updated") {
+      const usage = codexAppServerUsageToSnapshot(params);
+      if (usage)
+        this.opts.onEvent(usage);
+      return;
+    }
+    if (method === "item/agentMessage/delta") {
+      const p = asObject(params);
+      const text = typeof p?.delta === "string" ? p.delta : typeof p?.text === "string" ? p.text : "";
+      if (text)
+        this.opts.onEvent({ type: "assistant.delta", text });
+      return;
+    }
+    if (method === "item/started" || method === "item/completed") {
+      for (const event of codexAppServerItemNotificationToEvents(method, params))
+        this.opts.onEvent(event);
+      return;
+    }
+    if (method === "turn/completed") {
+      const p = asObject(params);
+      const turn = asObject(p?.turn);
+      const error = turn?.error;
+      if (error) {
+        this.opts.onEvent({ type: "error", message: stringifyErr2(error) });
+      } else {
+        this.opts.onEvent({ type: "done" });
+      }
+      this.close();
+      return;
+    }
+    if (method === "error") {
+      const p = asObject(params);
+      const message = typeof p?.message === "string" ? p.message : "codex app-server emitted an error";
+      this.opts.onEvent({ type: "error", message });
+      this.close();
+    }
+  }
+  rejectServerRequest(id, method) {
+    this.send({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32000,
+        message: `kobe app-server backend does not handle server request ${method}`
+      }
+    });
+  }
+  close() {
+    try {
+      this.proc.stdin.end();
+    } catch {}
+    setTimeout(() => {
+      if (!this.proc.killed) {
+        try {
+          this.proc.kill("SIGTERM");
+        } catch {}
+      }
+    }, 50).unref();
+  }
+  rejectAll(err) {
+    for (const pending of this.pending.values())
+      pending.reject(err);
+    this.pending.clear();
+  }
+}
+function permissionPayloads(mode) {
+  if (mode === "plan") {
+    return {
+      approvalPolicy: "never",
+      threadSandbox: "read-only",
+      turnSandboxPolicy: { type: "readOnly", networkAccess: true }
+    };
+  }
+  return {
+    approvalPolicy: "never",
+    threadSandbox: "danger-full-access",
+    turnSandboxPolicy: { type: "dangerFullAccess" }
+  };
+}
+function asObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+}
+function numberOr(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function stripItemHousekeeping(item) {
+  const { id: _id, type: _type, ...rest } = item;
+  return rest;
+}
+function isNonToolTranscriptItem(itemType) {
+  return itemType === "agentMessage" || itemType === "agent_message" || itemType === "userMessage" || itemType === "user_message";
+}
+function stringifyErr2(err) {
+  if (err instanceof Error)
+    return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+var CODEX_BACKEND_KV_KEY = "codex.backend";
+var init_app_server = __esm(() => {
+  init_env();
+});
+
 // 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 { homedir as homedir8 } from "os";
 import path4 from "path";
 async function findCodexBinary(deps = defaultDeps4) {
   const checked = [];
@@ -1510,7 +1924,7 @@ var init_binary2 = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir6();
+      return homedir8();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -1540,9 +1954,9 @@ var init_binary2 = __esm(() => {
 
 // src/engine/codex-local/models.ts
 function codexContextWindowFor(_modelId) {
-  return DEFAULT_CTX;
+  return 0;
 }
-var CODEX_GPT55_EFFORT_LEVELS, CODEX_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini", DEFAULT_CTX = 400000;
+var CODEX_GPT55_EFFORT_LEVELS, CODEX_MODELS, CODEX_FALLBACK_DEFAULT_MODEL_ID = "gpt-5.4-mini";
 var init_models2 = __esm(() => {
   CODEX_GPT55_EFFORT_LEVELS = [
     "none",
@@ -1567,12 +1981,12 @@ var init_models2 = __esm(() => {
 });
 
 // src/engine/codex-local/settings.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join5 } from "path";
 function readModelFromConfig() {
   try {
-    const raw = readFileSync2(CONFIG_PATH, "utf8");
+    const raw = readFileSync3(CONFIG_PATH, "utf8");
     let inTable = false;
     for (const line of raw.split(`
 `)) {
@@ -1600,7 +2014,7 @@ function resolveCodexDefaultModelId() {
 var CONFIG_PATH, cached2;
 var init_settings2 = __esm(() => {
   init_models2();
-  CONFIG_PATH = join4(homedir7(), ".codex", "config.toml");
+  CONFIG_PATH = join5(homedir9(), ".codex", "config.toml");
 });
 
 // src/engine/codex-local/capabilities.ts
@@ -1690,9 +2104,31 @@ function isInstructionsEnvelope(text) {
 }
 var init_synthetic = () => {};
 
+// src/engine/codex-local/usage.ts
+function codexUsageToSnapshot(usage, opts = {}) {
+  const totalInput = numberOr2(usage.input_tokens, 0);
+  const cachedInput = numberOr2(usage.cached_input_tokens, 0);
+  const output = numberOr2(usage.output_tokens, 0);
+  const nonCachedInput = Math.max(0, totalInput - cachedInput);
+  if (totalInput <= 0 && output <= 0 && cachedInput <= 0)
+    return;
+  return {
+    input_tokens: nonCachedInput,
+    output_tokens: output,
+    ...cachedInput > 0 ? { cache_read_input_tokens: cachedInput } : {},
+    ...validPositive(opts.contextWindowTokens) ? { context_window_tokens: opts.contextWindowTokens } : {}
+  };
+}
+function numberOr2(v, fallback) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function validPositive(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+
 // 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 { readFile as readFile3, readdir as readdir3, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir10 } from "os";
 import path5 from "path";
 async function listRolloutFiles(deps = defaultDeps5) {
   const root = deps.sessionsDir();
@@ -1742,7 +2178,7 @@ async function deleteHistory2(sessionId, deps = defaultDeps5) {
   if (!file)
     return;
   try {
-    await unlink2(file);
+    await unlink3(file);
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -1794,10 +2230,6 @@ function parseJsonl2(raw, sessionId) {
 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();
@@ -1812,15 +2244,8 @@ function deriveCodexUsageMetrics(raw) {
     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;
-      }
+    if (parsed.type === "response_item")
       continue;
-    }
     if (parsed.type !== "turn.completed")
       continue;
     const usage = isObject5(parsed.usage) ? parsed.usage : undefined;
@@ -1835,63 +2260,13 @@ function deriveCodexUsageMetrics(raw) {
     } 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 } : {}
-  };
+  return latestUsage;
 }
 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);
 }
@@ -1900,7 +2275,7 @@ var init_history2 = __esm(() => {
   init_synthetic();
   defaultDeps5 = {
     sessionsDir() {
-      return path5.join(homedir8(), ".codex", "sessions");
+      return path5.join(homedir10(), ".codex", "sessions");
     },
     async readdir(p) {
       try {
@@ -1915,6 +2290,52 @@ var init_history2 = __esm(() => {
   };
 });
 
+// src/engine/codex-local/openrouter.ts
+async function resolveOpenRouterContextWindow(modelId) {
+  const id = openRouterModelId(modelId);
+  if (!id)
+    return;
+  const models = await loadOpenRouterModels();
+  return models.get(id)?.contextLength;
+}
+function openRouterModelId(modelId) {
+  const id = modelId?.trim();
+  if (!id)
+    return null;
+  return id.includes("/") ? id : `openai/${id}`;
+}
+async function loadOpenRouterModels() {
+  cachePromise ??= fetchOpenRouterModels().catch(() => new Map);
+  return cachePromise;
+}
+async function fetchOpenRouterModels() {
+  const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS);
+  const res = await fetch(MODELS_URL, {
+    signal,
+    headers: { "user-agent": "kobe-codex-openrouter-context" }
+  });
+  if (!res.ok)
+    return new Map;
+  const body = await res.json();
+  if (!isObject6(body) || !Array.isArray(body.data))
+    return new Map;
+  const out = new Map;
+  for (const item of body.data) {
+    if (!isObject6(item))
+      continue;
+    const id = typeof item.id === "string" ? item.id : undefined;
+    const contextLength = typeof item.context_length === "number" ? item.context_length : undefined;
+    if (!id || !contextLength || !Number.isFinite(contextLength) || contextLength <= 0)
+      continue;
+    out.set(id, { id, contextLength });
+  }
+  return out;
+}
+function isObject6(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var MODELS_URL = "https://openrouter.ai/api/v1/models", FETCH_TIMEOUT_MS = 2500, cachePromise;
+
 // src/engine/codex-local/sessions.ts
 import { open, stat as stat2 } from "fs/promises";
 async function listSessionsForCwd2(cwd, deps) {
@@ -1958,7 +2379,7 @@ async function tryReadMeta(file) {
         return;
       if (parsed.type === "session_meta") {
         const payload = parsed.payload;
-        if (isObject6(payload)) {
+        if (isObject7(payload)) {
           if (typeof payload.id === "string")
             sessionId = payload.id;
           if (typeof payload.cwd === "string")
@@ -1966,7 +2387,7 @@ async function tryReadMeta(file) {
         }
         return;
       }
-      if (parsed.type === "response_item" && isObject6(parsed.payload)) {
+      if (parsed.type === "response_item" && isObject7(parsed.payload)) {
         const p = parsed.payload;
         if (p.type === "message") {
           messageCount++;
@@ -2012,12 +2433,12 @@ function safeParse(line) {
     return null;
   try {
     const v = JSON.parse(t);
-    return isObject6(v) ? v : null;
+    return isObject7(v) ? v : null;
   } catch {
     return null;
   }
 }
-function isObject6(v) {
+function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var PREVIEW_CHAR_CAP = 200;
@@ -2027,10 +2448,10 @@ var init_sessions2 = __esm(() => {
 });
 
 // src/engine/codex-local/spawn.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function spawnCodexProcess(opts) {
   const args = buildArgs2(opts);
-  const proc = spawn3(opts.binaryPath, args, {
+  const proc = spawn4(opts.binaryPath, args, {
     cwd: opts.cwd,
     env: { ...process.env, ...opts.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -2087,10 +2508,10 @@ async function* parseStreamJson2(lines, opts = {}) {
     try {
       msg = JSON.parse(line);
     } catch (err) {
-      yield { type: "error", message: `codex stream-json parse failed: ${stringifyErr2(err)}` };
+      yield { type: "error", message: `codex stream-json parse failed: ${stringifyErr3(err)}` };
       continue;
     }
-    if (!isObject7(msg))
+    if (!isObject8(msg))
       continue;
     const type = typeof msg.type === "string" ? msg.type : undefined;
     if (!type)
@@ -2106,7 +2527,7 @@ async function* parseStreamJson2(lines, opts = {}) {
     if (type === "turn.started")
       continue;
     if (type === "item.started" || type === "item.completed") {
-      const item = isObject7(msg.item) ? msg.item : undefined;
+      const item = isObject8(msg.item) ? msg.item : undefined;
       if (!item)
         continue;
       const itemId = typeof item.id === "string" ? item.id : undefined;
@@ -2140,17 +2561,12 @@ async function* parseStreamJson2(lines, opts = {}) {
       continue;
     }
     if (type === "turn.completed") {
-      const usage = isObject7(msg.usage) ? msg.usage : undefined;
+      const usage = isObject8(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 } : {}
-        };
+        const contextWindowTokens = await opts.contextWindowTokens?.();
+        const snapshot = codexUsageToSnapshot(usage, { contextWindowTokens });
+        if (snapshot)
+          yield { type: "usage", ...snapshot };
       }
       yield { type: "done" };
       return;
@@ -2179,26 +2595,23 @@ async function* readLines2(stream) {
   if (buf.length > 0)
     yield buf;
 }
-function isObject7(v) {
+function isObject8(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 payload = isObject8(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) {
+function stringifyErr3(err) {
   if (err instanceof Error)
     return err.message;
   try {
@@ -2207,6 +2620,7 @@ function stringifyErr2(err) {
     return String(err);
   }
 }
+var init_stream = () => {};
 
 // src/engine/codex-local/index.ts
 class CodexLocal {
@@ -2216,9 +2630,11 @@ class CodexLocal {
   running = new Map;
   binaryPathResolver;
   stopGraceMs;
+  backend;
   constructor(opts = {}) {
     this.binaryPathResolver = opts.binaryPathResolver ?? findCodexBinary;
     this.stopGraceMs = opts.stopGraceMs ?? 5000;
+    this.backend = opts.backend ?? resolveCodexBackend();
   }
   async spawn(cwd, prompt, opts) {
     return this.start({ cwd, prompt, opts });
@@ -2273,7 +2689,100 @@ class CodexLocal {
     }
   }
   async start(args) {
+    if (this.backend === "app-server")
+      return this.startAppServer(args);
+    return this.startExec(args);
+  }
+  async startAppServer(args) {
+    const binaryPath = await this.binaryPathResolver();
+    const queue = [];
+    let session;
+    let bound = false;
+    let terminalSeen = false;
+    let stderrTail = "";
+    let resolveHandle = () => {};
+    let rejectHandle = () => {};
+    const handlePromise = new Promise((res, rej) => {
+      resolveHandle = res;
+      rejectHandle = rej;
+    });
+    const bind = (sessionId) => {
+      if (bound)
+        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 });
+    };
+    const emit = (ev) => {
+      if (ev.type === "done" || ev.type === "error")
+        terminalSeen = true;
+      queue.push(ev);
+      if (session) {
+        this.notify(session);
+        if (ev.type === "done" || ev.type === "error") {
+          this.registry.unregister(session.sessionId, spawned.proc);
+        }
+      }
+    };
+    const spawned = spawnCodexAppServerTurn({
+      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,
+      onSessionId: bind,
+      onEvent: emit
+    });
+    captureStderrTail(spawned.stderr, (chunk) => {
+      stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_CAP);
+    });
+    spawned.ready.catch((err) => {
+      if (!bound)
+        rejectHandle(err);
+    });
+    spawned.closed.then(({ code, signal }) => {
+      if (session) {
+        if (!terminalSeen && typeof code === "number" && code !== 0) {
+          queue.push({
+            type: "error",
+            message: formatExitMsg("codex app-server exited", code, 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(formatExitMsg("codex app-server exited before session id was captured", code, signal, stderrTail)));
+      }
+    });
+    return handlePromise;
+  }
+  async startExec(args) {
     const binaryPath = await this.binaryPathResolver();
+    const modelId = args.opts?.model ?? codexCapabilities.defaultModelId();
     const spawned = spawnCodexProcess({
       binaryPath,
       cwd: args.cwd,
@@ -2294,6 +2803,7 @@ class CodexLocal {
     let session;
     let bound = false;
     let stderrTail = "";
+    const contextWindowPromise = resolveOpenRouterContextWindow(modelId);
     const bind = (sessionId) => {
       if (bound) {
         if (session && session.sessionId !== sessionId) {
@@ -2357,15 +2867,15 @@ class CodexLocal {
     });
     (async () => {
       const events = parseStreamJson2(readLines2(spawned.stdout), {
-        onSessionId: (sid) => bind(sid)
+        onSessionId: (sid) => bind(sid),
+        contextWindowTokens: () => contextWindowPromise
       });
       try {
         for await (const ev of events) {
-          const enriched = enrichUsageEvent2(ev, session?.spawnedAtIso);
-          queue.push(enriched);
+          queue.push(ev);
           if (session)
             this.notify(session);
-          if ((enriched.type === "done" || enriched.type === "error") && session) {
+          if ((ev.type === "done" || ev.type === "error") && session) {
             this.registry.unregister(session.sessionId, spawned.proc);
           }
         }
@@ -2431,28 +2941,25 @@ function formatExitMsg(prefix, code, signal, stderrTail) {
     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_app_server();
   init_binary2();
   init_capabilities2();
   init_history2();
   init_sessions2();
   init_spawn2();
+  init_stream();
   STDERR_TAIL_CAP = 4 * 1024;
 });
 
 // src/orchestrator/bridge/server.ts
-import { mkdir as mkdir2, unlink as unlink3 } from "fs/promises";
+import { mkdir as mkdir2, unlink as unlink4 } 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 unlink3(socketPath).catch(() => {});
+  await unlink4(socketPath).catch(() => {});
   const conns = new Set;
   const server = createServer((conn) => {
     conns.add(conn);
@@ -2493,7 +3000,7 @@ async function startBridgeServer(orch, socketPath) {
         conn.destroy();
       conns.clear();
       await new Promise((resolve2) => server.close(() => resolve2()));
-      await unlink3(socketPath).catch(() => {});
+      await unlink4(socketPath).catch(() => {});
     }
   };
 }
@@ -2585,19 +3092,19 @@ __export(exports_bridge, {
   startBridge: () => startBridge,
   bridgeSocketPathForHome: () => bridgeSocketPathForHome
 });
-import { mkdir as mkdir3, writeFile as writeFile2 } from "fs/promises";
-import { homedir as homedir9 } from "os";
-import { join as join5 } from "path";
+import { mkdir as mkdir3, unlink as unlink5, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir11 } from "os";
+import { join as join6 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function bridgeSocketPathForHome(home, pid = process.pid) {
-  const runDir = join5(home, ".kobe", "run");
-  return fitSocketPath(join5(runDir, `bridge-${pid}.sock`), home, "bridge", pid);
+  const runDir = join6(home, ".kobe", "run");
+  return fitSocketPath(join6(runDir, `bridge-${pid}.sock`), home, "bridge", pid);
 }
 async function startBridge(orch, opts = {}) {
-  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir9();
-  const runDir = join5(home, ".kobe", "run");
+  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir11();
+  const runDir = join6(home, ".kobe", "run");
   const socketPath = bridgeSocketPathForHome(home);
-  const mcpConfigPath = join5(runDir, `mcp-${process.pid}.json`);
+  const mcpConfigPath = join6(runDir, `mcp-${process.pid}.json`);
   await mkdir3(runDir, { recursive: true });
   const server = await startBridgeServer(orch, socketPath);
   await mkdir3(runDir, { recursive: true });
@@ -2618,6 +3125,7 @@ async function startBridge(orch, opts = {}) {
     mcpConfigPath,
     async close() {
       await server.close();
+      await unlink5(mcpConfigPath).catch(() => {});
     }
   };
 }
@@ -3925,23 +4433,6 @@ var init_registry = __esm(() => {
   defaultIdentity = claudeIdentity;
 });
 
-// src/env.ts
-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 ?? homedir10();
-}
-function kobeStateDir() {
-  return join6(homeDir(), ".kobe");
-}
-function kvStatePath() {
-  return join6(homeDir(), ".config", "kobe", "state.json");
-}
-var init_env = () => {};
-
 // src/state/repos.ts
 var exports_repos = {};
 __export(exports_repos, {
@@ -3954,7 +4445,7 @@ __export(exports_repos, {
   addSavedRepo: () => addSavedRepo
 });
 import { spawnSync as spawnSync3 } from "child_process";
-import { mkdirSync, readFileSync as readFileSync3, realpathSync, renameSync, writeFileSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync4, realpathSync, renameSync, writeFileSync } from "fs";
 import { dirname as dirname3 } from "path";
 function resolveRepoRoot(absPath) {
   const r = spawnSync3("git", ["rev-parse", "--show-toplevel"], {
@@ -3991,7 +4482,7 @@ function statePath() {
 }
 function load() {
   try {
-    const text = readFileSync3(statePath(), "utf8");
+    const text = readFileSync4(statePath(), "utf8");
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -4138,7 +4629,7 @@ var init_ulid = __esm(() => {
 });
 
 // src/orchestrator/metadata-suggester.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 
 class MetadataSuggester {
   binaryPromise = null;
@@ -4167,7 +4658,7 @@ class MetadataSuggester {
     return new Promise((resolve2) => {
       let proc;
       try {
-        proc = spawn4(binary, ["-p", builder(trimmed)], {
+        proc = spawn5(binary, ["-p", builder(trimmed)], {
           stdio: ["ignore", "pipe", "ignore"],
           env: process.env
         });
@@ -6018,8 +6509,8 @@ var init_core = __esm(() => {
 });
 
 // src/orchestrator/index/store.ts
-import { mkdir as mkdir4, open as open2, readFile as readFile4, rename, unlink as unlink4 } from "fs/promises";
-import { homedir as homedir11 } from "os";
+import { mkdir as mkdir4, open as open2, readFile as readFile4, rename, unlink as unlink6 } from "fs/promises";
+import { homedir as homedir12 } from "os";
 import { dirname as dirname4, join as join7 } from "path";
 
 class TaskIndexStore {
@@ -6032,7 +6523,7 @@ class TaskIndexStore {
   listeners = new Set;
   saveChain = Promise.resolve();
   constructor(options = {}) {
-    this.homeDir = options.homeDir ?? homedir11();
+    this.homeDir = options.homeDir ?? homedir12();
     this.kobeDir = join7(this.homeDir, ".kobe");
     this.path = join7(this.kobeDir, "tasks.json");
     this.tmpPath = `${this.path}.tmp`;
@@ -6201,13 +6692,13 @@ class TaskIndexStore {
   }
   async _unlinkForTests() {
     try {
-      await unlink4(this.path);
+      await unlink6(this.path);
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
     }
     try {
-      await unlink4(this.tmpPath);
+      await unlink6(this.tmpPath);
     } catch (err) {
       if (err.code !== "ENOENT")
         throw err;
@@ -6605,7 +7096,7 @@ var init_manager = __esm(() => {
 // src/bin/kobed.ts
 init_daemon_process();
 init_client();
-import { unlink as unlink6 } from "fs/promises";
+import { unlink as unlink8 } from "fs/promises";
 
 // src/core/index.ts
 init_claude_code_local();
@@ -6614,9 +7105,9 @@ init_bridge();
 init_core();
 init_store();
 init_manager();
-import { homedir as homedir12 } from "os";
+import { homedir as homedir13 } from "os";
 async function createKobeCore(options = {}) {
-  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir12();
+  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir13();
   const store = new TaskIndexStore({ homeDir: homeDir2 });
   await store.load();
   const worktrees = new GitWorktreeManager;
@@ -6645,7 +7136,7 @@ init_paths();
 // src/daemon/server.ts
 init_repos();
 init_paths();
-import { mkdir as mkdir5, readFile as readFile6, unlink as unlink5, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, unlink as unlink7, writeFile as writeFile4 } from "fs/promises";
 import { createServer as createServer2 } from "net";
 import { dirname as dirname5 } from "path";
 
@@ -6653,12 +7144,12 @@ import { dirname as dirname5 } from "path";
 import { execFile } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { readFile as readFile5 } from "fs/promises";
-import { homedir as homedir13, userInfo } from "os";
+import { homedir as homedir14, 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";
-var FETCH_TIMEOUT_MS = 5000;
+var FETCH_TIMEOUT_MS2 = 5000;
 var KEYCHAIN_BASE = "Claude Code";
 var KEYCHAIN_SUFFIX = "-credentials";
 function keychainServiceName() {
@@ -6689,7 +7180,7 @@ async function readKeychainToken() {
   }
 }
 async function readPlainTextToken() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join8(homedir13(), ".claude");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join8(homedir14(), ".claude");
   const path9 = join8(configDir, ".credentials.json");
   try {
     const raw = await readFile5(path9, "utf8");
@@ -6730,7 +7221,7 @@ async function fetchPlanUsage(now = Date.now()) {
   if (typeof token.expiresAt === "number" && token.expiresAt > 0 && token.expiresAt < now)
     return null;
   const ctrl = new AbortController;
-  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+  const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS2);
   try {
     const res = await fetch(USAGE_URL, {
       signal: ctrl.signal,
@@ -6805,7 +7296,7 @@ function createPlanUsagePoller(options) {
 }
 // src/daemon/rc-bridge.ts
 init_binary();
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } 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;
@@ -6813,7 +7304,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) => spawn5(cmd, [...args], {
+  const spawner = options.spawner ?? ((cmd, args, cwd) => spawn6(cmd, [...args], {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
     env: { ...process.env }
@@ -6987,7 +7478,7 @@ async function startDaemonServer(orch, options = {}) {
   let nextClientId = 1;
   await mkdir5(dirname5(socketPath), { recursive: true });
   await mkdir5(dirname5(pidPath), { recursive: true });
-  await unlink5(socketPath).catch(() => {});
+  await unlink7(socketPath).catch(() => {});
   const server = createServer2((socket) => {
     const client = {
       id: nextClientId++,
@@ -7032,8 +7523,8 @@ async function startDaemonServer(orch, options = {}) {
         client.socket.destroy();
       }
       await new Promise((resolve2) => server.close(() => resolve2()));
-      await unlink5(socketPath).catch(() => {});
-      await unlink5(pidPath).catch(() => {});
+      await unlink7(socketPath).catch(() => {});
+      await unlink7(pidPath).catch(() => {});
     }
   };
   planUsagePoller.start();
@@ -7251,6 +7742,7 @@ async function startDaemonServer(orch, options = {}) {
         const tabId = optionalString2(payload, "tabId");
         const text = optionalString2(payload, "text");
         await orch.runTask(taskId, text, tabId);
+        broadcastTaskUpdated(orch, clients, taskId);
         const task = orch.getTask(taskId);
         if (task)
           broadcast(clients, {
@@ -7534,7 +8026,7 @@ async function main() {
         await new Promise((resolve2) => setTimeout(resolve2, 100));
       } catch {}
     }
-    await unlink6(socketPath).catch(() => {});
+    await unlink8(socketPath).catch(() => {});
     const next = await connectOrStartDaemon();
     next.close();
     console.log(`kobed: restarted, listening on ${socketPath}`);