@sma1lboy/kobe 0.4.0 → 0.5.0

package/dist/bin/kobed.js

@@ -0,0 +1,4805 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/daemon/protocol.ts
+function serializeTask(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    repo: task.repo,
+    branch: task.branch,
+    worktreePath: task.worktreePath,
+    kind: task.kind ?? "task",
+    sessionId: task.sessionId,
+    tabs: task.tabs,
+    activeTabId: task.activeTabId,
+    status: task.status,
+    archived: task.archived,
+    pinned: task.pinned ?? false,
+    permissionMode: task.permissionMode,
+    model: task.model,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt
+  };
+}
+function serializeMessages(messages) {
+  return messages.map((m) => ({ ...m }));
+}
+function normalizeEventForWire(taskId, tabId, ev) {
+  if (ev.type === "assistant.delta") {
+    return {
+      type: "event",
+      name: "chat.delta",
+      payload: { taskId, tabId, delta: ev.text }
+    };
+  }
+  if (ev.type === "done") {
+    return {
+      type: "event",
+      name: "chat.complete",
+      payload: { taskId, tabId }
+    };
+  }
+  if (ev.type === "error") {
+    return {
+      type: "event",
+      name: "engine.status",
+      payload: { taskId, tabId, status: "error", message: ev.message }
+    };
+  }
+  return {
+    type: "event",
+    name: "chat.event",
+    payload: { taskId, tabId, event: ev }
+  };
+}
+function frameToLine(frame) {
+  return `${JSON.stringify(frame)}
+`;
+}
+var DAEMON_PROTOCOL_VERSION = 1;
+
+// src/client/index.ts
+import { connect } from "net";
+
+class KobeDaemonClient {
+  socketPath;
+  socket = null;
+  buffer = "";
+  nextId = 1;
+  pending = new Map;
+  handlers = new Map;
+  constructor(socketPath) {
+    this.socketPath = socketPath;
+  }
+  connect() {
+    if (this.socket)
+      return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const socket = connect(this.socketPath);
+      this.socket = socket;
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+      socket.on("data", (chunk) => this.onData(chunk.toString("utf8")));
+      socket.on("close", () => {
+        this.socket = null;
+        for (const pending of this.pending.values())
+          pending.reject(new Error("daemon connection closed"));
+        this.pending.clear();
+      });
+    });
+  }
+  close() {
+    this.socket?.end();
+    this.socket = null;
+  }
+  on(name, handler) {
+    let set = this.handlers.get(name);
+    if (!set) {
+      set = new Set;
+      this.handlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+      if (set?.size === 0)
+        this.handlers.delete(name);
+    };
+  }
+  async request(name, payload) {
+    await this.connect();
+    const socket = this.socket;
+    if (!socket)
+      throw new Error("daemon connection is not open");
+    const id = String(this.nextId++);
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve: (value) => resolve(value), reject });
+    });
+    socket.write(frameToLine({ type: "request", id, name, payload }));
+    return promise;
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl = this.buffer.indexOf(`
+`);
+    while (nl !== -1) {
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(nl + 1);
+      if (line.trim().length > 0)
+        this.onLine(line);
+      nl = this.buffer.indexOf(`
+`);
+    }
+  }
+  onLine(line) {
+    const frame = JSON.parse(line);
+    if (frame.type === "event") {
+      this.emit(frame);
+      return;
+    }
+    if (frame.type !== "response")
+      return;
+    const pending = this.pending.get(frame.id);
+    if (!pending)
+      return;
+    this.pending.delete(frame.id);
+    if (frame.error)
+      pending.reject(new Error(frame.error.message));
+    else
+      pending.resolve(frame.payload);
+  }
+  emit(frame) {
+    for (const handler of this.handlers.get(frame.name) ?? [])
+      handler(frame);
+    for (const handler of this.handlers.get("*") ?? [])
+      handler(frame);
+  }
+}
+var init_client = () => {};
+
+// src/engine/claude-code-local/binary.ts
+import { spawnSync } from "child_process";
+import { existsSync, statSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+async function findClaudeBinary(deps = defaultDeps) {
+  const checked = [];
+  const tryPath = (p) => {
+    if (!p)
+      return;
+    checked.push(p);
+    return deps.fileExists(p) ? p : undefined;
+  };
+  const whichResult = deps.which("claude");
+  if (whichResult) {
+    checked.push(`which:${whichResult}`);
+    if (deps.fileExists(whichResult))
+      return whichResult;
+  }
+  const home = deps.home();
+  const localInstall = tryPath(path.join(home, ".claude", "local", "claude"));
+  if (localInstall)
+    return localInstall;
+  const nvmBin = deps.env("NVM_BIN");
+  if (nvmBin) {
+    const candidate = tryPath(path.join(nvmBin, "claude"));
+    if (candidate)
+      return candidate;
+  }
+  const nvmRoot = path.join(home, ".nvm", "versions", "node");
+  const nvmVersions = deps.readdir(nvmRoot).sort().reverse();
+  for (const v of nvmVersions) {
+    const candidate = tryPath(path.join(nvmRoot, v, "bin", "claude"));
+    if (candidate)
+      return candidate;
+  }
+  for (const p of ["/opt/homebrew/bin/claude", "/usr/local/bin/claude", "/usr/bin/claude", "/bin/claude"]) {
+    const candidate = tryPath(p);
+    if (candidate)
+      return candidate;
+  }
+  for (const rel of [
+    ".local/bin/claude",
+    ".npm-global/bin/claude",
+    ".yarn/bin/claude",
+    ".bun/bin/claude",
+    "bin/claude"
+  ]) {
+    const candidate = tryPath(path.join(home, rel));
+    if (candidate)
+      return candidate;
+  }
+  throw new ClaudeBinaryNotFoundError(checked);
+}
+var ClaudeBinaryNotFoundError, defaultDeps;
+var init_binary = __esm(() => {
+  ClaudeBinaryNotFoundError = class ClaudeBinaryNotFoundError extends Error {
+    checkedPaths;
+    constructor(checkedPaths) {
+      super(`Claude Code binary not found. Checked: ${checkedPaths.join(", ")}. Ensure 'claude' is on PATH, or install at ~/.claude/local/claude.`);
+      this.name = "ClaudeBinaryNotFoundError";
+      this.checkedPaths = checkedPaths;
+    }
+  };
+  defaultDeps = {
+    fileExists(p) {
+      try {
+        return statSync(p).isFile();
+      } catch {
+        return false;
+      }
+    },
+    env(name) {
+      return process.env[name];
+    },
+    home() {
+      return homedir();
+    },
+    which(name) {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      const out = spawnSync(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("claude:") && first.includes("aliased to")) {
+        const aliasTarget = first.split("aliased to")[1]?.trim();
+        return aliasTarget && existsSync(aliasTarget) ? aliasTarget : undefined;
+      }
+      return first;
+    },
+    readdir(p) {
+      try {
+        const fs = __require("fs");
+        return fs.readdirSync(p);
+      } catch {
+        return [];
+      }
+    }
+  };
+});
+
+// src/engine/claude-code-local/history.ts
+import { readFile, readdir, unlink } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+function encodeCwd(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+async function readHistory(sessionId, deps = defaultDeps2) {
+  const root = deps.projectsDir();
+  const projectDirs = await deps.readdir(root);
+  for (const dir of projectDirs) {
+    const candidate = path2.join(root, dir, `${sessionId}.jsonl`);
+    let raw;
+    try {
+      raw = await deps.readFile(candidate);
+    } catch {
+      continue;
+    }
+    return sortByTimestamp(parseJsonl(raw, sessionId));
+  }
+  return [];
+}
+async function deleteHistory(sessionId, deps = defaultDeps2) {
+  const root = deps.projectsDir();
+  const projectDirs = await deps.readdir(root);
+  for (const dir of projectDirs) {
+    const candidate = path2.join(root, dir, `${sessionId}.jsonl`);
+    try {
+      await unlink(candidate);
+    } catch (err) {
+      if (err.code === "ENOENT")
+        continue;
+      throw err;
+    }
+  }
+}
+function sortByTimestamp(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 parseJsonl(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 (!isObject(parsed))
+      continue;
+    const msg = extractMessage(parsed, sessionId);
+    if (msg)
+      out.push(msg);
+  }
+  return out;
+}
+function extractMessage(record, fallbackSessionId) {
+  const inner = isObject(record.message) ? record.message : record;
+  const role = inner.role;
+  if (role !== "user" && role !== "assistant" && role !== "system")
+    return null;
+  if (!("content" in inner))
+    return null;
+  const content = inner.content;
+  const ts = typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString();
+  const sid = typeof record.sessionId === "string" ? record.sessionId : fallbackSessionId;
+  return { role, content, timestamp: ts, sessionId: sid };
+}
+function isObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var defaultDeps2;
+var init_history = __esm(() => {
+  defaultDeps2 = {
+    projectsDir() {
+      return path2.join(homedir2(), ".claude", "projects");
+    },
+    async readdir(p) {
+      try {
+        return await readdir(p);
+      } catch {
+        return [];
+      }
+    },
+    async readFile(p) {
+      return await readFile(p, "utf8");
+    },
+    async pathExists(p) {
+      try {
+        await readdir(p);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+});
+
+// src/engine/claude-code-local/registry.ts
+class SessionRegistry {
+  handles = new Map;
+  register(handle) {
+    const existing = this.handles.get(handle.sessionId);
+    if (existing) {
+      const stale = existing.proc.exitCode !== null || existing.proc.signalCode !== null;
+      if (!stale) {
+        throw new Error(`SessionRegistry: duplicate sessionId ${handle.sessionId}`);
+      }
+    }
+    this.handles.set(handle.sessionId, handle);
+  }
+  unregister(sessionId) {
+    this.handles.delete(sessionId);
+  }
+  get(sessionId) {
+    return this.handles.get(sessionId);
+  }
+  async kill(sessionId, graceMs = 5000) {
+    const handle = this.handles.get(sessionId);
+    if (!handle)
+      return;
+    const proc = handle.proc;
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      this.unregister(sessionId);
+      return;
+    }
+    const exited = waitForExit(proc);
+    try {
+      proc.kill("SIGTERM");
+    } catch {}
+    const winner = await Promise.race([
+      exited.then(() => "exit"),
+      delay(graceMs).then(() => "timeout")
+    ]);
+    if (winner === "timeout") {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      await Promise.race([exited, delay(1000)]);
+    }
+    this.unregister(sessionId);
+  }
+}
+function waitForExit(proc) {
+  return new Promise((resolve) => {
+    if (proc.exitCode !== null || proc.signalCode !== null) {
+      resolve();
+      return;
+    }
+    proc.once("close", () => resolve());
+    proc.once("exit", () => resolve());
+  });
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/engine/claude-code-local/sessions.ts
+import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import path3 from "path";
+async function listSessionsForCwd(cwd, deps = defaultDeps3) {
+  const projectDir = path3.join(deps.projectsDir(), encodeCwd(cwd));
+  const entries = await deps.readdir(projectDir);
+  const jsonlNames = entries.filter((n) => n.endsWith(".jsonl"));
+  const out = [];
+  for (const name of jsonlNames) {
+    const sessionId = name.slice(0, -".jsonl".length);
+    const filePath = path3.join(projectDir, name);
+    try {
+      const [meta, raw] = await Promise.all([deps.stat(filePath), deps.readFile(filePath)]);
+      const lines = raw.split(`
+`).filter((l) => l.trim().length > 0);
+      out.push({
+        sessionId,
+        mtimeMs: meta.mtimeMs,
+        firstUserMessage: extractFirstUserMessage(lines),
+        messageCount: lines.length
+      });
+    } catch {
+      out.push({ sessionId, mtimeMs: 0, firstUserMessage: null, messageCount: 0 });
+    }
+  }
+  out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return out;
+}
+function extractFirstUserMessage(lines) {
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isObject2(parsed))
+      continue;
+    const inner = isObject2(parsed.message) ? parsed.message : parsed;
+    if (inner.role !== "user")
+      continue;
+    const text = stringifyContent(inner.content);
+    if (!text)
+      continue;
+    if (text.startsWith("Caveat:"))
+      continue;
+    if (text.startsWith("<command-name>") || text.startsWith("<local-command-stdout>"))
+      continue;
+    return text.length > PREVIEW_MAX_CHARS ? `${text.slice(0, PREVIEW_MAX_CHARS - 1).trimEnd()}\u2026` : text;
+  }
+  return null;
+}
+function stringifyContent(content) {
+  if (typeof content === "string")
+    return content.trim();
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const block of content) {
+    if (!isObject2(block))
+      continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join(" ").trim();
+}
+function isObject2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+var defaultDeps3, PREVIEW_MAX_CHARS = 200;
+var init_sessions = __esm(() => {
+  init_history();
+  defaultDeps3 = {
+    projectsDir() {
+      return path3.join(homedir3(), ".claude", "projects");
+    },
+    async readdir(p) {
+      try {
+        return await readdir2(p);
+      } catch {
+        return [];
+      }
+    },
+    async readFile(p) {
+      return await readFile2(p, "utf8");
+    },
+    async stat(p) {
+      const s = await stat(p);
+      return { mtimeMs: s.mtimeMs };
+    }
+  };
+});
+
+// src/engine/claude-code-local/spawn.ts
+import { spawn } from "child_process";
+function spawnClaudeProcess(opts) {
+  const args = buildArgs(opts);
+  const proc = spawn(opts.binaryPath, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env ?? {} },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return {
+    proc,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    args
+  };
+}
+function buildArgs(opts) {
+  const args = [];
+  if (opts.resumeSessionId) {
+    args.push("--resume", opts.resumeSessionId);
+  }
+  args.push("-p", opts.prompt);
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+  if (opts.permissionMode) {
+    args.push("--permission-mode", opts.permissionMode);
+  }
+  args.push("--output-format", "stream-json", "--verbose");
+  const mcpConfig = process.env.KOBE_MCP_CONFIG;
+  if (mcpConfig && mcpConfig.length > 0) {
+    args.push("--mcp-config", mcpConfig);
+  }
+  if (opts.extraArgs && opts.extraArgs.length > 0) {
+    args.push(...opts.extraArgs);
+  }
+  return args;
+}
+var init_spawn = () => {};
+
+// src/engine/claude-code-local/stream.ts
+async function* parseStreamJson(lines, opts = {}) {
+  let sessionIdEmitted = false;
+  const toolNameById = new Map;
+  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: `stream-json parse failed: ${stringifyErr(err)}` };
+      continue;
+    }
+    if (!isObject3(msg))
+      continue;
+    const type = typeof msg.type === "string" ? msg.type : undefined;
+    if (!type)
+      continue;
+    if ("parent_tool_use_id" in msg && msg.parent_tool_use_id != null)
+      continue;
+    if (type === "system") {
+      const subtype = typeof msg.subtype === "string" ? msg.subtype : undefined;
+      if (subtype === "init" && !sessionIdEmitted) {
+        const sid = typeof msg.session_id === "string" ? msg.session_id : undefined;
+        if (sid) {
+          sessionIdEmitted = true;
+          opts.onSessionId?.(sid);
+        }
+      }
+      continue;
+    }
+    if (type === "assistant") {
+      const content = extractContentBlocks(msg);
+      for (const block of content) {
+        if (!isObject3(block))
+          continue;
+        const blockType = typeof block.type === "string" ? block.type : undefined;
+        if (blockType === "text") {
+          const text = typeof block.text === "string" ? block.text : "";
+          if (text)
+            yield { type: "assistant.delta", text };
+        } else if (blockType === "tool_use") {
+          const name = typeof block.name === "string" ? block.name : "tool";
+          const id = typeof block.id === "string" ? block.id : undefined;
+          if (id)
+            toolNameById.set(id, name);
+          const input = "input" in block ? block.input : undefined;
+          yield { type: "tool.start", name, input };
+        }
+      }
+      continue;
+    }
+    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";
+      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 {
+  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((resolve) => session.waiters.push(resolve));
+        }
+      }
+    };
+  }
+  async readHistory(sessionId) {
+    return readHistory(sessionId);
+  }
+  async deleteHistory(sessionId) {
+    return deleteHistory(sessionId);
+  }
+  async listSessions(cwd) {
+    return listSessionsForCwd(cwd);
+  }
+  async stop(handle) {
+    const sid = handle.sessionId;
+    await this.registry.kill(sid, this.stopGraceMs);
+    const session = this.running.get(sid);
+    if (session) {
+      session.closed = true;
+      this.notify(session);
+      this.running.delete(sid);
+    }
+  }
+  async start(args) {
+    const binaryPath = await this.binaryPathResolver();
+    const 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
+      };
+      this.running.set(sessionId, session);
+      this.registry.register({
+        sessionId,
+        cwd: args.cwd,
+        proc: spawned.proc,
+        startedAt: Date.now()
+      });
+      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) {
+          queue.push(ev);
+          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", () => {});
+}
+var init_claude_code_local = __esm(() => {
+  init_binary();
+  init_history();
+  init_sessions();
+  init_spawn();
+});
+
+// src/orchestrator/bridge/server.ts
+import { mkdir, unlink as unlink2 } from "fs/promises";
+import { createServer } from "net";
+import { dirname } from "path";
+async function startBridgeServer(orch, socketPath) {
+  await mkdir(dirname(socketPath), { recursive: true });
+  await unlink2(socketPath).catch(() => {});
+  const server = createServer((conn) => {
+    let buffer = "";
+    conn.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let nl = buffer.indexOf(`
+`);
+      while (nl !== -1) {
+        const line = buffer.slice(0, nl);
+        buffer = buffer.slice(nl + 1);
+        if (line.trim().length > 0) {
+          handleLine(orch, line).then((reply) => conn.write(`${reply}
+`)).catch((err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            conn.write(`${JSON.stringify({ error: { message: msg } })}
+`);
+          });
+        }
+        nl = buffer.indexOf(`
+`);
+      }
+    });
+    conn.on("error", () => {});
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  return {
+    socketPath,
+    async close() {
+      await new Promise((resolve) => server.close(() => resolve()));
+      await unlink2(socketPath).catch(() => {});
+    }
+  };
+}
+async function handleLine(orch, line) {
+  let req;
+  try {
+    req = JSON.parse(line);
+  } catch (err) {
+    return JSON.stringify({ error: { message: `bad json: ${err instanceof Error ? err.message : String(err)}` } });
+  }
+  const id = req.id ?? null;
+  try {
+    const result = await dispatch(orch, req.method, req.params ?? {});
+    return JSON.stringify({ id, result });
+  } catch (err) {
+    return JSON.stringify({
+      id,
+      error: { message: err instanceof Error ? err.message : String(err) }
+    });
+  }
+}
+async function dispatch(orch, method, params) {
+  switch (method) {
+    case "list_tasks": {
+      return orch.listTasks().map(serializeTask2);
+    }
+    case "get_task": {
+      const id = requireString(params, "task_id");
+      const task = orch.getTask(id);
+      if (!task)
+        throw new Error(`task not found: ${id}`);
+      return serializeTask2(task);
+    }
+    case "spawn_task": {
+      const repo = requireString(params, "repo");
+      const prompt = requireString(params, "prompt");
+      const title = optionalString(params, "title");
+      const baseRef = optionalString(params, "base_branch");
+      const task = await orch.createTask({
+        repo,
+        prompt,
+        ...title ? { title } : {},
+        ...baseRef ? { baseRef } : {}
+      });
+      orch.runTask(task.id, prompt).catch(() => {});
+      return serializeTask2(task);
+    }
+    case "send_message": {
+      const id = requireString(params, "task_id");
+      const prompt = requireString(params, "prompt");
+      await orch.runTask(id, prompt);
+      return { ok: true };
+    }
+    default:
+      throw new Error(`unknown method: ${method}`);
+  }
+}
+function requireString(params, key) {
+  const v = params[key];
+  if (typeof v !== "string" || v.length === 0) {
+    throw new Error(`param '${key}' is required and must be a non-empty string`);
+  }
+  return v;
+}
+function optionalString(params, key) {
+  const v = params[key];
+  if (v === undefined || v === null || v === "")
+    return;
+  if (typeof v !== "string")
+    throw new Error(`param '${key}' must be a string`);
+  return v;
+}
+function serializeTask2(task) {
+  return {
+    id: task.id,
+    title: task.title,
+    repo: task.repo,
+    branch: task.branch,
+    worktree_path: task.worktreePath,
+    status: task.status,
+    session_id: task.sessionId
+  };
+}
+var init_server = () => {};
+
+// src/orchestrator/bridge/index.ts
+var exports_bridge = {};
+__export(exports_bridge, {
+  startBridge: () => startBridge
+});
+import { writeFile } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { join } from "path";
+async function startBridge(orch, opts = {}) {
+  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir4();
+  const runDir = join(home, ".kobe", "run");
+  const socketPath = join(runDir, `bridge-${process.pid}.sock`);
+  const mcpConfigPath = join(runDir, `mcp-${process.pid}.json`);
+  const server = await startBridgeServer(orch, socketPath);
+  const entry = process.argv[1] ?? "";
+  const mcpConfig = {
+    mcpServers: {
+      kobe: {
+        command: process.execPath,
+        args: [entry, "mcp-bridge", `--socket=${socketPath}`]
+      }
+    }
+  };
+  await writeFile(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), "utf8");
+  process.env.KOBE_MCP_CONFIG = mcpConfigPath;
+  return {
+    socketPath,
+    mcpConfigPath,
+    async close() {
+      await server.close();
+    }
+  };
+}
+var init_bridge = __esm(() => {
+  init_server();
+});
+
+// ../../node_modules/.bun/solid-js@1.9.10/node_modules/solid-js/dist/dev.js
+function getContextId(count) {
+  const num = String(count), len = num.length - 1;
+  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+  sharedConfig.context = context;
+}
+function nextHydrateContext() {
+  return {
+    ...sharedConfig.context,
+    id: sharedConfig.getNextContextId(),
+    count: 0
+  };
+}
+function createRoot(fn, detachedOwner) {
+  const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === undefined ? owner : detachedOwner, root = unowned ? {
+    owned: null,
+    cleanups: null,
+    context: null,
+    owner: null
+  } : {
+    owned: null,
+    cleanups: null,
+    context: current ? current.context : null,
+    owner: current
+  }, updateFn = unowned ? () => fn(() => {
+    throw new Error("Dispose method must be an explicit argument to createRoot function");
+  }) : () => fn(() => untrack(() => cleanNode(root)));
+  DevHooks.afterCreateOwner && DevHooks.afterCreateOwner(root);
+  Owner = root;
+  Listener = null;
+  try {
+    return runUpdates(updateFn, true);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+}
+function createSignal(value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const s = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || undefined
+  };
+  {
+    if (options.name)
+      s.name = options.name;
+    if (options.internal) {
+      s.internal = true;
+    } else {
+      registerGraph(s);
+      if (DevHooks.afterCreateSignal)
+        DevHooks.afterCreateSignal(s);
+    }
+  }
+  const setter = (value2) => {
+    if (typeof value2 === "function") {
+      if (Transition && Transition.running && Transition.sources.has(s))
+        value2 = value2(s.tValue);
+      else
+        value2 = value2(s.value);
+    }
+    return writeSignal(s, value2);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createComputed(fn, value, options) {
+  const c = createComputation(fn, value, true, STALE, options);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
+}
+function createRenderEffect(fn, value, options) {
+  const c = createComputation(fn, value, false, STALE, options);
+  if (Scheduler && Transition && Transition.running)
+    Updates.push(c);
+  else
+    updateComputation(c);
+}
+function createEffect(fn, value, options) {
+  runEffects = runUserEffects;
+  const c = createComputation(fn, value, false, STALE, options), s = SuspenseContext && useContext(SuspenseContext);
+  if (s)
+    c.suspense = s;
+  if (!options || !options.render)
+    c.user = true;
+  Effects ? Effects.push(c) : updateComputation(c);
+}
+function createMemo(fn, value, options) {
+  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
+  const c = createComputation(fn, value, true, 0, options);
+  c.observers = null;
+  c.observerSlots = null;
+  c.comparator = options.equals || undefined;
+  if (Scheduler && Transition && Transition.running) {
+    c.tState = STALE;
+    Updates.push(c);
+  } else
+    updateComputation(c);
+  return readSignal.bind(c);
+}
+function isPromise(v) {
+  return v && typeof v === "object" && "then" in v;
+}
+function createResource(pSource, pFetcher, pOptions) {
+  let source;
+  let fetcher;
+  let options;
+  if (typeof pFetcher === "function") {
+    source = pSource;
+    fetcher = pFetcher;
+    options = pOptions || {};
+  } else {
+    source = true;
+    fetcher = pSource;
+    options = pFetcher || {};
+  }
+  let pr = null, initP = NO_INIT, id = null, loadedUnderTransition = false, scheduled = false, resolved = "initialValue" in options, dynamic = typeof source === "function" && createMemo(source);
+  const contexts = new Set, [value, setValue] = (options.storage || createSignal)(options.initialValue), [error, setError] = createSignal(undefined), [track, trigger] = createSignal(undefined, {
+    equals: false
+  }), [state, setState] = createSignal(resolved ? "ready" : "unresolved");
+  if (sharedConfig.context) {
+    id = sharedConfig.getNextContextId();
+    if (options.ssrLoadFrom === "initial")
+      initP = options.initialValue;
+    else if (sharedConfig.load && sharedConfig.has(id))
+      initP = sharedConfig.load(id);
+  }
+  function loadEnd(p, v, error2, key) {
+    if (pr === p) {
+      pr = null;
+      key !== undefined && (resolved = true);
+      if ((p === initP || v === initP) && options.onHydrated)
+        queueMicrotask(() => options.onHydrated(key, {
+          value: v
+        }));
+      initP = NO_INIT;
+      if (Transition && p && loadedUnderTransition) {
+        Transition.promises.delete(p);
+        loadedUnderTransition = false;
+        runUpdates(() => {
+          Transition.running = true;
+          completeLoad(v, error2);
+        }, false);
+      } else
+        completeLoad(v, error2);
+    }
+    return v;
+  }
+  function completeLoad(v, err) {
+    runUpdates(() => {
+      if (err === undefined)
+        setValue(() => v);
+      setState(err !== undefined ? "errored" : resolved ? "ready" : "unresolved");
+      setError(err);
+      for (const c of contexts.keys())
+        c.decrement();
+      contexts.clear();
+    }, false);
+  }
+  function read() {
+    const c = SuspenseContext && useContext(SuspenseContext), v = value(), err = error();
+    if (err !== undefined && !pr)
+      throw err;
+    if (Listener && !Listener.user && c) {
+      createComputed(() => {
+        track();
+        if (pr) {
+          if (c.resolved && Transition && loadedUnderTransition)
+            Transition.promises.add(pr);
+          else if (!contexts.has(c)) {
+            c.increment();
+            contexts.add(c);
+          }
+        }
+      });
+    }
+    return v;
+  }
+  function load(refetching = true) {
+    if (refetching !== false && scheduled)
+      return;
+    scheduled = false;
+    const lookup = dynamic ? dynamic() : source;
+    loadedUnderTransition = Transition && Transition.running;
+    if (lookup == null || lookup === false) {
+      loadEnd(pr, untrack(value));
+      return;
+    }
+    if (Transition && pr)
+      Transition.promises.delete(pr);
+    let error2;
+    const p = initP !== NO_INIT ? initP : untrack(() => {
+      try {
+        return fetcher(lookup, {
+          value: value(),
+          refetching
+        });
+      } catch (fetcherError) {
+        error2 = fetcherError;
+      }
+    });
+    if (error2 !== undefined) {
+      loadEnd(pr, undefined, castError(error2), lookup);
+      return;
+    } else if (!isPromise(p)) {
+      loadEnd(pr, p, undefined, lookup);
+      return p;
+    }
+    pr = p;
+    if ("v" in p) {
+      if (p.s === 1)
+        loadEnd(pr, p.v, undefined, lookup);
+      else
+        loadEnd(pr, undefined, castError(p.v), lookup);
+      return p;
+    }
+    scheduled = true;
+    queueMicrotask(() => scheduled = false);
+    runUpdates(() => {
+      setState(resolved ? "refreshing" : "pending");
+      trigger();
+    }, false);
+    return p.then((v) => loadEnd(p, v, undefined, lookup), (e) => loadEnd(p, undefined, castError(e), lookup));
+  }
+  Object.defineProperties(read, {
+    state: {
+      get: () => state()
+    },
+    error: {
+      get: () => error()
+    },
+    loading: {
+      get() {
+        const s = state();
+        return s === "pending" || s === "refreshing";
+      }
+    },
+    latest: {
+      get() {
+        if (!resolved)
+          return read();
+        const err = error();
+        if (err && !pr)
+          throw err;
+        return value();
+      }
+    }
+  });
+  let owner = Owner;
+  if (dynamic)
+    createComputed(() => (owner = Owner, load(false)));
+  else
+    load(false);
+  return [read, {
+    refetch: (info) => runWithOwner(owner, () => load(info)),
+    mutate: setValue
+  }];
+}
+function batch(fn) {
+  return runUpdates(fn, false);
+}
+function untrack(fn) {
+  if (!ExternalSourceConfig && Listener === null)
+    return fn();
+  const listener = Listener;
+  Listener = null;
+  try {
+    if (ExternalSourceConfig)
+      return ExternalSourceConfig.untrack(fn);
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function on(deps, fn, options) {
+  const isArray = Array.isArray(deps);
+  let prevInput;
+  let defer = options && options.defer;
+  return (prevValue) => {
+    let input;
+    if (isArray) {
+      input = Array(deps.length);
+      for (let i = 0;i < deps.length; i++)
+        input[i] = deps[i]();
+    } else
+      input = deps();
+    if (defer) {
+      defer = false;
+      return prevValue;
+    }
+    const result = untrack(() => fn(input, prevInput, prevValue));
+    prevInput = input;
+    return result;
+  };
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+  if (Owner === null)
+    console.warn("cleanups created outside a `createRoot` or `render` will never be run");
+  else if (Owner.cleanups === null)
+    Owner.cleanups = [fn];
+  else
+    Owner.cleanups.push(fn);
+  return fn;
+}
+function getListener() {
+  return Listener;
+}
+function runWithOwner(o, fn) {
+  const prev = Owner;
+  const prevListener = Listener;
+  Owner = o;
+  Listener = null;
+  try {
+    return runUpdates(fn, true);
+  } catch (err) {
+    handleError(err);
+  } finally {
+    Owner = prev;
+    Listener = prevListener;
+  }
+}
+function startTransition(fn) {
+  if (Transition && Transition.running) {
+    fn();
+    return Transition.done;
+  }
+  const l = Listener;
+  const o = Owner;
+  return Promise.resolve().then(() => {
+    Listener = l;
+    Owner = o;
+    let t;
+    if (Scheduler || SuspenseContext) {
+      t = Transition || (Transition = {
+        sources: new Set,
+        effects: [],
+        promises: new Set,
+        disposed: new Set,
+        queue: new Set,
+        running: true
+      });
+      t.done || (t.done = new Promise((res) => t.resolve = res));
+      t.running = true;
+    }
+    runUpdates(fn, false);
+    Listener = Owner = null;
+    return t ? t.done : undefined;
+  });
+}
+function devComponent(Comp, props) {
+  const c = createComputation(() => untrack(() => {
+    Object.assign(Comp, {
+      [$DEVCOMP]: true
+    });
+    return Comp(props);
+  }), undefined, true, 0);
+  c.props = props;
+  c.observers = null;
+  c.observerSlots = null;
+  c.name = Comp.name;
+  c.component = Comp;
+  updateComputation(c);
+  return c.tValue !== undefined ? c.tValue : c.value;
+}
+function registerGraph(value) {
+  if (Owner) {
+    if (Owner.sourceMap)
+      Owner.sourceMap.push(value);
+    else
+      Owner.sourceMap = [value];
+    value.graph = Owner;
+  }
+  if (DevHooks.afterRegisterGraph)
+    DevHooks.afterRegisterGraph(value);
+}
+function createContext(defaultValue, options) {
+  const id = Symbol("context");
+  return {
+    id,
+    Provider: createProvider(id, options),
+    defaultValue
+  };
+}
+function useContext(context) {
+  let value;
+  return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
+}
+function children(fn) {
+  const children2 = createMemo(fn);
+  const memo = createMemo(() => resolveChildren(children2()), undefined, {
+    name: "children"
+  });
+  memo.toArray = () => {
+    const c = memo();
+    return Array.isArray(c) ? c : c != null ? [c] : [];
+  };
+  return memo;
+}
+function readSignal() {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (runningTransition ? this.tState : this.state)) {
+    if ((runningTransition ? this.tState : this.state) === STALE)
+      updateComputation(this);
+    else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  if (runningTransition && Transition.sources.has(this))
+    return this.tValue;
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning)
+        node.value = value;
+    } else
+      node.value = value;
+    if (node.observers && node.observers.length) {
+      runUpdates(() => {
+        for (let i = 0;i < node.observers.length; i += 1) {
+          const o = node.observers[i];
+          const TransitionRunning = Transition && Transition.running;
+          if (TransitionRunning && Transition.disposed.has(o))
+            continue;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
+          }
+          if (!TransitionRunning)
+            o.state = STALE;
+          else
+            o.tState = STALE;
+        }
+        if (Updates.length > 1e6) {
+          Updates = [];
+          if (IS_DEV)
+            throw new Error("Potential Infinite Loop Detected.");
+          throw new Error;
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const time = ExecCount;
+  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+  if (Transition && !Transition.running && Transition.sources.has(node)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        Listener = Owner = node;
+        runComputation(node, node.tValue, time);
+        Listener = Owner = null;
+      }, false);
+    });
+  }
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  const owner = Owner, listener = Listener;
+  Listener = Owner = node;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    if (node.pure) {
+      if (Transition && Transition.running) {
+        node.tState = STALE;
+        node.tOwned && node.tOwned.forEach(cleanNode);
+        node.tOwned = undefined;
+      } else {
+        node.state = STALE;
+        node.owned && node.owned.forEach(cleanNode);
+        node.owned = null;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      Transition.sources.add(node);
+      node.tValue = nextValue;
+    } else
+      node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c = {
+    fn,
+    state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
+  if (Owner === null)
+    console.warn("computations created outside a `createRoot` or `render` will never be disposed");
+  else if (Owner !== UNOWNED) {
+    if (Transition && Transition.running && Owner.pure) {
+      if (!Owner.tOwned)
+        Owner.tOwned = [c];
+      else
+        Owner.tOwned.push(c);
+    } else {
+      if (!Owner.owned)
+        Owner.owned = [c];
+      else
+        Owner.owned.push(c);
+    }
+  }
+  if (options && options.name)
+    c.name = options.name;
+  if (ExternalSourceConfig && c.fn) {
+    const [track, trigger] = createSignal(undefined, {
+      equals: false
+    });
+    const ordinary = ExternalSourceConfig.factory(c.fn, trigger);
+    onCleanup(() => ordinary.dispose());
+    const triggerInTransition = () => startTransition(trigger).then(() => inTransition.dispose());
+    const inTransition = ExternalSourceConfig.factory(c.fn, triggerInTransition);
+    c.fn = (x) => {
+      track();
+      return Transition && Transition.running ? inTransition.track(x) : ordinary.track(x);
+    };
+  }
+  DevHooks.afterCreateOwner && DevHooks.afterCreateOwner(c);
+  return c;
+}
+function runTop(node) {
+  const runningTransition = Transition && Transition.running;
+  if ((runningTransition ? node.tState : node.state) === 0)
+    return;
+  if ((runningTransition ? node.tState : node.state) === PENDING)
+    return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (runningTransition && Transition.disposed.has(node))
+      return;
+    if (runningTransition ? node.tState : node.state)
+      ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1;i >= 0; i--) {
+    node = ancestors[i];
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if ((runningTransition ? node.tState : node.state) === STALE) {
+      updateComputation(node);
+    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait)
+      Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
+    Updates = null;
+  }
+  if (wait)
+    return;
+  let res;
+  if (Transition) {
+    if (!Transition.promises.size && !Transition.queue.size) {
+      const sources = Transition.sources;
+      const disposed = Transition.disposed;
+      Effects.push.apply(Effects, Transition.effects);
+      res = Transition.resolve;
+      for (const e2 of Effects) {
+        "tState" in e2 && (e2.state = e2.tState);
+        delete e2.tState;
+      }
+      Transition = null;
+      runUpdates(() => {
+        for (const d of disposed)
+          cleanNode(d);
+        for (const v of sources) {
+          v.value = v.tValue;
+          if (v.owned) {
+            for (let i = 0, len = v.owned.length;i < len; i++)
+              cleanNode(v.owned[i]);
+          }
+          if (v.tOwned)
+            v.owned = v.tOwned;
+          delete v.tValue;
+          delete v.tOwned;
+          v.tState = 0;
+        }
+        setTransPending(false);
+      }, false);
+    } else if (Transition.running) {
+      Transition.running = false;
+      Transition.effects.push.apply(Transition.effects, Effects);
+      Effects = null;
+      setTransPending(true);
+      return;
+    }
+  }
+  const e = Effects;
+  Effects = null;
+  if (e.length)
+    runUpdates(() => runEffects(e), false);
+  else
+    DevHooks.afterUpdate && DevHooks.afterUpdate();
+  if (res)
+    res();
+}
+function runQueue(queue) {
+  for (let i = 0;i < queue.length; i++)
+    runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+  for (let i = 0;i < queue.length; i++) {
+    const item = queue[i];
+    const tasks = Transition.queue;
+    if (!tasks.has(item)) {
+      tasks.add(item);
+      Scheduler(() => {
+        tasks.delete(item);
+        runUpdates(() => {
+          Transition.running = true;
+          runTop(item);
+        }, false);
+        Transition && (Transition.running = false);
+      });
+    }
+  }
+}
+function runUserEffects(queue) {
+  let i, userLength = 0;
+  for (i = 0;i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
+  }
+  if (sharedConfig.context) {
+    if (sharedConfig.count) {
+      sharedConfig.effects || (sharedConfig.effects = []);
+      sharedConfig.effects.push(...queue.slice(0, userLength));
+      return;
+    }
+    setHydrateContext();
+  }
+  if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+    queue = [...sharedConfig.effects, ...queue];
+    userLength += sharedConfig.effects.length;
+    delete sharedConfig.effects;
+  }
+  for (i = 0;i < userLength; i++)
+    runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  const runningTransition = Transition && Transition.running;
+  if (runningTransition)
+    node.tState = 0;
+  else
+    node.state = 0;
+  for (let i = 0;i < node.sources.length; i += 1) {
+    const source = node.sources[i];
+    if (source.sources) {
+      const state = runningTransition ? source.tState : source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (state === PENDING)
+        lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0;i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (runningTransition ? !o.tState : !o.state) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(), s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (node.tOwned) {
+    for (i = node.tOwned.length - 1;i >= 0; i--)
+      cleanNode(node.tOwned[i]);
+    delete node.tOwned;
+  }
+  if (Transition && Transition.running && node.pure) {
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = node.owned.length - 1;i >= 0; i--)
+      cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1;i >= 0; i--)
+      node.cleanups[i]();
+    node.cleanups = null;
+  }
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
+  delete node.sourceMap;
+}
+function reset(node, top) {
+  if (!top) {
+    node.tState = 0;
+    Transition.disposed.add(node);
+  }
+  if (node.owned) {
+    for (let i = 0;i < node.owned.length; i++)
+      reset(node.owned[i]);
+  }
+}
+function castError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function runErrors(err, fns, owner) {
+  try {
+    for (const f of fns)
+      f(err);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+function handleError(err, owner = Owner) {
+  const fns = ERROR && owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(error, fns, owner);
+      },
+      state: STALE
+    });
+  else
+    runErrors(error, fns, owner);
+}
+function resolveChildren(children2) {
+  if (typeof children2 === "function" && !children2.length)
+    return resolveChildren(children2());
+  if (Array.isArray(children2)) {
+    const results = [];
+    for (let i = 0;i < children2.length; i++) {
+      const result = resolveChildren(children2[i]);
+      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    }
+    return results;
+  }
+  return children2;
+}
+function createProvider(id, options) {
+  return function provider(props) {
+    let res;
+    createRenderEffect(() => res = untrack(() => {
+      Owner.context = {
+        ...Owner.context,
+        [id]: props.value
+      };
+      return children(() => props.children);
+    }), undefined, options);
+    return res;
+  };
+}
+function dispose(d) {
+  for (let i = 0;i < d.length; i++)
+    d[i]();
+}
+function mapArray(list, mapFn, options = {}) {
+  let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
+  onCleanup(() => dispose(disposers));
+  return () => {
+    let newItems = list() || [], newLen = newItems.length, i, j;
+    newItems[$TRACK];
+    return untrack(() => {
+      let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
+      if (newLen === 0) {
+        if (len !== 0) {
+          dispose(disposers);
+          disposers = [];
+          items = [];
+          mapped = [];
+          len = 0;
+          indexes && (indexes = []);
+        }
+        if (options.fallback) {
+          items = [FALLBACK];
+          mapped[0] = createRoot((disposer) => {
+            disposers[0] = disposer;
+            return options.fallback();
+          });
+          len = 1;
+        }
+      } else if (len === 0) {
+        mapped = new Array(newLen);
+        for (j = 0;j < newLen; j++) {
+          items[j] = newItems[j];
+          mapped[j] = createRoot(mapper);
+        }
+        len = newLen;
+      } else {
+        temp = new Array(newLen);
+        tempdisposers = new Array(newLen);
+        indexes && (tempIndexes = new Array(newLen));
+        for (start = 0, end = Math.min(len, newLen);start < end && items[start] === newItems[start]; start++)
+          ;
+        for (end = len - 1, newEnd = newLen - 1;end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
+          temp[newEnd] = mapped[end];
+          tempdisposers[newEnd] = disposers[end];
+          indexes && (tempIndexes[newEnd] = indexes[end]);
+        }
+        newIndices = new Map;
+        newIndicesNext = new Array(newEnd + 1);
+        for (j = newEnd;j >= start; j--) {
+          item = newItems[j];
+          i = newIndices.get(item);
+          newIndicesNext[j] = i === undefined ? -1 : i;
+          newIndices.set(item, j);
+        }
+        for (i = start;i <= end; i++) {
+          item = items[i];
+          j = newIndices.get(item);
+          if (j !== undefined && j !== -1) {
+            temp[j] = mapped[i];
+            tempdisposers[j] = disposers[i];
+            indexes && (tempIndexes[j] = indexes[i]);
+            j = newIndicesNext[j];
+            newIndices.set(item, j);
+          } else
+            disposers[i]();
+        }
+        for (j = start;j < newLen; j++) {
+          if (j in temp) {
+            mapped[j] = temp[j];
+            disposers[j] = tempdisposers[j];
+            if (indexes) {
+              indexes[j] = tempIndexes[j];
+              indexes[j](j);
+            }
+          } else
+            mapped[j] = createRoot(mapper);
+        }
+        mapped = mapped.slice(0, len = newLen);
+        items = newItems.slice(0);
+      }
+      return mapped;
+    });
+    function mapper(disposer) {
+      disposers[j] = disposer;
+      if (indexes) {
+        const [s, set] = createSignal(j, {
+          name: "index"
+        });
+        indexes[j] = set;
+        return mapFn(newItems[j], s);
+      }
+      return mapFn(newItems[j]);
+    }
+  };
+}
+function createComponent(Comp, props) {
+  if (hydrationEnabled) {
+    if (sharedConfig.context) {
+      const c = sharedConfig.context;
+      setHydrateContext(nextHydrateContext());
+      const r = devComponent(Comp, props || {});
+      setHydrateContext(c);
+      return r;
+    }
+  }
+  return devComponent(Comp, props || {});
+}
+function trueFn() {
+  return true;
+}
+function resolveSource(s) {
+  return !(s = typeof s === "function" ? s() : s) ? {} : s;
+}
+function resolveSources() {
+  for (let i = 0, length = this.length;i < length; ++i) {
+    const v = this[i]();
+    if (v !== undefined)
+      return v;
+  }
+}
+function mergeProps(...sources) {
+  let proxy = false;
+  for (let i = 0;i < sources.length; i++) {
+    const s = sources[i];
+    proxy = proxy || !!s && $PROXY in s;
+    sources[i] = typeof s === "function" ? (proxy = true, createMemo(s)) : s;
+  }
+  if (SUPPORTS_PROXY && proxy) {
+    return new Proxy({
+      get(property) {
+        for (let i = sources.length - 1;i >= 0; i--) {
+          const v = resolveSource(sources[i])[property];
+          if (v !== undefined)
+            return v;
+        }
+      },
+      has(property) {
+        for (let i = sources.length - 1;i >= 0; i--) {
+          if (property in resolveSource(sources[i]))
+            return true;
+        }
+        return false;
+      },
+      keys() {
+        const keys = [];
+        for (let i = 0;i < sources.length; i++)
+          keys.push(...Object.keys(resolveSource(sources[i])));
+        return [...new Set(keys)];
+      }
+    }, propTraps);
+  }
+  const sourcesMap = {};
+  const defined = Object.create(null);
+  for (let i = sources.length - 1;i >= 0; i--) {
+    const source = sources[i];
+    if (!source)
+      continue;
+    const sourceKeys = Object.getOwnPropertyNames(source);
+    for (let i2 = sourceKeys.length - 1;i2 >= 0; i2--) {
+      const key = sourceKeys[i2];
+      if (key === "__proto__" || key === "constructor")
+        continue;
+      const desc = Object.getOwnPropertyDescriptor(source, key);
+      if (!defined[key]) {
+        defined[key] = desc.get ? {
+          enumerable: true,
+          configurable: true,
+          get: resolveSources.bind(sourcesMap[key] = [desc.get.bind(source)])
+        } : desc.value !== undefined ? desc : undefined;
+      } else {
+        const sources2 = sourcesMap[key];
+        if (sources2) {
+          if (desc.get)
+            sources2.push(desc.get.bind(source));
+          else if (desc.value !== undefined)
+            sources2.push(() => desc.value);
+        }
+      }
+    }
+  }
+  const target = {};
+  const definedKeys = Object.keys(defined);
+  for (let i = definedKeys.length - 1;i >= 0; i--) {
+    const key = definedKeys[i], desc = defined[key];
+    if (desc && desc.get)
+      Object.defineProperty(target, key, desc);
+    else
+      target[key] = desc ? desc.value : undefined;
+  }
+  return target;
+}
+function For(props) {
+  const fallback = "fallback" in props && {
+    fallback: () => props.fallback
+  };
+  return createMemo(mapArray(() => props.each, props.children, fallback || undefined), undefined, {
+    name: "value"
+  });
+}
+function Show(props) {
+  const keyed = props.keyed;
+  const conditionValue = createMemo(() => props.when, undefined, {
+    name: "condition value"
+  });
+  const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
+    equals: (a, b) => !a === !b,
+    name: "condition"
+  });
+  return createMemo(() => {
+    const c = condition();
+    if (c) {
+      const child = props.children;
+      const fn = typeof child === "function" && child.length > 0;
+      return fn ? untrack(() => child(keyed ? c : () => {
+        if (!untrack(condition))
+          throw narrowedError("Show");
+        return conditionValue();
+      })) : child;
+    }
+    return props.fallback;
+  }, undefined, {
+    name: "value"
+  });
+}
+function Switch(props) {
+  const chs = children(() => props.children);
+  const switchFunc = createMemo(() => {
+    const ch = chs();
+    const mps = Array.isArray(ch) ? ch : [ch];
+    let func = () => {
+      return;
+    };
+    for (let i = 0;i < mps.length; i++) {
+      const index = i;
+      const mp = mps[i];
+      const prevFunc = func;
+      const conditionValue = createMemo(() => prevFunc() ? undefined : mp.when, undefined, {
+        name: "condition value"
+      });
+      const condition = mp.keyed ? conditionValue : createMemo(conditionValue, undefined, {
+        equals: (a, b) => !a === !b,
+        name: "condition"
+      });
+      func = () => prevFunc() || (condition() ? [index, conditionValue, mp] : undefined);
+    }
+    return func;
+  });
+  return createMemo(() => {
+    const sel = switchFunc()();
+    if (!sel)
+      return props.fallback;
+    const [index, conditionValue, mp] = sel;
+    const child = mp.children;
+    const fn = typeof child === "function" && child.length > 0;
+    return fn ? untrack(() => child(mp.keyed ? conditionValue() : () => {
+      if (untrack(switchFunc)()?.[0] !== index)
+        throw narrowedError("Match");
+      return conditionValue();
+    })) : child;
+  }, undefined, {
+    name: "eval conditions"
+  });
+}
+function Match(props) {
+  return props;
+}
+var sharedConfig, IS_DEV = true, equalFn = (a, b) => a === b, $PROXY, SUPPORTS_PROXY, $TRACK, $DEVCOMP, signalOptions, ERROR = null, runEffects, STALE = 1, PENDING = 2, UNOWNED, NO_INIT, Owner = null, Transition = null, Scheduler = null, ExternalSourceConfig = null, Listener = null, Updates = null, Effects = null, ExecCount = 0, DevHooks, transPending, setTransPending, SuspenseContext, FALLBACK, hydrationEnabled = false, propTraps, narrowedError = (name) => `Attempting to access a stale value from <${name}> that could possibly be undefined. This may occur because you are reading the accessor returned from the component at a time where it has already been unmounted. We recommend cleaning up any stale timers or async, or reading from the initial condition.`, DEV;
+var init_dev = __esm(() => {
+  sharedConfig = {
+    context: undefined,
+    registry: undefined,
+    effects: undefined,
+    done: false,
+    getContextId() {
+      return getContextId(this.context.count);
+    },
+    getNextContextId() {
+      return getContextId(this.context.count++);
+    }
+  };
+  $PROXY = Symbol("solid-proxy");
+  SUPPORTS_PROXY = typeof Proxy === "function";
+  $TRACK = Symbol("solid-track");
+  $DEVCOMP = Symbol("solid-dev-component");
+  signalOptions = {
+    equals: equalFn
+  };
+  runEffects = runQueue;
+  UNOWNED = {
+    owned: null,
+    cleanups: null,
+    context: null,
+    owner: null
+  };
+  NO_INIT = {};
+  DevHooks = {
+    afterUpdate: null,
+    afterCreateOwner: null,
+    afterCreateSignal: null,
+    afterRegisterGraph: null
+  };
+  [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
+  FALLBACK = Symbol("fallback");
+  propTraps = {
+    get(_, property, receiver) {
+      if (property === $PROXY)
+        return receiver;
+      return _.get(property);
+    },
+    has(_, property) {
+      if (property === $PROXY)
+        return true;
+      return _.has(property);
+    },
+    set: trueFn,
+    deleteProperty: trueFn,
+    getOwnPropertyDescriptor(_, property) {
+      return {
+        configurable: true,
+        enumerable: true,
+        get() {
+          return _.get(property);
+        },
+        set: trueFn,
+        deleteProperty: trueFn
+      };
+    },
+    ownKeys(_) {
+      return _.keys();
+    }
+  };
+  DEV = {
+    hooks: DevHooks,
+    writeSignal,
+    registerGraph
+  };
+  if (globalThis) {
+    if (!globalThis.Solid$$)
+      globalThis.Solid$$ = true;
+    else
+      console.warn("You appear to have multiple instances of Solid. This can lead to unexpected behavior.");
+  }
+});
+
+// src/engine/claude-settings.ts
+import { readFileSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join2 } 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 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 = join2(homedir5(), ".claude", "settings.json");
+});
+
+// src/env.ts
+import { homedir as homedir6 } from "os";
+import { join as join3 } from "path";
+function isDev() {
+  return process.env.KOBE_DEV === "1";
+}
+function homeDir() {
+  return process.env.KOBE_HOME_DIR ?? homedir6();
+}
+function kobeStateDir() {
+  return join3(homeDir(), ".kobe");
+}
+function kvStatePath() {
+  return join3(homeDir(), ".config", "kobe", "state.json");
+}
+function tmuxBin() {
+  return process.env.KOBE_TMUX_BIN ?? "tmux";
+}
+var init_env = () => {};
+
+// src/state/repos.ts
+var exports_repos = {};
+__export(exports_repos, {
+  statePath: () => statePath,
+  resolveRepoRoot: () => resolveRepoRoot,
+  removeSavedRepo: () => removeSavedRepo,
+  normalizeSavedRepos: () => normalizeSavedRepos,
+  getSavedRepos: () => getSavedRepos,
+  addSavedRepo: () => addSavedRepo
+});
+import { spawnSync as spawnSync2 } from "child_process";
+import { mkdirSync, readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync } from "fs";
+import { dirname as dirname2 } from "path";
+function resolveRepoRoot(absPath) {
+  const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
+    cwd: absPath,
+    encoding: "utf8",
+    shell: false
+  });
+  if (r.status !== 0)
+    return absPath;
+  const top = (r.stdout ?? "").trim();
+  if (!top)
+    return absPath;
+  try {
+    if (realpathSync(absPath) === realpathSync(top))
+      return absPath;
+  } catch {}
+  return top;
+}
+function statePath() {
+  return kvStatePath();
+}
+function load() {
+  try {
+    const text = readFileSync2(statePath(), "utf8");
+    const parsed = JSON.parse(text);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return {};
+}
+function save(state) {
+  const path4 = statePath();
+  mkdirSync(dirname2(path4), { recursive: true });
+  const tmp = `${path4}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
+  renameSync(tmp, path4);
+}
+function getSavedRepos() {
+  const state = load();
+  const raw = state.savedRepos;
+  if (!Array.isArray(raw))
+    return [];
+  return raw.filter((s) => typeof s === "string");
+}
+function addSavedRepo(absPath) {
+  const normalized = resolveRepoRoot(absPath);
+  const state = load();
+  const cur = getSavedRepos();
+  if (cur.includes(normalized)) {
+    return { added: false, path: normalized, total: cur.length };
+  }
+  state.savedRepos = [...cur, normalized];
+  save(state);
+  return { added: true, path: normalized, total: cur.length + 1 };
+}
+function normalizeSavedRepos() {
+  const state = load();
+  const cur = getSavedRepos();
+  const seen = new Set;
+  const next = [];
+  let changed = false;
+  for (const p of cur) {
+    const top = resolveRepoRoot(p);
+    if (top !== p)
+      changed = true;
+    if (seen.has(top)) {
+      changed = true;
+      continue;
+    }
+    seen.add(top);
+    next.push(top);
+  }
+  if (!changed)
+    return;
+  state.savedRepos = next;
+  save(state);
+}
+function removeSavedRepo(absPath) {
+  const state = load();
+  const cur = getSavedRepos();
+  if (!cur.includes(absPath)) {
+    return { removed: false, path: absPath, total: cur.length };
+  }
+  state.savedRepos = cur.filter((p) => p !== absPath);
+  save(state);
+  return { removed: true, path: absPath, total: cur.length - 1 };
+}
+var init_repos = __esm(() => {
+  init_env();
+});
+
+// src/types/task.ts
+function nextChatTabSeq(tabs) {
+  let max = 0;
+  for (const t of tabs)
+    if (t.seq > max)
+      max = t.seq;
+  return max + 1;
+}
+var toTaskId = (id) => id;
+
+// src/orchestrator/index/ulid.ts
+function encodeTime(now, len) {
+  let out = "";
+  let n = now;
+  for (let i = len - 1;i >= 0; i--) {
+    const mod = n % 32;
+    out = ALPHABET[mod] + out;
+    n = (n - mod) / 32;
+  }
+  return out;
+}
+function randomIndices(len) {
+  const buf = new Uint8Array(len);
+  crypto.getRandomValues(buf);
+  const out = new Array(len);
+  for (let i = 0;i < len; i++) {
+    out[i] = (buf[i] ?? 0) & 31;
+  }
+  return out;
+}
+function incrementIndices(indices) {
+  for (let i = indices.length - 1;i >= 0; i--) {
+    const v = indices[i] ?? 0;
+    if (v < 31) {
+      indices[i] = v + 1;
+      return true;
+    }
+    indices[i] = 0;
+  }
+  return false;
+}
+function indicesToString(indices) {
+  let out = "";
+  for (const idx of indices) {
+    out += ALPHABET[idx] ?? "0";
+  }
+  return out;
+}
+function ulid(now = Date.now()) {
+  let randIndices;
+  if (now === lastTime) {
+    const next = lastRand.slice();
+    if (!incrementIndices(next)) {
+      randIndices = randomIndices(RAND_LEN);
+    } else {
+      randIndices = next;
+    }
+  } else {
+    randIndices = randomIndices(RAND_LEN);
+  }
+  lastTime = now;
+  lastRand = randIndices;
+  return encodeTime(now, TIME_LEN) + indicesToString(randIndices);
+}
+var ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ", TIME_LEN = 10, RAND_LEN = 16, lastTime = -1, lastRand;
+var init_ulid = __esm(() => {
+  lastRand = new Array(RAND_LEN).fill(0);
+});
+
+// src/orchestrator/metadata-suggester.ts
+import { spawn as spawn2 } from "child_process";
+
+class MetadataSuggester {
+  binaryPromise = null;
+  async suggestBranchSlug(prompt) {
+    return this.runOneShot(buildBranchInstruction, sanitizeKebabSlug, prompt);
+  }
+  async suggestWorktreeSlug(prompt) {
+    return this.runOneShot(buildWorktreeInstruction, sanitizeKebabSlug, prompt);
+  }
+  async suggestTitle(prompt) {
+    return this.runOneShot(buildTitleInstruction, sanitizeTitleText, prompt);
+  }
+  async resolveBinary() {
+    if (!this.binaryPromise) {
+      this.binaryPromise = findClaudeBinary().catch(() => null);
+    }
+    return this.binaryPromise;
+  }
+  async runOneShot(builder, sanitize, prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed)
+      return null;
+    const binary = await this.resolveBinary();
+    if (!binary)
+      return null;
+    return new Promise((resolve) => {
+      let proc;
+      try {
+        proc = spawn2(binary, ["-p", builder(trimmed)], {
+          stdio: ["ignore", "pipe", "ignore"],
+          env: process.env
+        });
+      } catch {
+        resolve(null);
+        return;
+      }
+      let buf = "";
+      let settled = false;
+      const settle = (v) => {
+        if (settled)
+          return;
+        settled = true;
+        try {
+          proc.kill();
+        } catch {}
+        resolve(v);
+      };
+      const timer = setTimeout(() => settle(null), SUGGESTION_TIMEOUT_MS);
+      proc.stdout?.on("data", (chunk) => {
+        buf += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      });
+      proc.on("error", () => {
+        clearTimeout(timer);
+        settle(null);
+      });
+      proc.on("close", () => {
+        clearTimeout(timer);
+        settle(sanitize(buf));
+      });
+    });
+  }
+}
+function buildBranchInstruction(prompt) {
+  return [
+    "Generate a short git branch slug for this user task.",
+    "Rules:",
+    "- Lowercase, kebab-case, alphanumeric + hyphens only.",
+    `- Max ${MAX_SLUG_LEN} characters.`,
+    "- Action-oriented (e.g. fix-login-redirect, add-csv-export).",
+    "- Reply with ONLY the slug, no other text, no quotes, no explanation.",
+    "",
+    `User task: ${prompt}`,
+    "",
+    "Branch slug:"
+  ].join(`
+`);
+}
+function buildWorktreeInstruction(prompt) {
+  return [
+    "Generate a short directory-name slug for a per-task git worktree.",
+    "Rules:",
+    "- Lowercase, kebab-case, alphanumeric + hyphens only.",
+    `- Max ${MAX_SLUG_LEN} characters.`,
+    "- Topic-oriented; describe the work area, not the action verb.",
+    "- Reply with ONLY the slug, no other text, no quotes, no explanation.",
+    "",
+    `User task: ${prompt}`,
+    "",
+    "Worktree slug:"
+  ].join(`
+`);
+}
+function buildTitleInstruction(prompt) {
+  return [
+    "Generate a short sidebar title for this user task.",
+    "Rules:",
+    `- \u2264 ${MAX_TITLE_LEN} characters, single line.`,
+    "- Sentence case, no trailing period.",
+    `- Capture the essential action (e.g. "Fix login redirect", "Add CSV export to settings").`,
+    `- Reply with ONLY the title, no quotes, no explanation, no leading "Title:".`,
+    "",
+    `User task: ${prompt}`,
+    "",
+    "Title:"
+  ].join(`
+`);
+}
+function sanitizeKebabSlug(raw) {
+  const firstLine = raw.split(/\r?\n/).map((s) => s.trim()).find((s) => s.length > 0);
+  if (!firstLine)
+    return null;
+  const cleaned = firstLine.toLowerCase().replace(/^["'`]+|["'`]+$/g, "").replace(/^(branch|slug|worktree)[:\s-]+/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, MAX_SLUG_LEN).replace(/-+$/g, "");
+  return cleaned.length > 0 ? cleaned : null;
+}
+function sanitizeTitleText(raw) {
+  const firstLine = raw.split(/\r?\n/).map((s) => s.trim()).find((s) => s.length > 0);
+  if (!firstLine)
+    return null;
+  const cleaned = firstLine.replace(/^["'`]+|["'`]+$/g, "").replace(/^title[:\s-]+/i, "").replace(/[\s.!]+$/g, "").slice(0, MAX_TITLE_LEN).trim();
+  return cleaned.length > 0 ? cleaned : null;
+}
+var SUGGESTION_TIMEOUT_MS = 30000, MAX_SLUG_LEN = 32, MAX_TITLE_LEN = 60;
+var init_metadata_suggester = __esm(() => {
+  init_binary();
+});
+
+// src/orchestrator/pending-input-broker.ts
+class InMemoryPendingInputBroker {
+  buckets = new Map;
+  requestTab = new Map;
+  record(taskId, tabKey, requestId, payload) {
+    let bucket = this.buckets.get(taskId);
+    if (!bucket) {
+      bucket = new Map;
+      this.buckets.set(taskId, bucket);
+    }
+    if (bucket.has(requestId))
+      return;
+    bucket.set(requestId, payload);
+    this.requestTab.set(requestId, tabKey);
+  }
+  resolve(taskId, requestId) {
+    const bucket = this.buckets.get(taskId);
+    const payload = bucket?.get(requestId);
+    const tabKey = this.requestTab.get(requestId);
+    if (!bucket || !payload || !tabKey)
+      return null;
+    bucket.delete(requestId);
+    if (bucket.size === 0)
+      this.buckets.delete(taskId);
+    this.requestTab.delete(requestId);
+    return { requestId, payload, tabKey };
+  }
+  snapshot(taskId) {
+    const bucket = this.buckets.get(taskId);
+    if (!bucket)
+      return [];
+    return Array.from(bucket.entries()).map(([requestId, payload]) => ({
+      requestId,
+      payload,
+      tabKey: this.requestTab.get(requestId) ?? ""
+    }));
+  }
+  awaitingTabKeys() {
+    return this.requestTab.values();
+  }
+  clearForTask(taskId) {
+    const bucket = this.buckets.get(taskId);
+    if (!bucket)
+      return;
+    for (const requestId of bucket.keys())
+      this.requestTab.delete(requestId);
+    this.buckets.delete(taskId);
+  }
+}
+
+// src/orchestrator/pr/build.ts
+import { spawnSync as spawnSync3 } from "child_process";
+function git(cwd, args) {
+  try {
+    const out = spawnSync3("git", args.slice(), {
+      cwd,
+      encoding: "utf8",
+      timeout: GIT_TIMEOUT_MS
+    });
+    if (out.error)
+      return null;
+    if (out.status !== 0)
+      return null;
+    return (out.stdout ?? "").trim();
+  } catch {
+    return null;
+  }
+}
+function currentBranch(cwd) {
+  const out = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (!out)
+    return "HEAD";
+  return out;
+}
+function targetBranch(cwd) {
+  const out = git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
+  if (!out)
+    return "main";
+  return out.startsWith("origin/") ? out.slice("origin/".length) : out;
+}
+function hasUpstream(cwd) {
+  const out = git(cwd, ["rev-parse", "--abbrev-ref", "@{u}"]);
+  return out !== null && out.length > 0;
+}
+function dirtyCount(cwd) {
+  const out = git(cwd, ["status", "--porcelain"]);
+  if (!out)
+    return 0;
+  return out.split(`
+`).filter((line) => line.length > 0).length;
+}
+async function gatherPRState(worktreePath) {
+  return {
+    branch: currentBranch(worktreePath),
+    targetBranch: targetBranch(worktreePath),
+    hasUpstream: hasUpstream(worktreePath),
+    dirtyCount: dirtyCount(worktreePath)
+  };
+}
+var GIT_TIMEOUT_MS = 5000;
+var init_build = () => {};
+
+// src/orchestrator/pr/instructions.ts
+import { promises as fs } from "fs";
+import path4 from "path";
+function dirtyCountSentence(n) {
+  if (n <= 0)
+    return "There are no uncommitted changes.";
+  if (n === 1)
+    return "There is 1 uncommitted change.";
+  return `There are ${n} uncommitted changes.`;
+}
+function upstreamSentence(hasUpstream2) {
+  return hasUpstream2 ? "The current branch tracks an upstream." : "There is no upstream branch yet.";
+}
+function renderPRInstructions(template, state) {
+  const replacements = {
+    branch: state.branch,
+    targetBranch: state.targetBranch,
+    dirtyCountSentence: dirtyCountSentence(state.dirtyCount),
+    upstreamSentence: upstreamSentence(state.hasUpstream)
+  };
+  return template.replace(/\{\{([a-zA-Z][a-zA-Z0-9_]*)\}\}/g, (match, key) => {
+    if (Object.hasOwn(replacements, key)) {
+      return replacements[key];
+    }
+    return match;
+  });
+}
+async function loadPRInstructionsTemplate(worktreePath) {
+  if (!worktreePath)
+    return DEFAULT_PR_INSTRUCTIONS_TEMPLATE;
+  const file = path4.join(worktreePath, ".kobe", "pr-instructions.md");
+  try {
+    const text = await fs.readFile(file, "utf8");
+    if (text.length === 0)
+      return DEFAULT_PR_INSTRUCTIONS_TEMPLATE;
+    return text;
+  } catch {
+    return DEFAULT_PR_INSTRUCTIONS_TEMPLATE;
+  }
+}
+var DEFAULT_PR_INSTRUCTIONS_TEMPLATE = `The user likes the current state of the code.
+
+{{dirtyCountSentence}}
+The current branch is {{branch}}.
+The target branch is {{targetBranch}}.
+
+{{upstreamSentence}}
+The user requested a PR.
+
+Follow these steps to create a PR:
+
+- If you have any skills related to creating PRs, invoke them now. Instructions there should take precedence over these instructions.
+- Run \`git diff\` to review uncommitted changes.
+- Commit them. Follow any instructions the user gave you about writing commit messages.
+- Push to origin.
+- Use \`gh pr create --base {{targetBranch}}\` to create a PR onto the target branch. Keep the title under 80 characters. Keep the description under five sentences. Describe not just changes made in this session but ALL changes since the branch diverged from the target.
+
+If any of these steps fail, ask the user for help.`;
+var init_instructions = () => {};
+
+// src/orchestrator/pr/index.ts
+var exports_pr = {};
+__export(exports_pr, {
+  renderPRInstructions: () => renderPRInstructions,
+  loadPRInstructionsTemplate: () => loadPRInstructionsTemplate,
+  gatherPRState: () => gatherPRState,
+  DEFAULT_PR_INSTRUCTIONS_TEMPLATE: () => DEFAULT_PR_INSTRUCTIONS_TEMPLATE
+});
+var init_pr = __esm(() => {
+  init_build();
+  init_instructions();
+});
+
+// src/orchestrator/session-pump.ts
+class SessionPump {
+  env;
+  constructor(env) {
+    this.env = env;
+  }
+  async run(taskId, tabId, handle) {
+    const tabKey = chatRunStateKey(taskId, tabId);
+    let killedForInput = false;
+    let terminalEvent = null;
+    try {
+      for await (const ev of this.env.engine.stream(handle)) {
+        const inputReq = detectUserInputFromEngineEvent(ev);
+        if (inputReq) {
+          this.env.dispatch(taskId, tabId, ev);
+          const requestId = this.env.nextRequestId();
+          this.env.broker.record(taskId, tabKey, requestId, inputReq);
+          this.env.onPendingInputChange?.();
+          this.env.dispatch(taskId, tabId, {
+            type: "user_input.request",
+            requestId,
+            payload: inputReq
+          });
+          killedForInput = true;
+          try {
+            await this.env.engine.stop(handle);
+          } catch {}
+          break;
+        }
+        if (ev.type === "done" || ev.type === "error") {
+          terminalEvent = ev;
+          continue;
+        }
+        this.env.dispatch(taskId, tabId, ev);
+      }
+    } finally {
+      if (!killedForInput) {
+        try {
+          await this.env.engine.stop(handle);
+        } catch {}
+      }
+    }
+    return { terminalEvent, killedForInput };
+  }
+}
+var init_session_pump = __esm(() => {
+  init_core();
+});
+
+// src/orchestrator/core.ts
+var exports_core = {};
+__export(exports_core, {
+  summarizeWorktreeError: () => summarizeWorktreeError,
+  renderUserInputResponsePrompt: () => renderUserInputResponsePrompt,
+  detectUserInputFromEngineEvent: () => detectUserInputFromEngineEvent,
+  deriveTitleFromPrompt: () => deriveTitleFromPrompt,
+  chatRunStateKey: () => chatRunStateKey,
+  TaskNotFoundError: () => TaskNotFoundError,
+  TITLE_CHAR_CAP: () => TITLE_CHAR_CAP,
+  PRPreconditionError: () => PRPreconditionError,
+  PLACEHOLDER_TASK_TITLE: () => PLACEHOLDER_TASK_TITLE,
+  Orchestrator: () => Orchestrator,
+  IllegalTransitionError: () => IllegalTransitionError,
+  ConcurrencyCapError: () => ConcurrencyCapError,
+  CannotDeleteMainTaskError: () => CannotDeleteMainTaskError,
+  CONCURRENCY_CAP: () => CONCURRENCY_CAP
+});
+function chatRunStateKey(taskId, tabId) {
+  return `${taskId}:${tabId}`;
+}
+function tabKey(taskId, tabId) {
+  return `${taskId}:${tabId}`;
+}
+function summarizeWorktreeError(raw, repo, baseRef) {
+  const m = raw.toLowerCase();
+  if (m.includes("invalid reference") || m.includes("unknown revision") || m.includes("not a valid object name")) {
+    const ref = baseRef ?? "(none)";
+    return `could not create worktree: base ref '${ref}' does not exist in ${repo}`;
+  }
+  if (m.includes("not a git repository") || m.includes("not in a git directory")) {
+    return `could not create worktree: ${repo} is not a git repository`;
+  }
+  if (m.includes("permission denied") || m.includes("eacces")) {
+    return `could not create worktree: permission denied writing into ${repo}/.claude/worktrees/`;
+  }
+  if (m.includes("already exists") || m.includes("refusing to hijack") || m.includes("is on branch")) {
+    return `could not create worktree: a stale worktree already exists for this task (try removing it under ${repo}/.claude/worktrees/)`;
+  }
+  if (m.includes("enoent") || m.includes("does not exist")) {
+    return `could not create worktree: ${repo} does not exist`;
+  }
+  const fatal = raw.match(/fatal:\s*([^\n]+)/i);
+  if (fatal)
+    return `could not create worktree: ${fatal[1]?.trim() ?? raw}`;
+  return `could not create worktree: ${raw.trim()}`;
+}
+
+class Orchestrator {
+  engine;
+  store;
+  worktrees;
+  metadataSuggester;
+  handles = new Map;
+  subscribers = new Map;
+  pumps = new Map;
+  pendingInputBroker = new InMemoryPendingInputBroker;
+  requestIdCounter = 0;
+  sessionPump;
+  pendingWorktreeOpts = new Map;
+  tasksAcc;
+  setTasks;
+  unsubscribeStore;
+  runStateAcc;
+  setRunState;
+  constructor(deps) {
+    this.engine = deps.engine;
+    this.store = deps.store;
+    this.worktrees = deps.worktrees;
+    this.metadataSuggester = deps.metadataSuggester ?? new MetadataSuggester;
+    const [tasks, setTasks] = createSignal(this.store.list());
+    this.tasksAcc = tasks;
+    this.setTasks = (next) => setTasks(() => next);
+    this.unsubscribeStore = this.store.subscribe((snapshot) => {
+      this.setTasks(snapshot.slice());
+    });
+    const [runState, setRunState] = createSignal(new Map);
+    this.runStateAcc = runState;
+    this.setRunState = (next) => setRunState(() => next);
+    this.sessionPump = new SessionPump({
+      engine: this.engine,
+      broker: this.pendingInputBroker,
+      dispatch: (taskId, tabId, ev) => this.dispatchEvent(taskId, tabId, ev),
+      nextRequestId: () => `req-${++this.requestIdCounter}`,
+      onPendingInputChange: () => this.bumpRunState()
+    });
+  }
+  bumpRunState() {
+    const next = new Map;
+    for (const tabKey2 of this.pendingInputBroker.awaitingTabKeys()) {
+      next.set(tabKey2, "awaiting_input");
+    }
+    for (const key of this.handles.keys()) {
+      if (!next.has(key))
+        next.set(key, "running");
+    }
+    this.setRunState(next);
+  }
+  chatRunStateSignal() {
+    return this.runStateAcc;
+  }
+  tasksSignal() {
+    return this.tasksAcc;
+  }
+  subscribeTasks(listener) {
+    return this.store.subscribe(listener);
+  }
+  dispose() {
+    this.unsubscribeStore();
+  }
+  listTasks() {
+    return this.store.list();
+  }
+  getTask(id) {
+    return this.store.get(id);
+  }
+  peekPendingInput(id) {
+    return this.pendingInputBroker.snapshot(String(id));
+  }
+  async createTask(input) {
+    if (!input.repo)
+      throw new Error("createTask: repo is required");
+    const explicitTitle = input.title?.trim() ?? "";
+    const derivedTitle = explicitTitle || deriveTitleFromPrompt(input.prompt ?? "");
+    const finalTitle = derivedTitle || PLACEHOLDER_TASK_TITLE;
+    const created = await this.store.create({
+      title: finalTitle,
+      repo: input.repo,
+      branch: "",
+      worktreePath: "",
+      sessionId: null,
+      status: "backlog",
+      archived: false
+    });
+    this.pendingWorktreeOpts.set(created.id, {
+      branch: input.branch,
+      baseRef: input.baseRef
+    });
+    return created;
+  }
+  async ensureMainTask(repo) {
+    if (!repo)
+      throw new Error("ensureMainTask: repo is required");
+    const normalized = resolveRepoRoot(repo);
+    const all = this.store.list();
+    const candidates = all.filter((t) => t.kind === "main" && (t.repo === normalized || resolveRepoRoot(t.repo) === normalized));
+    const winner = candidates.find((t) => t.repo === normalized) ?? candidates[0];
+    if (winner) {
+      for (const dup of candidates) {
+        if (dup.id !== winner.id) {
+          try {
+            await this.deleteTask(dup.id);
+          } catch (err) {
+            console.error(`[kobe orchestrator] ensureMainTask: failed to remove duplicate ${dup.id}:`, err);
+          }
+        }
+      }
+      let existing = winner;
+      if (existing.repo !== normalized || existing.worktreePath !== normalized) {
+        existing = await this.store.update(existing.id, {
+          repo: normalized,
+          worktreePath: normalized,
+          title: normalized.split("/").filter(Boolean).pop() ?? normalized
+        });
+      }
+      if (existing.archived) {
+        return await this.store.update(existing.id, { archived: false });
+      }
+      return existing;
+    }
+    const basename = normalized.split("/").filter(Boolean).pop() ?? normalized;
+    return await this.store.create({
+      title: basename,
+      repo: normalized,
+      branch: "",
+      worktreePath: normalized,
+      sessionId: null,
+      status: "backlog",
+      archived: false,
+      kind: "main"
+    });
+  }
+  async ensureWorktree(task) {
+    if (task.worktreePath)
+      return task;
+    const opts = this.pendingWorktreeOpts.get(task.id);
+    const branch = opts?.branch ?? `kobe/tmp-${task.id.slice(-8).toLowerCase()}`;
+    const baseRef = opts?.baseRef;
+    let info;
+    try {
+      info = await this.worktrees.createForTask({
+        repo: task.repo,
+        taskId: task.id,
+        branch,
+        baseRef
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(summarizeWorktreeError(message, task.repo, baseRef ?? null), { cause: err });
+    }
+    this.pendingWorktreeOpts.delete(task.id);
+    return await this.store.update(task.id, {
+      branch: info.branch,
+      worktreePath: info.path
+    });
+  }
+  async maybeRenameTempBranch(taskId, tabId, prompt) {
+    if (!prompt || prompt.trim().length === 0)
+      return;
+    const task = this.store.get(taskId);
+    if (!task || !task.worktreePath)
+      return;
+    if (!task.branch.startsWith("kobe/tmp-"))
+      return;
+    this.dispatchEvent(taskId, tabId, {
+      type: "system.info",
+      text: "branch: choosing a name\u2026"
+    });
+    const slug = await this.metadataSuggester.suggestBranchSlug(prompt);
+    if (!slug)
+      return;
+    const fresh = this.store.get(taskId);
+    if (!fresh || !fresh.worktreePath)
+      return;
+    if (fresh.branch !== task.branch)
+      return;
+    const newBranch = `kobe/${slug}-${taskId.slice(-4).toLowerCase()}`;
+    if (newBranch === fresh.branch)
+      return;
+    try {
+      await this.worktrees.renameBranch(fresh.worktreePath, fresh.branch, newBranch);
+      await this.store.update(taskId, { branch: newBranch });
+      this.dispatchEvent(taskId, tabId, {
+        type: "system.info",
+        text: `branch: renamed to ${newBranch}`
+      });
+    } catch {}
+  }
+  async maybeUpgradeTitle(taskId, prompt) {
+    if (!prompt || prompt.trim().length === 0)
+      return;
+    const task = this.store.get(taskId);
+    if (!task)
+      return;
+    const derived = deriveTitleFromPrompt(prompt);
+    if (!derived)
+      return;
+    if (task.title !== derived)
+      return;
+    const suggested = await this.metadataSuggester.suggestTitle(prompt);
+    if (!suggested)
+      return;
+    if (suggested === derived)
+      return;
+    const fresh = this.store.get(taskId);
+    if (!fresh)
+      return;
+    if (fresh.title !== derived)
+      return;
+    await this.store.update(taskId, { title: suggested });
+  }
+  async runTask(id, prompt, tabId) {
+    let task = this.requireTask(id);
+    if (task.status === "canceled") {
+      throw new IllegalTransitionError(task.status, "in_progress", String(id));
+    }
+    const isMain = task.kind === "main";
+    const isFirstAllocation = !isMain && !task.worktreePath;
+    if (isFirstAllocation) {
+      task = await this.ensureWorktree(task);
+      const targetTabForInfo = this.resolveTab(task, tabId);
+      this.dispatchEvent(task.id, targetTabForInfo.id, {
+        type: "system.info",
+        text: `worktree: ${task.worktreePath} (branch ${task.branch})`
+      });
+    }
+    if (isFirstAllocation && prompt) {
+      const renameTabId = this.resolveTab(task, tabId).id;
+      this.maybeRenameTempBranch(task.id, renameTabId, prompt);
+    }
+    const targetTab = this.resolveTab(task, tabId);
+    const key = tabKey(task.id, targetTab.id);
+    if (this.handles.has(key) === false) {
+      const running = this.countRunning();
+      if (running >= CONCURRENCY_CAP) {
+        throw new ConcurrencyCapError;
+      }
+    }
+    const promptToSend = prompt && prompt.length > 0 ? prompt : " ";
+    if (prompt && prompt.trim().length > 0) {
+      this.dispatchEvent(task.id, targetTab.id, { type: "user.inject", text: prompt });
+    }
+    const modelToUse = task.model ?? resolveDefaultModelId();
+    let handle;
+    if (targetTab.sessionId) {
+      handle = await this.engine.resume(targetTab.sessionId, promptToSend, {
+        cwd: task.worktreePath,
+        env: { KOBE_RESUME_CWD: task.worktreePath },
+        permissionMode: task.permissionMode,
+        model: modelToUse
+      });
+    } else {
+      handle = await this.engine.spawn(task.worktreePath, promptToSend, {
+        permissionMode: task.permissionMode,
+        model: modelToUse
+      });
+      await this.updateTab(task.id, targetTab.id, { sessionId: handle.sessionId });
+      if (task.title === PLACEHOLDER_TASK_TITLE && prompt && prompt.trim().length > 0) {
+        const derived = deriveTitleFromPrompt(prompt);
+        if (derived)
+          await this.store.update(task.id, { title: derived });
+      }
+      if (prompt && prompt.trim().length > 0) {
+        this.maybeUpgradeTitle(task.id, prompt);
+      }
+    }
+    this.handles.set(key, handle);
+    this.bumpRunState();
+    if (task.status !== "in_progress") {
+      await this.store.update(task.id, { status: "in_progress" });
+    }
+    const pump = this.runPumpAndCleanup(task.id, targetTab.id, handle);
+    this.pumps.set(key, pump);
+    pump.catch((err) => {
+      this.dispatchEvent(task.id, targetTab.id, {
+        type: "error",
+        message: `pump failure: ${err instanceof Error ? err.message : String(err)}`
+      });
+    });
+  }
+  async requestPR(id) {
+    const task = this.requireTask(id);
+    if (task.status === "canceled") {
+      throw new PRPreconditionError("Cannot create a PR for a canceled task.");
+    }
+    if (!task.worktreePath) {
+      throw new PRPreconditionError("Task has no worktree yet \u2014 wait for setup to finish.");
+    }
+    if (!task.repo) {
+      throw new PRPreconditionError("Task has no repo path; cannot resolve git state.");
+    }
+    const state = await gatherPRState(task.worktreePath);
+    const template = await loadPRInstructionsTemplate(task.worktreePath);
+    const prompt = renderPRInstructions(template, state);
+    const activeTab = this.resolveTab(task);
+    await this.runTask(task.id, prompt, activeTab.id);
+  }
+  async respondToInput(id, requestId, response) {
+    const task = this.requireTask(id);
+    const resolved = this.pendingInputBroker.resolve(task.id, requestId);
+    if (!resolved)
+      return;
+    const pending = resolved.payload;
+    this.bumpRunState();
+    const tabId = task.activeTabId;
+    this.dispatchEvent(task.id, tabId, { type: "user_input.resolved", requestId, response });
+    const prompt = renderUserInputResponsePrompt(pending, response);
+    if (!prompt)
+      return;
+    await this.runTask(task.id, prompt, tabId);
+  }
+  async interruptTask(id, tabId) {
+    const task = this.requireTask(id);
+    const targetTab = this.resolveTab(task, tabId);
+    const key = tabKey(task.id, targetTab.id);
+    const handle = this.handles.get(key);
+    if (!handle)
+      return;
+    this.dispatchEvent(task.id, targetTab.id, {
+      type: "system.info",
+      text: "(turn interrupted \u2014 sending new prompt)"
+    });
+    try {
+      await this.engine.stop(handle);
+    } finally {
+      this.handles.delete(key);
+      this.bumpRunState();
+    }
+    this.dispatchEvent(task.id, targetTab.id, { type: "done" });
+  }
+  async pauseTask(id) {
+    const task = this.requireTask(id);
+    if (task.status !== "in_progress") {
+      throw new IllegalTransitionError(task.status, "backlog", String(id));
+    }
+    await this.stopAllTabsForTask(task.id);
+    await this.store.update(task.id, { status: "backlog" });
+  }
+  async archiveTask(id, status) {
+    const task = this.requireTask(id);
+    if (status !== "done" && status !== "canceled") {
+      throw new IllegalTransitionError(task.status, status, String(id));
+    }
+    await this.stopAllTabsForTask(task.id);
+    await this.store.archive(task.id, status);
+  }
+  async setArchived(id, archived) {
+    const task = this.requireTask(id);
+    const next = archived ?? !task.archived;
+    if (task.archived === next)
+      return;
+    await this.store.update(task.id, { archived: next });
+  }
+  async setPermissionMode(id, mode) {
+    const task = this.requireTask(id);
+    if (task.permissionMode === mode)
+      return;
+    await this.store.update(task.id, { permissionMode: mode });
+  }
+  async setModel(id, model) {
+    const task = this.requireTask(id);
+    if (task.model === model)
+      return;
+    await this.store.update(task.id, { model });
+  }
+  async setTitle(id, title) {
+    const task = this.requireTask(id);
+    const trimmed = typeof title === "string" ? title.trim() : "";
+    if (trimmed.length === 0) {
+      throw new Error("setTitle: title is required (empty or whitespace-only rejected)");
+    }
+    if (task.title === trimmed)
+      return;
+    await this.store.update(task.id, { title: trimmed });
+  }
+  async setPinned(id, pinned) {
+    const task = this.requireTask(id);
+    if (task.kind === "main")
+      return;
+    const next = pinned ?? !task.pinned;
+    if ((task.pinned ?? false) === next)
+      return;
+    await this.store.update(task.id, { pinned: next });
+  }
+  async setTabTitle(id, tabId, title) {
+    const task = this.requireTask(id);
+    const trimmed = typeof title === "string" ? title.trim() : "";
+    if (trimmed.length === 0) {
+      throw new Error("setTabTitle: title is required (empty or whitespace-only rejected)");
+    }
+    const idx = task.tabs.findIndex((t) => t.id === tabId);
+    if (idx < 0) {
+      throw new Error(`setTabTitle: tab ${tabId} not found on task ${task.id}`);
+    }
+    const current = task.tabs[idx];
+    if (!current)
+      return;
+    if (current.title === trimmed)
+      return;
+    const nextTabs = task.tabs.map((t) => t.id === tabId ? { ...t, title: trimmed } : t);
+    await this.store.update(task.id, { tabs: nextTabs });
+  }
+  async deleteTask(id) {
+    const task = this.store.get(id);
+    if (!task)
+      return;
+    if (task.kind === "main") {
+      throw new CannotDeleteMainTaskError;
+    }
+    if (task.status === "in_progress") {
+      try {
+        await this.pauseTask(task.id);
+      } catch (err) {
+        console.error(`[kobe orchestrator] deleteTask: pauseTask failed for ${task.id}:`, err);
+        this.handles.delete(task.id);
+        this.bumpRunState();
+      }
+    }
+    if (task.worktreePath) {
+      try {
+        await this.worktrees.remove(task.worktreePath, { force: true });
+      } catch (err) {
+        console.error(`[kobe orchestrator] deleteTask: worktree remove failed for ${task.id}:`, err);
+      }
+    }
+    if (task.sessionId) {
+      try {
+        await this.engine.deleteHistory(task.sessionId);
+      } catch (err) {
+        console.error(`[kobe orchestrator] deleteTask: deleteHistory failed for ${task.id}:`, err);
+      }
+    }
+    this.pendingInputBroker.clearForTask(task.id);
+    await this.store.remove(task.id);
+  }
+  async readHistory(sessionId) {
+    try {
+      return await this.engine.readHistory(sessionId);
+    } catch {
+      return [];
+    }
+  }
+  async listSessions(id) {
+    const task = this.requireTask(id);
+    if (!task.worktreePath)
+      return [];
+    try {
+      return await this.engine.listSessions(task.worktreePath);
+    } catch {
+      return [];
+    }
+  }
+  async openSessionInTab(id, sessionId, opts = {}) {
+    const task = this.requireTask(id);
+    const existing = task.tabs.find((t) => t.sessionId === sessionId);
+    if (existing) {
+      await this.setActiveTab(task.id, existing.id);
+      return existing.id;
+    }
+    const tab = {
+      id: ulid(),
+      sessionId,
+      seq: nextChatTabSeq(task.tabs),
+      createdAt: new Date().toISOString(),
+      ...opts.title ? { title: opts.title } : {}
+    };
+    await this.store.update(task.id, { tabs: [...task.tabs, tab], activeTabId: tab.id });
+    return tab.id;
+  }
+  subscribeEvents(id, cb, tabId) {
+    const task = this.store.get(id);
+    const taskId = task?.id ?? id;
+    const resolvedTabId = tabId ?? task?.activeTabId ?? String(taskId);
+    const key = tabKey(taskId, resolvedTabId);
+    let set = this.subscribers.get(key);
+    if (!set) {
+      set = new Set;
+      this.subscribers.set(key, set);
+    }
+    set.add(cb);
+    return () => {
+      const cur = this.subscribers.get(key);
+      if (!cur)
+        return;
+      cur.delete(cb);
+      if (cur.size === 0)
+        this.subscribers.delete(key);
+    };
+  }
+  async createTab(id, opts = {}) {
+    const task = this.requireTask(id);
+    const tab = {
+      id: ulid(),
+      sessionId: null,
+      seq: nextChatTabSeq(task.tabs),
+      createdAt: new Date().toISOString(),
+      ...opts.title ? { title: opts.title } : {}
+    };
+    const tabs = [...task.tabs, tab];
+    await this.store.update(task.id, { tabs });
+    return tab;
+  }
+  async closeTab(id, tabId) {
+    const task = this.requireTask(id);
+    if (task.tabs.length <= 1) {
+      throw new Error(`closeTab: refusing to close the last tab on task ${task.id}`);
+    }
+    const idx = task.tabs.findIndex((t) => t.id === tabId);
+    if (idx < 0) {
+      throw new Error(`closeTab: tab ${tabId} not found on task ${task.id}`);
+    }
+    await this.stopTab(task.id, tabId);
+    const remaining = task.tabs.filter((t) => t.id !== tabId);
+    let nextActive = task.activeTabId;
+    if (task.activeTabId === tabId) {
+      const prevIdx = Math.max(0, idx - 1);
+      nextActive = remaining[prevIdx]?.id ?? remaining[0]?.id ?? "";
+    }
+    await this.store.update(task.id, { tabs: remaining, activeTabId: nextActive });
+    return nextActive;
+  }
+  async setActiveTab(id, tabId) {
+    const task = this.requireTask(id);
+    if (!task.tabs.some((t) => t.id === tabId)) {
+      throw new Error(`setActiveTab: tab ${tabId} not found on task ${task.id}`);
+    }
+    if (task.activeTabId === tabId)
+      return;
+    await this.store.update(task.id, { activeTabId: tabId });
+  }
+  async _waitForPumpsIdle() {
+    const pumps = Array.from(this.pumps.values());
+    await Promise.allSettled(pumps);
+  }
+  requireTask(id) {
+    const task = this.store.get(id);
+    if (!task)
+      throw new TaskNotFoundError(String(id));
+    return task;
+  }
+  resolveTab(task, tabId) {
+    if (tabId) {
+      const found = task.tabs.find((t) => t.id === tabId);
+      if (!found)
+        throw new Error(`tab not found on task ${task.id}: ${tabId}`);
+      return found;
+    }
+    const active = task.tabs.find((t) => t.id === task.activeTabId) ?? task.tabs[0];
+    if (!active) {
+      throw new Error(`task ${task.id} has no tabs`);
+    }
+    return active;
+  }
+  async updateTab(taskId, tabId, patch) {
+    const cur = this.store.get(taskId);
+    if (!cur)
+      return;
+    const tabs = cur.tabs.map((t) => t.id === tabId ? { ...t, ...patch, id: t.id } : t);
+    await this.store.update(taskId, { tabs });
+  }
+  async stopTab(taskId, tabId) {
+    const key = tabKey(taskId, tabId);
+    const handle = this.handles.get(key);
+    if (!handle)
+      return;
+    try {
+      await this.engine.stop(handle);
+    } finally {
+      this.handles.delete(key);
+      this.bumpRunState();
+    }
+  }
+  async stopAllTabsForTask(taskId) {
+    const prefix = `${taskId}:`;
+    const keys = Array.from(this.handles.keys()).filter((k) => k.startsWith(prefix));
+    for (const key of keys) {
+      const handle = this.handles.get(key);
+      if (!handle)
+        continue;
+      try {
+        await this.engine.stop(handle);
+      } catch {}
+      this.handles.delete(key);
+    }
+    this.bumpRunState();
+  }
+  countRunning() {
+    return this.handles.size;
+  }
+  dispatchEvent(taskId, tabId, ev) {
+    const set = this.subscribers.get(tabKey(taskId, tabId));
+    if (!set)
+      return;
+    for (const cb of set) {
+      try {
+        cb(ev);
+      } catch (err) {
+        console.error("[kobe orchestrator] subscriber threw:", err);
+      }
+    }
+  }
+  async runPumpAndCleanup(taskId, tabId, handle) {
+    const key = tabKey(taskId, tabId);
+    const { terminalEvent, killedForInput } = await this.sessionPump.run(taskId, tabId, handle);
+    this.handles.delete(key);
+    this.pumps.delete(key);
+    this.bumpRunState();
+    const terminal = terminalEvent?.type === "error" ? "error" : terminalEvent ? "done" : null;
+    if (terminal && !killedForInput) {
+      const stillLive = Array.from(this.handles.keys()).some((k) => k.startsWith(`${taskId}:`));
+      if (!stillLive) {
+        try {
+          await this.store.update(taskId, { status: terminal === "done" ? "done" : "error" });
+        } catch {}
+      }
+    }
+    if (terminalEvent && !killedForInput) {
+      this.dispatchEvent(taskId, tabId, terminalEvent);
+    }
+  }
+}
+function detectUserInputFromEngineEvent(ev) {
+  if (ev.type !== "tool.start")
+    return null;
+  if (ev.name === "ExitPlanMode" || ev.name === "ExitPlanModeV2Tool") {
+    const input = ev.input;
+    if (!input || typeof input !== "object")
+      return null;
+    const obj = input;
+    const plan = typeof obj.plan === "string" ? obj.plan : "";
+    const filePath = typeof obj.filePath === "string" ? obj.filePath : null;
+    return { kind: "approve_plan", plan, filePath };
+  }
+  if (ev.name === "AskUserQuestion") {
+    return parseAskUserQuestionInput(ev.input);
+  }
+  return null;
+}
+function parseAskUserQuestionInput(input) {
+  if (!input || typeof input !== "object")
+    return null;
+  const obj = input;
+  if (!Array.isArray(obj.questions))
+    return null;
+  const out = [];
+  for (const q of obj.questions) {
+    if (!q || typeof q !== "object")
+      continue;
+    const qo = q;
+    const question = typeof qo.question === "string" ? qo.question : "";
+    if (!question)
+      continue;
+    const header = typeof qo.header === "string" ? qo.header : "";
+    const multiSelect = qo.multiSelect === true;
+    const opts = Array.isArray(qo.options) ? qo.options : [];
+    const options = [];
+    for (const o of opts) {
+      if (!o || typeof o !== "object")
+        continue;
+      const oo = o;
+      const label = typeof oo.label === "string" ? oo.label : "";
+      if (!label)
+        continue;
+      const description = typeof oo.description === "string" ? oo.description : "";
+      options.push({ label, description });
+    }
+    if (options.length === 0)
+      continue;
+    out.push({ question, header, multiSelect, options });
+  }
+  if (out.length === 0)
+    return null;
+  return { kind: "ask_question", questions: out };
+}
+function renderUserInputResponsePrompt(req, response) {
+  if (req.kind === "approve_plan" && response.kind === "approve_plan") {
+    if (response.approve) {
+      return "Plan approved. Please proceed with the implementation as outlined.";
+    }
+    return "Plan rejected. Please reconsider the approach and present a revised plan.";
+  }
+  if (req.kind === "ask_question" && response.kind === "ask_question") {
+    const lines = ["You asked:"];
+    for (const q of req.questions) {
+      const ans = response.answers[q.question];
+      lines.push(`- ${q.question} \u2192 ${ans && ans.length > 0 ? ans : "(no answer)"}`);
+    }
+    lines.push("", "Please continue.");
+    return lines.join(`
+`);
+  }
+  return "";
+}
+function deriveTitleFromPrompt(prompt) {
+  if (typeof prompt !== "string")
+    return "";
+  const collapsed = prompt.replace(/\s+/g, " ").trim();
+  if (collapsed.length === 0)
+    return "";
+  if (collapsed.length <= TITLE_CHAR_CAP)
+    return collapsed;
+  return `${collapsed.slice(0, TITLE_CHAR_CAP)}\u2026`;
+}
+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_repos();
+  init_ulid();
+  init_metadata_suggester();
+  init_pr();
+  init_session_pump();
+  IllegalTransitionError = class IllegalTransitionError extends Error {
+    from;
+    to;
+    taskId;
+    constructor(from, to, taskId) {
+      super(`illegal transition for task ${taskId}: ${from} -> ${to}`);
+      this.from = from;
+      this.to = to;
+      this.taskId = taskId;
+      this.name = "IllegalTransitionError";
+    }
+  };
+  ConcurrencyCapError = class ConcurrencyCapError extends Error {
+    constructor() {
+      super(`concurrency cap reached: ${CONCURRENCY_CAP} tasks running`);
+      this.name = "ConcurrencyCapError";
+    }
+  };
+  PRPreconditionError = class PRPreconditionError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "PRPreconditionError";
+    }
+  };
+  TaskNotFoundError = class TaskNotFoundError extends Error {
+    constructor(taskId) {
+      super(`task not found: ${taskId}`);
+      this.name = "TaskNotFoundError";
+    }
+  };
+  CannotDeleteMainTaskError = class CannotDeleteMainTaskError extends Error {
+    constructor() {
+      super("cannot delete a main task; remove the repo from saved repos instead");
+      this.name = "CannotDeleteMainTaskError";
+    }
+  };
+});
+
+// src/orchestrator/index/store.ts
+import { mkdir as mkdir2, open, readFile as readFile3, rename, unlink as unlink3 } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname3, join as join4 } from "path";
+
+class TaskIndexStore {
+  homeDir;
+  kobeDir;
+  path;
+  tmpPath;
+  cache = { version: 2, tasks: [] };
+  loaded = false;
+  listeners = new Set;
+  saveChain = Promise.resolve();
+  constructor(options = {}) {
+    this.homeDir = options.homeDir ?? homedir7();
+    this.kobeDir = join4(this.homeDir, ".kobe");
+    this.path = join4(this.kobeDir, "tasks.json");
+    this.tmpPath = `${this.path}.tmp`;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (this.loaded) {
+      try {
+        listener(this.cache.tasks.slice());
+      } catch (err) {
+        console.error("[kobe TaskIndexStore] listener threw on subscribe:", err);
+      }
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  get filePath() {
+    return this.path;
+  }
+  get stateDir() {
+    return this.kobeDir;
+  }
+  async load() {
+    let raw;
+    try {
+      raw = await readFile3(this.path, "utf8");
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") {
+        this.cache = { version: 2, tasks: [] };
+        this.loaded = true;
+        this.notifyListeners();
+        return this.snapshot();
+      }
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      console.warn(`[kobe] tasks.json at ${this.path} is corrupted (${err.message}); recovering with empty index. The stale file is left in place.`);
+      this.cache = { version: 2, tasks: [] };
+      this.loaded = true;
+      this.notifyListeners();
+      return this.snapshot();
+    }
+    this.cache = normalizeIndex(parsed, this.path);
+    this.loaded = true;
+    this.notifyListeners();
+    return this.snapshot();
+  }
+  async save() {
+    this.assertLoaded();
+    const next = this.saveChain.then(() => this.doSave());
+    this.saveChain = next.catch(() => {});
+    return next;
+  }
+  async doSave() {
+    await mkdir2(dirname3(this.path), { recursive: true });
+    const payload = this.snapshot();
+    const json = `${JSON.stringify(payload, null, 2)}
+`;
+    const handle = await open(this.tmpPath, "w", 420);
+    try {
+      await handle.writeFile(json, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(this.tmpPath, this.path);
+  }
+  get(id) {
+    this.assertLoaded();
+    return this.cache.tasks.find((t) => t.id === id);
+  }
+  list() {
+    this.assertLoaded();
+    return this.cache.tasks.slice();
+  }
+  async create(partial) {
+    this.assertLoaded();
+    const now = new Date().toISOString();
+    const { tabs: tabsIn, activeTabId: activeIn, sessionId, ...rest } = partial;
+    let tabs;
+    let activeTabId;
+    if (tabsIn && tabsIn.length > 0) {
+      tabs = tabsIn;
+      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 }];
+      activeTabId = tabId;
+    }
+    const firstSession = tabs[0]?.sessionId ?? null;
+    const task = {
+      archived: false,
+      ...rest,
+      sessionId: firstSession,
+      tabs,
+      activeTabId,
+      id: toTaskId(ulid()),
+      createdAt: now,
+      updatedAt: now
+    };
+    this.cache.tasks.push(task);
+    await this.save();
+    this.notifyListeners();
+    return task;
+  }
+  async update(id, patch) {
+    this.assertLoaded();
+    const idx = this.cache.tasks.findIndex((t) => t.id === id);
+    if (idx < 0) {
+      throw new Error(`task not found: ${id}`);
+    }
+    const existing = this.cache.tasks[idx];
+    if (!existing) {
+      throw new Error(`task not found: ${id}`);
+    }
+    const { id: _ignoredId, createdAt: _ignoredCreatedAt, ...mutable } = patch;
+    const sessionIdPatched = "sessionId" in patch;
+    const tabsPatched = "tabs" in patch;
+    let mergedTabs = "tabs" in mutable && Array.isArray(mutable.tabs) ? mutable.tabs : existing.tabs;
+    if (sessionIdPatched && !tabsPatched) {
+      const newSessionId = patch.sessionId ?? null;
+      const activeId = mutable.activeTabId ?? existing.activeTabId;
+      mergedTabs = mergedTabs.map((t) => t.id === activeId ? { ...t, sessionId: newSessionId } : t);
+    }
+    const merged = {
+      ...existing,
+      ...mutable,
+      tabs: mergedTabs,
+      id: existing.id,
+      createdAt: existing.createdAt,
+      updatedAt: new Date().toISOString()
+    };
+    const activeTab = merged.tabs.find((t) => t.id === merged.activeTabId) ?? merged.tabs[0];
+    const next = activeTab && activeTab.sessionId !== merged.sessionId ? { ...merged, sessionId: activeTab.sessionId } : merged;
+    this.cache.tasks[idx] = next;
+    await this.save();
+    this.notifyListeners();
+    return next;
+  }
+  async archive(id, status = "done") {
+    return this.update(id, { status });
+  }
+  async remove(id) {
+    this.assertLoaded();
+    const idx = this.cache.tasks.findIndex((t) => t.id === id);
+    if (idx < 0)
+      return;
+    this.cache.tasks.splice(idx, 1);
+    await this.save();
+    this.notifyListeners();
+  }
+  async _unlinkForTests() {
+    try {
+      await unlink3(this.path);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+    }
+    try {
+      await unlink3(this.tmpPath);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+    }
+    this.cache = { version: 2, tasks: [] };
+    this.loaded = false;
+  }
+  assertLoaded() {
+    if (!this.loaded) {
+      throw new Error("TaskIndexStore: call load() before any other method");
+    }
+  }
+  snapshot() {
+    return {
+      version: 2,
+      tasks: this.cache.tasks.slice()
+    };
+  }
+  notifyListeners() {
+    if (this.listeners.size === 0)
+      return;
+    const snapshot = this.cache.tasks.slice();
+    for (const listener of this.listeners) {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error("[kobe TaskIndexStore] listener threw on notify:", err);
+      }
+    }
+  }
+}
+function normalizeIndex(parsed, source) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    console.warn(`[kobe] tasks.json at ${source} is not an object; recovering with empty index.`);
+    return { version: 2, tasks: [] };
+  }
+  const obj = parsed;
+  const version = obj.version;
+  if (version !== undefined && version !== 1 && version !== 2) {
+    console.warn(`[kobe] tasks.json at ${source} has unsupported version=${String(version)}; recovering with empty index.`);
+    return { version: 2, tasks: [] };
+  }
+  const rawTasks = Array.isArray(obj.tasks) ? obj.tasks : [];
+  const tasks = [];
+  for (const entry of rawTasks) {
+    const task = coerceTask(entry);
+    if (task)
+      tasks.push(task);
+    else {
+      console.warn(`[kobe] dropping malformed task entry from ${source}: ${JSON.stringify(entry)}`);
+    }
+  }
+  return { version: 2, tasks };
+}
+function coerceTask(value) {
+  if (!value || typeof value !== "object")
+    return null;
+  const v = value;
+  if (typeof v.id !== "string" || typeof v.title !== "string" || typeof v.repo !== "string" || typeof v.branch !== "string" || typeof v.worktreePath !== "string" || !(v.sessionId === null || typeof v.sessionId === "string" || v.sessionId === undefined) || typeof v.status !== "string" || typeof v.createdAt !== "string" || typeof v.updatedAt !== "string") {
+    return null;
+  }
+  if (!isTaskStatus(v.status))
+    return null;
+  const legacySessionId = (v.sessionId === undefined ? null : v.sessionId) ?? null;
+  const rawTabs = Array.isArray(v.tabs) ? v.tabs : null;
+  let tabs = null;
+  if (rawTabs) {
+    tabs = [];
+    let nextSeqForMissing = 1;
+    for (const t of rawTabs) {
+      if (!t || typeof t !== "object")
+        continue;
+      const tt = t;
+      if (typeof tt.id !== "string")
+        continue;
+      if (!(tt.sessionId === null || typeof tt.sessionId === "string"))
+        continue;
+      if (typeof tt.createdAt !== "string")
+        continue;
+      const persistedSeq = typeof tt.seq === "number" && Number.isFinite(tt.seq) && tt.seq > 0 ? tt.seq : null;
+      const seq = persistedSeq ?? nextSeqForMissing++;
+      if (persistedSeq !== null && persistedSeq >= nextSeqForMissing) {
+        nextSeqForMissing = persistedSeq + 1;
+      }
+      const tab = {
+        id: tt.id,
+        sessionId: tt.sessionId ?? null,
+        seq,
+        createdAt: tt.createdAt,
+        ...typeof tt.title === "string" ? { title: tt.title } : {}
+      };
+      tabs.push(tab);
+    }
+  }
+  let finalTabs;
+  let finalActive;
+  if (tabs && tabs.length > 0) {
+    finalTabs = tabs;
+    const persisted = typeof v.activeTabId === "string" ? v.activeTabId : null;
+    finalActive = persisted && tabs.some((t) => t.id === persisted) ? persisted : tabs[0]?.id ?? "";
+  } else {
+    const synthesizedId = ulid();
+    finalTabs = [{ id: synthesizedId, sessionId: legacySessionId, seq: 1, createdAt: v.createdAt }];
+    finalActive = synthesizedId;
+  }
+  const activeTab = finalTabs.find((t) => t.id === finalActive) ?? finalTabs[0];
+  const aliasSessionId = activeTab?.sessionId ?? legacySessionId;
+  return {
+    id: toTaskId(v.id),
+    title: v.title,
+    repo: v.repo,
+    branch: v.branch,
+    worktreePath: v.worktreePath,
+    sessionId: aliasSessionId,
+    tabs: finalTabs,
+    activeTabId: finalActive,
+    status: v.status,
+    archived: typeof v.archived === "boolean" ? v.archived : false,
+    pinned: typeof v.pinned === "boolean" ? v.pinned : false,
+    kind: v.kind === "main" ? "main" : "task",
+    permissionMode: isPermissionMode(v.permissionMode) ? v.permissionMode : undefined,
+    model: typeof v.model === "string" ? v.model : undefined,
+    createdAt: v.createdAt,
+    updatedAt: v.updatedAt
+  };
+}
+function isPermissionMode(v) {
+  return v === "default" || v === "plan";
+}
+function isTaskStatus(s) {
+  return s === "backlog" || s === "in_progress" || s === "in_review" || s === "done" || s === "canceled" || s === "error";
+}
+var init_store = __esm(() => {
+  init_ulid();
+});
+
+// src/orchestrator/worktree/git.ts
+import { spawnSync as spawnSync4 } 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], {
+    cwd: opts.cwd,
+    env: opts.env ? { ...process.env, ...opts.env } : process.env,
+    encoding: "utf8",
+    shell: false
+  });
+  const result = {
+    stdout: proc.stdout ?? "",
+    stderr: proc.stderr ?? "",
+    exitCode: proc.status ?? -1
+  };
+  if (result.exitCode !== 0 && !opts.allowFail) {
+    throw new GitCommandError(args, opts.cwd, result);
+  }
+  return result;
+}
+var GitCommandError;
+var init_git = __esm(() => {
+  GitCommandError = class GitCommandError extends Error {
+    args;
+    cwd;
+    exitCode;
+    stdout;
+    stderr;
+    constructor(args, cwd, result) {
+      super(`git ${args.join(" ")} (cwd=${cwd}) exited with code ${result.exitCode}: ${result.stderr.trim() || result.stdout.trim()}`);
+      this.name = "GitCommandError";
+      this.args = args;
+      this.cwd = cwd;
+      this.exitCode = result.exitCode;
+      this.stdout = result.stdout;
+      this.stderr = result.stderr;
+    }
+  };
+});
+
+// src/orchestrator/worktree/paths.ts
+import fs2 from "fs";
+import path5 from "path";
+function worktreeRootFor(repo) {
+  if (!path5.isAbsolute(repo)) {
+    throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
+  }
+  return path5.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
+}
+function worktreePathFor(repo, taskId) {
+  if (!taskId || /[/\\\0]/.test(taskId)) {
+    throw new Error(`worktreePathFor: invalid taskId: ${JSON.stringify(taskId)}`);
+  }
+  return path5.join(worktreeRootFor(repo), taskId);
+}
+function isKobeManagedPath(repo, candidate) {
+  if (!path5.isAbsolute(repo) || !path5.isAbsolute(candidate))
+    return false;
+  const root = canonicalize(worktreeRootFor(repo));
+  const target = canonicalize(candidate);
+  const rel = path5.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path5.isAbsolute(rel);
+}
+function canonicalize(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return path5.resolve(p);
+  }
+}
+var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
+var init_paths = () => {};
+
+// src/orchestrator/worktree/manager.ts
+import fs3 from "fs";
+import path6 from "path";
+
+class GitWorktreeManager {
+  async create(repo, branch, worktreePath, baseRef) {
+    requireAbsolute("repo", repo);
+    requireAbsolute("path", worktreePath);
+    if (!branch)
+      throw new Error("create(): branch must be a non-empty string");
+    if (fs3.existsSync(worktreePath)) {
+      const existing = await this.tryDescribe(repo, worktreePath);
+      if (existing) {
+        if (existing.branch !== branch) {
+          throw new Error(`worktree at ${worktreePath} is on branch '${existing.branch}', refusing to hijack to '${branch}'`);
+        }
+        return existing;
+      }
+      throw new Error(`create(): ${worktreePath} exists but is not a registered git worktree`);
+    }
+    fs3.mkdirSync(path6.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 });
+    const info = await this.tryDescribe(repo, worktreePath);
+    if (!info) {
+      throw new Error(`create(): git reported success but ${worktreePath} is not a worktree`);
+    }
+    if (info.branch !== branch) {
+      throw new Error(`create(): post-condition failed \u2014 expected branch '${branch}' at ${worktreePath}, got '${info.branch}'`);
+    }
+    return info;
+  }
+  async createForTask(args) {
+    const target = worktreePathFor(args.repo, args.taskId);
+    return this.create(args.repo, args.branch, target, args.baseRef);
+  }
+  async remove(worktreePath, opts) {
+    requireAbsolute("path", worktreePath);
+    const force = opts?.force === true;
+    if (!fs3.existsSync(worktreePath)) {
+      const repo2 = this.findRepoFor(worktreePath);
+      if (repo2)
+        git2(["worktree", "prune"], { cwd: repo2, allowFail: true });
+      return;
+    }
+    const repo = this.findRepoFor(worktreePath);
+    if (!repo) {
+      throw new Error(`remove(): ${worktreePath} is not a git worktree`);
+    }
+    if (!force) {
+      const dirty = await this.isDirty(worktreePath);
+      if (dirty) {
+        throw new Error(`remove(): refusing to remove dirty worktree at ${worktreePath} (pass { force: true } to override)`);
+      }
+    }
+    const args = force ? ["worktree", "remove", "--force", worktreePath] : ["worktree", "remove", worktreePath];
+    git2(args, { cwd: repo });
+    git2(["worktree", "prune"], { cwd: repo, allowFail: true });
+  }
+  async list(repo) {
+    requireAbsolute("repo", repo);
+    const out = git2(["worktree", "list", "--porcelain"], { cwd: repo });
+    const all = parsePorcelain(out.stdout);
+    const callerRoot = worktreeRootFor(repo);
+    const canonRoot = canonicalize2(callerRoot);
+    const infos = [];
+    for (const entry of all) {
+      if (!entry.path)
+        continue;
+      if (!isKobeManagedPath(repo, entry.path))
+        continue;
+      if (!entry.branch || entry.detached)
+        continue;
+      const canonEntry = canonicalize2(entry.path);
+      const rel = path6.relative(canonRoot, canonEntry);
+      const callerPath = path6.join(callerRoot, rel);
+      const dirty = await this.isDirty(entry.path);
+      infos.push({
+        path: callerPath,
+        branch: entry.branch,
+        head: entry.head ?? "",
+        dirty
+      });
+    }
+    return infos;
+  }
+  async isDirty(worktreePath) {
+    requireAbsolute("path", worktreePath);
+    const out = git2(["status", "--porcelain"], { cwd: worktreePath });
+    return out.stdout.length > 0;
+  }
+  async currentBranch(worktreePath) {
+    requireAbsolute("path", worktreePath);
+    const out = git2(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: worktreePath });
+    const name = out.stdout.trim();
+    if (!name || name === "HEAD") {
+      throw new Error(`currentBranch(): ${worktreePath} is in detached-HEAD state`);
+    }
+    return name;
+  }
+  async renameBranch(worktreePath, from, to) {
+    requireAbsolute("path", worktreePath);
+    if (from === to)
+      return;
+    const repo = this.findRepoFor(worktreePath);
+    if (!repo)
+      throw new Error(`renameBranch(): ${worktreePath} is not a git worktree`);
+    git2(["branch", "-m", from, to], { cwd: repo });
+  }
+  async tryDescribe(repo, worktreePath) {
+    const out = git2(["worktree", "list", "--porcelain"], { cwd: repo });
+    const entries = parsePorcelain(out.stdout);
+    const target = canonicalize2(worktreePath);
+    const match = entries.find((e) => e.path && canonicalize2(e.path) === target);
+    if (!match || !match.path || !match.branch || match.detached)
+      return null;
+    return {
+      path: worktreePath,
+      branch: match.branch,
+      head: match.head ?? "",
+      dirty: await this.isDirty(match.path)
+    };
+  }
+  branchExists(repo, branch) {
+    const ref = `refs/heads/${branch}`;
+    const out = git2(["show-ref", "--verify", "--quiet", ref], { cwd: repo, allowFail: true });
+    return out.exitCode === 0;
+  }
+  findRepoFor(worktreePath) {
+    try {
+      const out = git2(["rev-parse", "--git-common-dir"], { cwd: worktreePath, allowFail: true });
+      if (out.exitCode !== 0)
+        return null;
+      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;
+    } catch (err) {
+      if (err instanceof GitCommandError)
+        return null;
+      throw err;
+    }
+  }
+}
+function parsePorcelain(out) {
+  const records = [];
+  let current = null;
+  for (const rawLine of out.split(`
+`)) {
+    const line = rawLine.replace(/\r$/, "");
+    if (line === "") {
+      if (current)
+        records.push(current);
+      current = null;
+      continue;
+    }
+    if (!current)
+      current = {};
+    if (line.startsWith("worktree ")) {
+      current.path = line.slice("worktree ".length);
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
+    } else if (line.startsWith("branch ")) {
+      const ref = line.slice("branch ".length);
+      current.branch = ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
+    } else if (line === "detached") {
+      current.detached = true;
+    } else if (line === "bare") {
+      current.bare = true;
+    }
+  }
+  if (current)
+    records.push(current);
+  return records;
+}
+function requireAbsolute(name, value) {
+  if (!value || !path6.isAbsolute(value)) {
+    throw new Error(`${name} must be an absolute path, got: ${JSON.stringify(value)}`);
+  }
+}
+function canonicalize2(p) {
+  try {
+    return fs3.realpathSync(p);
+  } catch {
+    return path6.resolve(p);
+  }
+}
+var init_manager = __esm(() => {
+  init_git();
+  init_paths();
+});
+
+// src/daemon/paths.ts
+import { homedir as homedir9, tmpdir } from "os";
+import { join as join5 } from "path";
+function defaultDaemonSocketPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir9()) {
+  const runtimeDir = process.env.XDG_RUNTIME_DIR;
+  if (runtimeDir && runtimeDir.length > 0)
+    return join5(runtimeDir, "kobe.sock");
+  return join5(homeDir2, ".kobe", "daemon.sock");
+}
+function defaultDaemonPidPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir9()) {
+  return join5(homeDir2, ".kobe", "daemon.pid");
+}
+var init_paths2 = () => {};
+
+// src/bin/kobed.ts
+init_client();
+
+// src/core/index.ts
+init_claude_code_local();
+init_bridge();
+init_core();
+init_store();
+init_manager();
+import { homedir as homedir8 } from "os";
+async function createKobeCore(options = {}) {
+  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir8();
+  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 bridge = options.startMcpBridge === false ? null : await startBridge(orchestrator, { homeDir: homeDir2 });
+  return {
+    homeDir: homeDir2,
+    orchestrator,
+    store,
+    worktrees,
+    bridge,
+    async close() {
+      await bridge?.close();
+      orchestrator.dispose();
+    }
+  };
+}
+
+// src/bin/kobed.ts
+init_paths2();
+
+// src/daemon/server.ts
+init_paths2();
+import { mkdir as mkdir3, readFile as readFile4, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { createServer as createServer2 } from "net";
+import { dirname as dirname4 } from "path";
+async function startDaemonServer(orch, options = {}) {
+  const socketPath = options.socketPath ?? defaultDaemonSocketPath(options.homeDir);
+  const pidPath = options.pidPath ?? defaultDaemonPidPath(options.homeDir);
+  const startedAt = options.startedAt ?? new Date;
+  const clients = new Set;
+  let nextClientId = 1;
+  await mkdir3(dirname4(socketPath), { recursive: true });
+  await mkdir3(dirname4(pidPath), { recursive: true });
+  await unlink4(socketPath).catch(() => {});
+  const server = createServer2((socket) => {
+    const client = {
+      id: nextClientId++,
+      connectedAt: new Date,
+      socket,
+      buffer: "",
+      subscriptions: new Map
+    };
+    clients.add(client);
+    socket.on("data", (chunk) => {
+      client.buffer += chunk.toString("utf8");
+      drainClientBuffer(orch, serverApi, client);
+    });
+    socket.on("error", () => {});
+    socket.on("close", () => {
+      for (const unsub of client.subscriptions.values())
+        unsub();
+      client.subscriptions.clear();
+      clients.delete(client);
+    });
+  });
+  const serverApi = {
+    socketPath,
+    pidPath,
+    startedAt,
+    clients,
+    async close() {
+      broadcast(clients, { type: "event", name: "daemon.stopping", payload: {} });
+      await new Promise((resolve) => server.close(() => resolve()));
+      for (const client of Array.from(clients)) {
+        for (const unsub of client.subscriptions.values())
+          unsub();
+        client.subscriptions.clear();
+        client.socket.end();
+      }
+      await unlink4(socketPath).catch(() => {});
+      await unlink4(pidPath).catch(() => {});
+    }
+  };
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socketPath, () => {
+      server.removeListener("error", reject);
+      resolve();
+    });
+  });
+  await writeFile3(pidPath, `${process.pid}
+`, "utf8");
+  async function stopSoon() {
+    await options.onStop?.();
+    setTimeout(() => {
+      serverApi.close();
+    }, 0).unref();
+  }
+  async function dispatch2(req, client) {
+    const payload = objectPayload(req.payload);
+    switch (req.name) {
+      case "hello": {
+        const tasks = orch.listTasks();
+        const pending = {};
+        for (const task of tasks) {
+          const entries = orch.peekPendingInput(task.id);
+          if (entries.length > 0)
+            pending[task.id] = entries;
+        }
+        const runState = {};
+        for (const [key, value] of orch.chatRunStateSignal()())
+          runState[key] = value;
+        return {
+          protocolVersion: DAEMON_PROTOCOL_VERSION,
+          daemonPid: process.pid,
+          clientId: client.id,
+          tasks: tasks.map(serializeTask),
+          pending,
+          runState
+        };
+      }
+      case "daemon.status":
+        return {
+          daemonPid: process.pid,
+          uptimeMs: Date.now() - startedAt.getTime(),
+          startedAt: startedAt.toISOString(),
+          attachedClients: clients.size,
+          taskCount: orch.listTasks().length,
+          socketPath
+        };
+      case "daemon.stop":
+        await stopSoon();
+        return {};
+      case "task.list":
+        return { tasks: orch.listTasks().map(serializeTask) };
+      case "task.spawn": {
+        const repo = requireString2(payload, "repo");
+        const task = await orch.createTask({
+          repo,
+          prompt: optionalString2(payload, "prompt"),
+          title: optionalString2(payload, "title"),
+          branch: optionalString2(payload, "branch"),
+          baseRef: optionalString2(payload, "baseRef")
+        });
+        for (const c of clients)
+          subscribeClientToTask(orch, c, task);
+        broadcast(clients, { type: "event", name: "task.created", payload: { task: serializeTask(task) } });
+        return { taskId: task.id, task: serializeTask(task) };
+      }
+      case "task.archive": {
+        const taskId = requireString2(payload, "taskId");
+        const archived = optionalBoolean(payload, "archived");
+        await orch.setArchived(taskId, archived);
+        const task = orch.getTask(taskId);
+        if (task)
+          broadcast(clients, { type: "event", name: "task.updated", payload: { taskId, task: serializeTask(task) } });
+        return {};
+      }
+      case "task.rename": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.setTitle(taskId, requireString2(payload, "title"));
+        const task = orch.getTask(taskId);
+        if (task)
+          broadcast(clients, { type: "event", name: "task.updated", payload: { taskId, task: serializeTask(task) } });
+        return {};
+      }
+      case "task.delete": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.deleteTask(taskId);
+        for (const c of clients)
+          unsubscribeClientFromTask(c, taskId);
+        broadcast(clients, { type: "event", name: "task.deleted", payload: { taskId } });
+        return {};
+      }
+      case "task.pin": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.setPinned(taskId, optionalBoolean(payload, "pinned"));
+        broadcastTaskUpdated(orch, clients, taskId);
+        return {};
+      }
+      case "task.permissionMode": {
+        const taskId = requireString2(payload, "taskId");
+        const mode = optionalString2(payload, "mode");
+        if (mode !== undefined && mode !== "default" && mode !== "plan")
+          throw new Error("mode must be default or plan");
+        await orch.setPermissionMode(taskId, mode);
+        broadcastTaskUpdated(orch, clients, taskId);
+        return {};
+      }
+      case "task.model": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.setModel(taskId, optionalString2(payload, "model"));
+        broadcastTaskUpdated(orch, clients, taskId);
+        return {};
+      }
+      case "task.ensureMain": {
+        const repo = requireString2(payload, "repo");
+        const prior = orch.listTasks().find((t) => t.kind === "main" && t.repo === repo);
+        const task = await orch.ensureMainTask(repo);
+        if (!prior) {
+          for (const c of clients)
+            subscribeClientToTask(orch, c, task);
+          broadcast(clients, { type: "event", name: "task.created", payload: { task: serializeTask(task) } });
+        } else if (prior.archived && !task.archived) {
+          broadcastTaskUpdated(orch, clients, task.id);
+        }
+        return { task: serializeTask(task) };
+      }
+      case "chat.tab.create": {
+        const taskId = requireString2(payload, "taskId");
+        const tab = await orch.createTab(taskId, { title: optionalString2(payload, "title") });
+        for (const c of clients)
+          subscribeClientToTab(orch, c, taskId, tab.id);
+        broadcastTaskUpdated(orch, clients, taskId);
+        return { tab };
+      }
+      case "chat.tab.close": {
+        const taskId = requireString2(payload, "taskId");
+        const nextActive = await orch.closeTab(taskId, requireString2(payload, "tabId"));
+        broadcastTaskUpdated(orch, clients, taskId);
+        return { nextActive };
+      }
+      case "chat.tab.activate": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.setActiveTab(taskId, requireString2(payload, "tabId"));
+        broadcastTaskUpdated(orch, clients, taskId);
+        return {};
+      }
+      case "chat.tab.rename": {
+        const taskId = requireString2(payload, "taskId");
+        await orch.setTabTitle(taskId, requireString2(payload, "tabId"), requireString2(payload, "title"));
+        broadcastTaskUpdated(orch, clients, taskId);
+        return {};
+      }
+      case "chat.sessions": {
+        const sessions = await orch.listSessions(requireString2(payload, "taskId"));
+        return { sessions };
+      }
+      case "chat.session.open": {
+        const taskId = requireString2(payload, "taskId");
+        const tabId = await orch.openSessionInTab(taskId, requireString2(payload, "sessionId"), {
+          title: optionalString2(payload, "title")
+        });
+        for (const c of clients)
+          subscribeClientToTab(orch, c, taskId, tabId);
+        broadcastTaskUpdated(orch, clients, taskId);
+        return { tabId };
+      }
+      case "chat.interrupt": {
+        await orch.interruptTask(requireString2(payload, "taskId"), optionalString2(payload, "tabId"));
+        return {};
+      }
+      case "chat.input.pending": {
+        return { pending: orch.peekPendingInput(requireString2(payload, "taskId")) };
+      }
+      case "chat.input.respond": {
+        await orch.respondToInput(requireString2(payload, "taskId"), requireString2(payload, "requestId"), requireUserInputResponse(payload.response));
+        return {};
+      }
+      case "pr.request": {
+        await orch.requestPR(requireString2(payload, "taskId"));
+        return {};
+      }
+      case "chat.history": {
+        const taskId = requireString2(payload, "taskId");
+        const sessionId = optionalString2(payload, "sessionId");
+        const limit = optionalNumber(payload, "limit") ?? 50;
+        const before = optionalString2(payload, "before");
+        const result = await readTaskHistory(orch, taskId, sessionId, limit, before);
+        return {
+          messages: serializeMessages(result.messages),
+          nextBefore: result.nextBefore,
+          hasMore: result.hasMore
+        };
+      }
+      case "chat.send": {
+        const taskId = requireString2(payload, "taskId");
+        const tabId = optionalString2(payload, "tabId");
+        const text = optionalString2(payload, "text");
+        await orch.runTask(taskId, text, tabId);
+        const task = orch.getTask(taskId);
+        if (task)
+          broadcast(clients, {
+            type: "event",
+            name: "engine.status",
+            payload: { taskId, tabId: tabId ?? task.activeTabId, status: "running" }
+          });
+        return {};
+      }
+      case "subscribe": {
+        const taskIds = normalizeTaskIds(payload.taskIds);
+        const tasks = taskIds === "all" ? orch.listTasks() : taskIds.map((id) => orch.getTask(id)).filter((t) => Boolean(t));
+        for (const task of tasks)
+          subscribeClientToTask(orch, client, task);
+        return {};
+      }
+      default:
+        throw new Error(`unknown daemon request: ${req.name}`);
+    }
+  }
+  async function handleRequest(req, client) {
+    try {
+      const payload = await dispatch2(req, client);
+      writeFrame(client, { type: "response", id: req.id, name: req.name, payload });
+    } catch (err) {
+      writeFrame(client, {
+        type: "response",
+        id: req.id,
+        name: req.name,
+        error: {
+          message: err instanceof Error ? err.message : String(err),
+          name: err instanceof Error ? err.name : undefined
+        }
+      });
+    }
+  }
+  function drainClientBuffer(orch2, _server, client) {
+    let nl = client.buffer.indexOf(`
+`);
+    while (nl !== -1) {
+      const line = client.buffer.slice(0, nl);
+      client.buffer = client.buffer.slice(nl + 1);
+      if (line.trim().length > 0) {
+        try {
+          const frame = JSON.parse(line);
+          if (frame.type !== "request")
+            throw new Error("daemon only accepts request frames from clients");
+          handleRequest(frame, client);
+        } catch (err) {
+          writeFrame(client, {
+            type: "response",
+            id: "parse-error",
+            error: { message: err instanceof Error ? err.message : String(err) }
+          });
+        }
+      }
+      nl = client.buffer.indexOf(`
+`);
+    }
+  }
+  return serverApi;
+}
+async function readPidFile(pidPath) {
+  try {
+    const raw = await readFile4(pidPath, "utf8");
+    const pid = Number(raw.trim());
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function subscribeClientToTask(orch, client, task) {
+  for (const tab of task.tabs)
+    subscribeClientToTab(orch, client, task.id, tab.id);
+}
+function subscribeClientToTab(orch, client, taskId, tabId) {
+  const key = `${taskId}:${tabId}`;
+  if (client.subscriptions.has(key))
+    return;
+  const unsub = orch.subscribeEvents(taskId, (ev) => writeFrame(client, normalizeEventForWire(taskId, tabId, ev)), tabId);
+  client.subscriptions.set(key, unsub);
+}
+function broadcastTaskUpdated(orch, clients, taskId) {
+  const task = orch.getTask(taskId);
+  if (!task)
+    return;
+  broadcast(clients, { type: "event", name: "task.updated", payload: { taskId, task: serializeTask(task) } });
+}
+function unsubscribeClientFromTask(client, taskId) {
+  const prefix = `${taskId}:`;
+  for (const [key, unsub] of client.subscriptions) {
+    if (!key.startsWith(prefix))
+      continue;
+    unsub();
+    client.subscriptions.delete(key);
+  }
+}
+async function readTaskHistory(orch, taskId, requestedSessionId, limit, before) {
+  const task = orch.getTask(taskId);
+  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 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);
+  const page = messages.slice(start, end);
+  const hasMore = start > 0;
+  const first = page[0];
+  const nextBefore = hasMore && first ? `${first.timestamp}:${first.sessionId}` : null;
+  return { messages: page, nextBefore, hasMore };
+}
+function writeFrame(client, frame) {
+  client.socket.write(frameToLine(frame));
+}
+function broadcast(clients, frame) {
+  for (const client of clients)
+    writeFrame(client, frame);
+}
+function objectPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return {};
+  return payload;
+}
+function requireString2(payload, key) {
+  const value = payload[key];
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`${key} is required`);
+  return value;
+}
+function optionalString2(payload, key) {
+  const value = payload[key];
+  if (value === undefined || value === null || value === "")
+    return;
+  if (typeof value !== "string")
+    throw new Error(`${key} must be a string`);
+  return value;
+}
+function optionalBoolean(payload, key) {
+  const value = payload[key];
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "boolean")
+    throw new Error(`${key} must be a boolean`);
+  return value;
+}
+function optionalNumber(payload, key) {
+  const value = payload[key];
+  if (value === undefined || value === null)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new Error(`${key} must be a number`);
+  return value;
+}
+function normalizeTaskIds(value) {
+  if (value === undefined || value === null || value === "all")
+    return "all";
+  if (Array.isArray(value) && value.every((v) => typeof v === "string"))
+    return value;
+  throw new Error("taskIds must be 'all' or string[]");
+}
+function requireUserInputResponse(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("response is required");
+  const obj = value;
+  if (obj.kind === "approve_plan") {
+    if (typeof obj.approve !== "boolean")
+      throw new Error("response.approve must be a boolean");
+    return { kind: "approve_plan", approve: obj.approve };
+  }
+  if (obj.kind === "ask_question") {
+    if (!obj.answers || typeof obj.answers !== "object" || Array.isArray(obj.answers)) {
+      throw new Error("response.answers must be an object");
+    }
+    const answers = {};
+    for (const [key, answer] of Object.entries(obj.answers)) {
+      if (typeof answer === "string")
+        answers[key] = answer;
+    }
+    return { kind: "ask_question", answers };
+  }
+  throw new Error("response.kind must be approve_plan or ask_question");
+}
+
+// src/bin/kobed.ts
+async function main() {
+  const [, , command = "status"] = process.argv;
+  const socketPath = defaultDaemonSocketPath();
+  const pidPath = defaultDaemonPidPath();
+  if (command === "status") {
+    const client = new KobeDaemonClient(socketPath);
+    try {
+      const status = await client.request("daemon.status");
+      console.log(JSON.stringify(status, null, 2));
+    } catch {
+      const pid = await readPidFile(pidPath);
+      if (pid)
+        console.log(`kobed: no daemon socket at ${socketPath} (stale pidfile pid=${pid})`);
+      else
+        console.log(`kobed: no daemon running at ${socketPath}`);
+      process.exitCode = 1;
+    } finally {
+      client.close();
+    }
+    return;
+  }
+  if (command === "stop") {
+    const client = new KobeDaemonClient(socketPath);
+    try {
+      await client.request("daemon.stop");
+      console.log("kobed: stop requested");
+    } finally {
+      client.close();
+    }
+    return;
+  }
+  if (command === "restart") {
+    const oldPid = await readPidFile(pidPath);
+    const client = new KobeDaemonClient(socketPath);
+    try {
+      await client.request("daemon.stop");
+    } catch {} finally {
+      client.close();
+    }
+    if (oldPid && oldPid !== process.pid) {
+      const deadline = Date.now() + 5000;
+      while (Date.now() < deadline) {
+        try {
+          process.kill(oldPid, 0);
+          await new Promise((resolve) => setTimeout(resolve, 25));
+        } catch {
+          break;
+        }
+      }
+    }
+  } else if (command !== "start") {
+    console.error("usage: kobed start|stop|status|restart");
+    process.exit(2);
+  }
+  const core = await createKobeCore();
+  const server = await startDaemonServer(core.orchestrator, {
+    socketPath,
+    pidPath,
+    homeDir: core.homeDir,
+    onStop: async () => {
+      await core.close();
+    }
+  });
+  console.log(`kobed: listening on ${server.socketPath}`);
+  const shutdown = async () => {
+    await server.close();
+    await core.close();
+    process.exit(0);
+  };
+  process.once("SIGINT", () => void shutdown());
+  process.once("SIGTERM", () => void shutdown());
+}
+main().catch((err) => {
+  console.error("kobed failed:", err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});