@sma1lboy/kobe 0.7.2 → 0.7.4

package/dist/cli/index.js

@@ -70,7 +70,7 @@ var init_package = __esm(() => {
   package_default = {
     $schema: "https://json.schemastore.org/package.json",
     name: "@sma1lboy/kobe",
-    version: "0.7.2",
+    version: "0.7.4",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -2325,6 +2325,248 @@ var init_dev = __esm(() => {
   }
 });
 
+// src/cli/invocation.ts
+import { fileURLToPath } from "url";
+function kobeCliInvocation() {
+  const isBuilt = import.meta.url.endsWith(".js");
+  if (isBuilt)
+    return ["kobe"];
+  const entry = fileURLToPath(new URL("./index.ts", import.meta.url));
+  const preload = fileURLToPath(import.meta.resolve("@opentui/solid/preload"));
+  return [process.execPath, "--preload", preload, "--conditions=browser", entry];
+}
+var init_invocation = () => {};
+
+// src/tmux/session-layout.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function shellQuoteArgv(argv) {
+  return argv.map(shellQuote).join(" ");
+}
+function keepAlive(cmd) {
+  return `${cmd}; exec "\${SHELL:-/bin/sh}"`;
+}
+function shQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function homeWelcomeCommand() {
+  const msg = "\\n  No task selected\\n\\n  Press N to create a task, or pick one on the left.\\n\\n";
+  return `clear; printf ${shQuote(msg)}; exec "\${SHELL:-/bin/sh}"`;
+}
+function engineLaunchLine(engineCmd, init) {
+  const tail = keepAlive(engineCmd);
+  const script = init?.initScript?.trim();
+  if (!script)
+    return tail;
+  const group = ["{", script, "}"].join(`
+`);
+  if (init?.markerPath) {
+    const marker = shQuote(init.markerPath);
+    const markerDir = shQuote(markerDirOf(init.markerPath));
+    return [
+      `if [ ! -f ${marker} ]; then`,
+      group,
+      `if [ $? -eq 0 ]; then mkdir -p ${markerDir} && : > ${marker}; fi`,
+      "fi",
+      tail
+    ].join(`
+`);
+  }
+  return [group, tail].join(`
+`);
+}
+function markerDirOf(p) {
+  const i = p.lastIndexOf("/");
+  return i <= 0 ? "." : p.slice(0, i);
+}
+function fallbackOpsScript(cwd) {
+  return `cd ${shellQuote(cwd)} && while :; do   clear;   printf "\\033[1m# %s\\033[0m\\n\\n" ${shellQuote(cwd)};   git status --short --branch 2>/dev/null | sed 's/^/  /' || true;   printf "\\n";   if command -v lsd >/dev/null 2>&1; then     lsd --tree --git -I node_modules -I .git --depth 2 .;   elif command -v eza >/dev/null 2>&1; then     eza --tree --git -L 2 -I 'node_modules|.git' .;   elif command -v tree >/dev/null 2>&1; then     tree -L 2 -I 'node_modules|.git';   else     ls -la;   fi;   sleep 2; done`;
+}
+function previewWindowCommand(args) {
+  const wt = shellQuote(args.worktree);
+  const file = shellQuote(args.relPath);
+  const inv = args.cliInvocation.map(shellQuote).join(" ");
+  const fallback = `cd ${wt} && if ! git diff --quiet HEAD -- ${file} 2>/dev/null; then ` + `git diff HEAD -- ${file} | { delta --paging=always 2>/dev/null || less -R; }; ` + `else bat --style=plain --paging=always ${file} 2>/dev/null || \${PAGER:-less} ${file} 2>/dev/null || cat ${file}; fi`;
+  return `${inv} ops --worktree ${wt} --preview ${file} || { ${fallback}; }`;
+}
+function updatePageCommand(args) {
+  return `${shellQuoteArgv([...args.cliInvocation, "update-page"])}`;
+}
+function tasksPaneCommand(cliInvocation, opts = {}) {
+  const argv = [...cliInvocation, "tasks"];
+  if (opts.initialTaskId)
+    argv.push("--initial-task-id", opts.initialTaskId);
+  return shellQuoteArgv(argv);
+}
+function opsPaneCommand(args) {
+  if (args.taskId && args.claudePaneId) {
+    const inv = args.cliInvocation.map(shellQuote).join(" ");
+    const vendorFlag = args.vendor ? ` --vendor ${shellQuote(args.vendor)}` : "";
+    return `KOBE_FILETREE_WATCH=1 ${inv} ops --task-id ${shellQuote(args.taskId)} --worktree ${shellQuote(args.cwd)} ` + `--target-pane ${shellQuote(args.claudePaneId)}${vendorFlag} || { ${fallbackOpsScript(args.cwd)}; }`;
+  }
+  return fallbackOpsScript(args.cwd);
+}
+var TASKS_PANE_WIDTH = 32, CLAUDE_PANE_PERCENT = 60, OPS_PANE_PERCENT = 50;
+
+// src/engine/claude-code-local/hook-adapter.ts
+import { existsSync } from "fs";
+import { appendFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, join as join3 } from "path";
+function isObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+async function readJsonObject(path3) {
+  try {
+    const parsed = JSON.parse(await readFile2(path3, "utf8"));
+    return isObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isKobeWorktreeSyncGroup(group) {
+  if (!isObject(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((h) => isObject(h) && typeof h.command === "string" && h.command.includes(WORKTREE_SYNC_MARKER));
+}
+function mergeWorktreeSyncHook(current, command) {
+  const { hooks: rawHooks, ...restSettings } = current;
+  const { WorktreeCreate, ...otherHooks } = isObject(rawHooks) ? rawHooks : {};
+  const prior = Array.isArray(WorktreeCreate) ? WorktreeCreate : [];
+  const kept = prior.filter((g) => !isKobeWorktreeSyncGroup(g));
+  if (command !== null)
+    kept.push({ hooks: [{ type: "command", command }] });
+  const nextHooks = { ...otherHooks };
+  if (kept.length > 0)
+    nextHooks.WorktreeCreate = kept;
+  return Object.keys(nextHooks).length > 0 ? { ...restSettings, hooks: nextHooks } : { ...restSettings };
+}
+function buildClaudeHooks(taskId, inv = kobeCliInvocation()) {
+  const out = {};
+  for (const { event, matcher, verb } of EVENT_MAP) {
+    const command = shellQuoteArgv([...inv, "hook", verb, "--task-id", taskId]);
+    const group = { hooks: [{ type: "command", command }] };
+    if (matcher)
+      group.matcher = matcher;
+    out[event] = [group];
+  }
+  return out;
+}
+function mergeClaudeHooks(existing, kobeHooks) {
+  const merged = { ...existing };
+  for (const event of KOBE_HOOK_EVENTS)
+    merged[event] = kobeHooks[event];
+  return merged;
+}
+
+class ClaudeHookAdapter {
+  vendor = "claude";
+  supportsHooks() {
+    return true;
+  }
+  supportsWorktreeSync() {
+    return true;
+  }
+  async installWorktreeSyncHook(settingsFilePath) {
+    await this.editWorktreeSyncHook(settingsFilePath, true);
+  }
+  async removeWorktreeSyncHook(settingsFilePath) {
+    await this.editWorktreeSyncHook(settingsFilePath, false);
+  }
+  async editWorktreeSyncHook(settingsFilePath, install) {
+    const current = await readJsonObject(settingsFilePath);
+    const command = install ? shellQuoteArgv([...kobeCliInvocation(), "hook", "worktree-created"]) : null;
+    const next = mergeWorktreeSyncHook(current, command);
+    await mkdir2(dirname3(settingsFilePath), { recursive: true });
+    await writeFile2(settingsFilePath, `${JSON.stringify(next, null, 2)}
+`);
+  }
+  async installTaskHooks(ctx) {
+    try {
+      const claudeDir = join3(ctx.worktreeDir, ".claude");
+      const settingsPath = join3(claudeDir, "settings.local.json");
+      await mkdir2(claudeDir, { recursive: true });
+      let current = {};
+      try {
+        const raw = await readFile2(settingsPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+          current = parsed;
+      } catch {}
+      const existingHooks = current.hooks && typeof current.hooks === "object" && !Array.isArray(current.hooks) ? current.hooks : {};
+      current.hooks = mergeClaudeHooks(existingHooks, buildClaudeHooks(ctx.taskId));
+      await writeFile2(settingsPath, `${JSON.stringify(current, null, 2)}
+`);
+      await hideFromGit(ctx.worktreeDir, ".claude/settings.local.json");
+    } catch {}
+  }
+}
+async function hideFromGit(worktreeDir, relPath) {
+  try {
+    const proc = Bun.spawn(["git", "-C", worktreeDir, "rev-parse", "--git-common-dir"], {
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    if (code !== 0)
+      return;
+    let commonDir = out.trim();
+    if (!commonDir)
+      return;
+    if (!commonDir.startsWith("/"))
+      commonDir = join3(worktreeDir, commonDir);
+    const excludePath = join3(commonDir, "info", "exclude");
+    const existing = existsSync(excludePath) ? await readFile2(excludePath, "utf8") : "";
+    if (existing.split(`
+`).some((l) => l.trim() === relPath))
+      return;
+    await mkdir2(join3(commonDir, "info"), { recursive: true });
+    await appendFile(excludePath, `${existing.endsWith(`
+`) || existing === "" ? "" : `
+`}${relPath}
+`);
+  } catch {}
+}
+var EVENT_MAP, KOBE_HOOK_EVENTS, WORKTREE_SYNC_MARKER = "worktree-created";
+var init_hook_adapter = __esm(() => {
+  init_invocation();
+  EVENT_MAP = [
+    { event: "SessionStart", verb: "session-start" },
+    { event: "UserPromptSubmit", verb: "turn-start" },
+    { event: "Stop", verb: "turn-complete" },
+    { event: "StopFailure", verb: "turn-failed" },
+    { event: "Notification", matcher: "permission_prompt", verb: "awaiting-input" },
+    { event: "SessionEnd", verb: "session-end" }
+  ];
+  KOBE_HOOK_EVENTS = EVENT_MAP.map((e) => e.event);
+});
+
+// src/engine/hook-adapter.ts
+function createEngineHookAdapter(vendor) {
+  if (vendor === "claude")
+    return new ClaudeHookAdapter;
+  return new NoopHookAdapter(vendor);
+}
+
+class NoopHookAdapter {
+  vendor;
+  constructor(vendor) {
+    this.vendor = vendor;
+  }
+  supportsHooks() {
+    return false;
+  }
+  async installTaskHooks() {}
+  supportsWorktreeSync() {
+    return false;
+  }
+  async installWorktreeSyncHook() {}
+  async removeWorktreeSyncHook() {}
+}
+var init_hook_adapter2 = __esm(() => {
+  init_hook_adapter();
+});
+
 // src/orchestrator/errors.ts
 var IllegalTransitionError, TaskNotFoundError, CannotDeleteMainTaskError, DIRTY_WORKTREE_CODE = "DIRTY_WORKTREE", DirtyWorktreeError, WorktreeRemoveFailedError;
 var init_errors = __esm(() => {
@@ -3003,8 +3245,10 @@ class Orchestrator {
     const task = this.requireTask(id);
     if (task.kind === "main")
       return task.repo;
-    if (task.worktreePath)
+    if (task.worktreePath) {
+      await this.installEngineHooks(task);
       return task.worktreePath;
+    }
     const inflight = this.worktreeLocks.get(task.id);
     if (inflight) {
       await inflight;
@@ -3028,6 +3272,7 @@ class Orchestrator {
           worktreePath: info.path,
           branch
         });
+        await this.installEngineHooks(this.requireTask(task.id));
       } catch (err) {
         this.slugs.cancel(task.repo, slug);
         throw err;
@@ -3152,14 +3397,17 @@ class Orchestrator {
     if (!input.worktreePath)
       throw new Error("adoptWorktree: worktreePath is required");
     const target = canonPath(input.worktreePath);
+    const existing = this.store.list().find((t) => t.worktreePath && canonPath(t.worktreePath) === target);
+    if (existing) {
+      if (input.ifExists === "return")
+        return existing;
+      throw new Error(`adoptWorktree: ${input.worktreePath} is already adopted as a task`);
+    }
     const candidates = await this.worktrees.listAll(input.repo);
     const match = candidates.find((wt) => canonPath(wt.path) === target);
     if (!match) {
       throw new Error(`adoptWorktree: ${input.worktreePath} is not an adoptable git worktree of ${input.repo} (unknown, detached, or the main checkout)`);
     }
-    const alreadyLinked = this.store.list().some((t) => t.worktreePath && canonPath(t.worktreePath) === target);
-    if (alreadyLinked)
-      throw new Error(`adoptWorktree: ${input.worktreePath} is already adopted as a task`);
     const branch = input.branch?.trim() || match.branch;
     const title = (input.title ?? basename2(match.path)).trim() || PLACEHOLDER_TASK_TITLE;
     return this.store.create({
@@ -3172,6 +3420,14 @@ class Orchestrator {
       vendor: input.vendor ?? DEFAULT_TASK_VENDOR
     });
   }
+  async installEngineHooks(task) {
+    if (task.kind === "main" || !task.worktreePath)
+      return;
+    await createEngineHookAdapter(task.vendor ?? DEFAULT_TASK_VENDOR).installTaskHooks({
+      worktreeDir: task.worktreePath,
+      taskId: task.id
+    });
+  }
   pendingBaseRefs = new Map;
   requireTask(id) {
     const task = this.store.get(id);
@@ -3194,6 +3450,7 @@ function canonPath(p) {
 var PLACEHOLDER_TASK_TITLE = "(new task)";
 var init_core = __esm(() => {
   init_dev();
+  init_hook_adapter2();
   init_errors();
   init_slug_allocator();
 });
@@ -3225,13 +3482,13 @@ function frameToLine(frame) {
 }
 var DAEMON_PROTOCOL_VERSION = 2, MIN_COMPATIBLE_PROTOCOL_VERSION = 2, CHANNEL_NAMES;
 var init_protocol = __esm(() => {
-  CHANNEL_NAMES = ["task.snapshot", "active-task", "update"];
+  CHANNEL_NAMES = ["task.snapshot", "active-task", "update", "engine-state"];
 });
 
 // src/daemon/paths.ts
 import { createHash as createHash2 } from "crypto";
 import { homedir as homedir3, tmpdir } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function shortHomeTag(homeDir2) {
   return createHash2("sha1").update(homeDir2).digest("hex").slice(0, 8);
 }
@@ -3240,7 +3497,7 @@ function fitSocketPath(naturalPath, homeDir2, role, pidTag) {
     return naturalPath;
   const tag = shortHomeTag(homeDir2);
   const suffix = pidTag === undefined ? "" : `-${pidTag}`;
-  const fallback = join3(tmpdir(), `kobe-${tag}-${role}${suffix}.sock`);
+  const fallback = join4(tmpdir(), `kobe-${tag}-${role}${suffix}.sock`);
   if (Buffer.byteLength(fallback, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
     return fallback;
   throw new Error(`kobe socket path exceeds ${SOCKET_PATH_SAFETY_LIMIT} bytes even after fallback: ${fallback}`);
@@ -3251,33 +3508,33 @@ function defaultDaemonSocketPath(homeDir2) {
     return override;
   const explicit = homeDir2 ?? process.env.KOBE_HOME_DIR;
   if (explicit && explicit.length > 0) {
-    return fitSocketPath(join3(explicit, ".kobe", "daemon.sock"), explicit, "daemon");
+    return fitSocketPath(join4(explicit, ".kobe", "daemon.sock"), explicit, "daemon");
   }
   const runtimeDir = process.env.XDG_RUNTIME_DIR;
   if (runtimeDir && runtimeDir.length > 0) {
-    return fitSocketPath(join3(runtimeDir, "kobe.sock"), runtimeDir, "daemon");
+    return fitSocketPath(join4(runtimeDir, "kobe.sock"), runtimeDir, "daemon");
   }
   const home = homedir3();
-  return fitSocketPath(join3(home, ".kobe", "daemon.sock"), home, "daemon");
+  return fitSocketPath(join4(home, ".kobe", "daemon.sock"), home, "daemon");
 }
 function defaultDaemonPidPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir3()) {
   const override = process.env.KOBE_DAEMON_PID_PATH;
   if (override && override.length > 0)
     return override;
-  return join3(homeDir2, ".kobe", "daemon.pid");
+  return join4(homeDir2, ".kobe", "daemon.pid");
 }
 function defaultDaemonLogPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir3()) {
-  return join3(homeDir2, ".kobe", "daemon.log");
+  return join4(homeDir2, ".kobe", "daemon.log");
 }
 function defaultClientLogPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir3()) {
-  return join3(homeDir2, ".kobe", "client.log");
+  return join4(homeDir2, ".kobe", "client.log");
 }
 var SOCKET_PATH_SAFETY_LIMIT = 100;
 var init_paths2 = () => {};
 
 // src/client/client-log.ts
-import { appendFile, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3 } from "path";
+import { appendFile as appendFile2, mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4 } from "path";
 function setClientLogContext(ctx) {
   context = ctx;
 }
@@ -3309,11 +3566,11 @@ function append(line) {
   const path3 = defaultClientLogPath();
   writeChain = writeChain.then(async () => {
     try {
-      await appendFile(path3, line);
+      await appendFile2(path3, line);
     } catch (err) {
       if (err?.code === "ENOENT") {
-        await mkdir2(dirname3(path3), { recursive: true });
-        await appendFile(path3, line);
+        await mkdir3(dirname4(path3), { recursive: true });
+        await appendFile2(path3, line);
       } else {
         throw err;
       }
@@ -3515,6 +3772,37 @@ var init_client = __esm(() => {
   init_client_log();
 });
 
+// src/engine/hook-events.ts
+function isEngineActivityKind(v) {
+  return ENGINE_ACTIVITY_KINDS.includes(v);
+}
+function reduceActivity(_prev, kind, detail) {
+  switch (kind) {
+    case "session-start":
+    case "session-end":
+      return "idle";
+    case "turn-start":
+      return "running";
+    case "turn-complete":
+      return "turn_complete";
+    case "turn-failed":
+      return detail?.failure === "rate_limit" || detail?.failure === "billing" ? "rate_limited" : "error";
+    case "awaiting-input":
+      return detail?.waiting === "permission" ? "permission_needed" : "running";
+  }
+}
+var ENGINE_ACTIVITY_KINDS;
+var init_hook_events = __esm(() => {
+  ENGINE_ACTIVITY_KINDS = [
+    "session-start",
+    "turn-start",
+    "turn-complete",
+    "turn-failed",
+    "awaiting-input",
+    "session-end"
+  ];
+});
+
 // src/engine/claude-code-local/normalize.ts
 function normalizeClaudeContent(content) {
   if (typeof content === "string") {
@@ -3562,7 +3850,7 @@ function normalizeClaudeContent(content) {
 }
 
 // src/engine/claude-code-local/history.ts
-import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile2, readdir, stat, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir4, readFile as readFile3, readdir, stat, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir4 } from "os";
 import path3 from "path";
 function encodeCwd(cwd) {
@@ -3633,7 +3921,7 @@ function parseJsonl(raw, sessionId) {
     } catch {
       continue;
     }
-    if (!isObject(parsed))
+    if (!isObject2(parsed))
       continue;
     const msg = extractMessage(parsed, sessionId);
     if (msg)
@@ -3642,7 +3930,7 @@ function parseJsonl(raw, sessionId) {
   return out;
 }
 function extractMessage(record, fallbackSessionId) {
-  const inner = isObject(record.message) ? record.message : record;
+  const inner = isObject2(record.message) ? record.message : record;
   const role = inner.role;
   if (role !== "user" && role !== "assistant" && role !== "system")
     return null;
@@ -3655,7 +3943,7 @@ function extractMessage(record, fallbackSessionId) {
   return usage ? { role, blocks, timestamp: ts, sessionId: sid, usage } : { role, blocks, timestamp: ts, sessionId: sid };
 }
 function extractUsage(v) {
-  if (!isObject(v))
+  if (!isObject2(v))
     return;
   const inTok = typeof v.input_tokens === "number" ? v.input_tokens : undefined;
   const outTok = typeof v.output_tokens === "number" ? v.output_tokens : undefined;
@@ -3670,7 +3958,7 @@ function extractUsage(v) {
     ...cacheCreate !== undefined ? { cache_creation_input_tokens: cacheCreate } : {}
   };
 }
-function isObject(v) {
+function isObject2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var defaultDeps;
@@ -3687,7 +3975,7 @@ var init_history = __esm(() => {
       }
     },
     async readFile(p) {
-      return await readFile2(p, "utf8");
+      return await readFile3(p, "utf8");
     },
     async pathExists(p) {
       try {
@@ -3714,7 +4002,7 @@ function normalizeCodexContent(raw) {
         blocks.push({ type: "text", text: item });
       continue;
     }
-    if (!isObject2(item))
+    if (!isObject3(item))
       continue;
     const t = typeof item.type === "string" ? item.type : undefined;
     if (t === "input_text" || t === "output_text") {
@@ -3728,7 +4016,7 @@ function normalizeCodexContent(raw) {
   }
   return blocks;
 }
-function isObject2(v) {
+function isObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
@@ -3778,7 +4066,7 @@ function validPositive(v) {
 }
 
 // src/engine/codex-local/history.ts
-import { readFile as readFile3, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
+import { readFile as readFile4, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import path4 from "path";
 async function listRolloutFiles(deps = defaultDeps2) {
@@ -3913,11 +4201,11 @@ function parseJsonl2(raw, sessionId) {
     } catch {
       continue;
     }
-    if (!isObject3(parsed))
+    if (!isObject4(parsed))
       continue;
     if (parsed.type !== "response_item")
       continue;
-    const payload = isObject3(parsed.payload) ? parsed.payload : undefined;
+    const payload = isObject4(parsed.payload) ? parsed.payload : undefined;
     if (!payload)
       continue;
     const ts = typeof parsed.timestamp === "string" ? parsed.timestamp : new Date().toISOString();
@@ -4034,7 +4322,7 @@ function textFromReasoningValue(value) {
       parts.push(entry);
       continue;
     }
-    if (!isObject3(entry))
+    if (!isObject4(entry))
       continue;
     const text = typeof entry.text === "string" ? entry.text : "";
     if (text.length > 0)
@@ -4076,14 +4364,14 @@ function deriveCodexUsageMetrics(raw) {
     } catch {
       continue;
     }
-    if (!isObject3(parsed))
+    if (!isObject4(parsed))
       continue;
     const timestampMs = typeof parsed.timestamp === "string" ? parseTimestampMs(parsed.timestamp) : null;
     if (parsed.type === "response_item")
       continue;
     if (parsed.type !== "turn.completed")
       continue;
-    const usage = isObject3(parsed.usage) ? parsed.usage : undefined;
+    const usage = isObject4(parsed.usage) ? parsed.usage : undefined;
     if (!usage)
       continue;
     const snapshot = codexUsageToSnapshot(usage);
@@ -4102,7 +4390,7 @@ function parseTimestampMs(value) {
   const ms = new Date(value).getTime();
   return Number.isFinite(ms) ? ms : null;
 }
-function isObject3(v) {
+function isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var defaultDeps2, UUID_AT_END, MAX_WORKTREE_SCAN = 200, MAX_MTIME_SCAN = 12;
@@ -4120,7 +4408,7 @@ var init_history2 = __esm(() => {
       }
     },
     async readFile(p) {
-      return await readFile3(p, "utf8");
+      return await readFile4(p, "utf8");
     },
     stat: stat2
   };
@@ -4129,16 +4417,16 @@ var init_history2 = __esm(() => {
 
 // src/engine/copilot-local/usage.ts
 function copilotUsageToSnapshot(value) {
-  if (!isObject4(value))
+  if (!isObject5(value))
     return;
-  const modelMetrics = isObject4(value.modelMetrics) ? value.modelMetrics : undefined;
+  const modelMetrics = isObject5(value.modelMetrics) ? value.modelMetrics : undefined;
   if (!modelMetrics)
     return;
   let input = 0;
   let output = 0;
   let cached = 0;
   for (const metrics of Object.values(modelMetrics)) {
-    if (!isObject4(metrics) || !isObject4(metrics.usage))
+    if (!isObject5(metrics) || !isObject5(metrics.usage))
       continue;
     input += numberOr2(metrics.usage.inputTokens, 0);
     output += numberOr2(metrics.usage.outputTokens, 0);
@@ -4154,7 +4442,7 @@ function copilotUsageToSnapshot(value) {
     ...context2 > 0 ? { context_tokens: context2 } : {}
   };
 }
-function isObject4(v) {
+function isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function numberOr2(value, fallback) {
@@ -4162,7 +4450,7 @@ function numberOr2(value, fallback) {
 }
 
 // src/engine/copilot-local/history.ts
-import { readFile as readFile4, readdir as readdir3, rm, stat as stat3 } from "fs/promises";
+import { readFile as readFile5, readdir as readdir3, rm, stat as stat3 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import path5 from "path";
 async function listSessionDirs(deps = defaultDeps3) {
@@ -4259,10 +4547,10 @@ function parseEvents(raw, fallbackSessionId) {
     } catch {
       continue;
     }
-    if (!isObject5(record) || typeof record.type !== "string")
+    if (!isObject6(record) || typeof record.type !== "string")
       continue;
     const timestamp = typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString();
-    const data = isObject5(record.data) ? record.data : {};
+    const data = isObject6(record.data) ? record.data : {};
     if (record.type === "session.start") {
       const sid = typeof data.sessionId === "string" ? data.sessionId : undefined;
       if (sid)
@@ -4285,7 +4573,7 @@ function parseEvents(raw, fallbackSessionId) {
         blocks.push({ type: "text", text });
       const toolRequests = Array.isArray(data.toolRequests) ? data.toolRequests : [];
       for (const req of toolRequests) {
-        if (!isObject5(req))
+        if (!isObject6(req))
           continue;
         const callId = typeof req.id === "string" ? req.id : typeof req.toolCallId === "string" ? req.toolCallId : "tool";
         const name = typeof req.name === "string" ? req.name : typeof req.toolName === "string" ? req.toolName : "tool";
@@ -4322,7 +4610,7 @@ function parseEvents(raw, fallbackSessionId) {
   }
   return { messages, usageMetrics, firstUserMessage };
 }
-function isObject5(v) {
+function isObject6(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var defaultDeps3, PREVIEW_CHAR_CAP = 200;
@@ -4342,7 +4630,7 @@ var init_history3 = __esm(() => {
       }
     },
     async readFile(p) {
-      return await readFile4(p, "utf8");
+      return await readFile5(p, "utf8");
     },
     stat: stat3,
     async rm(p) {
@@ -4404,90 +4692,6 @@ var init_auto_title = __esm(() => {
   init_history3();
 });
 
-// src/cli/invocation.ts
-import { fileURLToPath } from "url";
-function kobeCliInvocation() {
-  const isBuilt = import.meta.url.endsWith(".js");
-  if (isBuilt)
-    return ["kobe"];
-  const entry = fileURLToPath(new URL("./index.ts", import.meta.url));
-  const preload = fileURLToPath(import.meta.resolve("@opentui/solid/preload"));
-  return [process.execPath, "--preload", preload, "--conditions=browser", entry];
-}
-var init_invocation = () => {};
-
-// src/tmux/session-layout.ts
-function shellQuote(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function shellQuoteArgv(argv) {
-  return argv.map(shellQuote).join(" ");
-}
-function keepAlive(cmd) {
-  return `${cmd}; exec "\${SHELL:-/bin/sh}"`;
-}
-function shQuote(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function homeWelcomeCommand() {
-  const msg = "\\n  No task selected\\n\\n  Press N to create a task, or pick one on the left.\\n\\n";
-  return `clear; printf ${shQuote(msg)}; exec "\${SHELL:-/bin/sh}"`;
-}
-function engineLaunchLine(engineCmd, init) {
-  const tail = keepAlive(engineCmd);
-  const script = init?.initScript?.trim();
-  if (!script)
-    return tail;
-  const group = ["{", script, "}"].join(`
-`);
-  if (init?.markerPath) {
-    const marker = shQuote(init.markerPath);
-    const markerDir = shQuote(markerDirOf(init.markerPath));
-    return [
-      `if [ ! -f ${marker} ]; then`,
-      group,
-      `if [ $? -eq 0 ]; then mkdir -p ${markerDir} && : > ${marker}; fi`,
-      "fi",
-      tail
-    ].join(`
-`);
-  }
-  return [group, tail].join(`
-`);
-}
-function markerDirOf(p) {
-  const i = p.lastIndexOf("/");
-  return i <= 0 ? "." : p.slice(0, i);
-}
-function fallbackOpsScript(cwd) {
-  return `cd ${shellQuote(cwd)} && while :; do   clear;   printf "\\033[1m# %s\\033[0m\\n\\n" ${shellQuote(cwd)};   git status --short --branch 2>/dev/null | sed 's/^/  /' || true;   printf "\\n";   if command -v lsd >/dev/null 2>&1; then     lsd --tree --git -I node_modules -I .git --depth 2 .;   elif command -v eza >/dev/null 2>&1; then     eza --tree --git -L 2 -I 'node_modules|.git' .;   elif command -v tree >/dev/null 2>&1; then     tree -L 2 -I 'node_modules|.git';   else     ls -la;   fi;   sleep 2; done`;
-}
-function previewWindowCommand(args) {
-  const wt = shellQuote(args.worktree);
-  const file = shellQuote(args.relPath);
-  const inv = args.cliInvocation.map(shellQuote).join(" ");
-  const fallback = `cd ${wt} && if ! git diff --quiet HEAD -- ${file} 2>/dev/null; then ` + `git diff HEAD -- ${file} | { delta --paging=always 2>/dev/null || less -R; }; ` + `else bat --style=plain --paging=always ${file} 2>/dev/null || \${PAGER:-less} ${file} 2>/dev/null || cat ${file}; fi`;
-  return `${inv} ops --worktree ${wt} --preview ${file} || { ${fallback}; }`;
-}
-function updatePageCommand(args) {
-  return `${shellQuoteArgv([...args.cliInvocation, "update-page"])}`;
-}
-function tasksPaneCommand(cliInvocation, opts = {}) {
-  const argv = [...cliInvocation, "tasks"];
-  if (opts.initialTaskId)
-    argv.push("--initial-task-id", opts.initialTaskId);
-  return shellQuoteArgv(argv);
-}
-function opsPaneCommand(args) {
-  if (args.taskId && args.claudePaneId) {
-    const inv = args.cliInvocation.map(shellQuote).join(" ");
-    const vendorFlag = args.vendor ? ` --vendor ${shellQuote(args.vendor)}` : "";
-    return `KOBE_FILETREE_WATCH=1 ${inv} ops --task-id ${shellQuote(args.taskId)} --worktree ${shellQuote(args.cwd)} ` + `--target-pane ${shellQuote(args.claudePaneId)}${vendorFlag} || { ${fallbackOpsScript(args.cwd)}; }`;
-  }
-  return fallbackOpsScript(args.cwd);
-}
-var TASKS_PANE_WIDTH = 32, CLAUDE_PANE_PERCENT = 60, OPS_PANE_PERCENT = 50;
-
 // src/tmux/client.ts
 var exports_client = {};
 __export(exports_client, {
@@ -4967,9 +5171,9 @@ class DaemonEventBus {
 }
 
 // src/daemon/server.ts
-import { mkdir as mkdir4, readFile as readFile5, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile6, unlink as unlink4, writeFile as writeFile4 } from "fs/promises";
 import { createServer } from "net";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 function resolveIdleGraceMs() {
   const raw = process.env.KOBE_DAEMON_IDLE_GRACE_MS;
   if (raw === undefined)
@@ -4977,6 +5181,13 @@ function resolveIdleGraceMs() {
   const n = Number(raw);
   return Number.isFinite(n) && n >= 0 ? n : DEFAULT_IDLE_GRACE_MS;
 }
+function resolveEngineStateTtlMs() {
+  const raw = process.env.KOBE_ENGINE_STATE_TTL_MS;
+  if (raw === undefined)
+    return DEFAULT_ENGINE_STATE_TTL_MS;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : DEFAULT_ENGINE_STATE_TTL_MS;
+}
 async function startDaemonServer(orch, options = {}) {
   const socketPath = options.socketPath ?? defaultDaemonSocketPath(options.homeDir);
   const pidPath = options.pidPath ?? defaultDaemonPidPath(options.homeDir);
@@ -5017,8 +5228,30 @@ async function startDaemonServer(orch, options = {}) {
   bus.onPublish((event) => {
     broadcast(clients, { type: "event", name: event.channel, payload: event.payload });
   });
-  await mkdir4(dirname4(socketPath), { recursive: true });
-  await mkdir4(dirname4(pidPath), { recursive: true });
+  const activity = new Map;
+  const ACTIVITY_STALE_MS = resolveEngineStateTtlMs();
+  function reportActivity(taskId, kind, detail) {
+    const prev = activity.get(taskId);
+    if (prev?.lapse)
+      clearTimeout(prev.lapse);
+    const state = reduceActivity(prev?.state, kind, detail);
+    const at = Date.now();
+    const entry = { state, detail, at };
+    if (state !== "idle") {
+      entry.lapse = setTimeout(() => {
+        const cur = activity.get(taskId);
+        if (cur && cur.at === at) {
+          activity.set(taskId, { state: "idle", at: Date.now() });
+          bus.publish("engine-state", { taskId, state: "idle", at: Date.now() });
+        }
+      }, ACTIVITY_STALE_MS);
+      entry.lapse.unref?.();
+    }
+    activity.set(taskId, entry);
+    bus.publish("engine-state", { taskId, state, ...detail ? { detail } : {}, at });
+  }
+  await mkdir5(dirname5(socketPath), { recursive: true });
+  await mkdir5(dirname5(pidPath), { recursive: true });
   await unlink4(socketPath).catch(() => {});
   const server = createServer((socket) => {
     const client = {
@@ -5088,7 +5321,7 @@ async function startDaemonServer(orch, options = {}) {
       resolve2();
     });
   });
-  await writeFile3(pidPath, `${process.pid}
+  await writeFile4(pidPath, `${process.pid}
 `, "utf8");
   async function stopSoon() {
     if (stopping)
@@ -5181,6 +5414,10 @@ async function startDaemonServer(orch, options = {}) {
       case "task.delete": {
         const taskId = requireString(payload, "taskId");
         await orch.deleteTask(taskId, { force: optionalBoolean(payload, "force") });
+        const gone = activity.get(taskId);
+        if (gone?.lapse)
+          clearTimeout(gone.lapse);
+        activity.delete(taskId);
         return {};
       }
       case "task.pin": {
@@ -5218,7 +5455,8 @@ async function startDaemonServer(orch, options = {}) {
           worktreePath: requireString(payload, "worktreePath"),
           branch: optionalString(payload, "branch"),
           vendor: optionalVendor(payload, "vendor"),
-          title: optionalString(payload, "title")
+          title: optionalString(payload, "title"),
+          ifExists: optionalString(payload, "ifExists") === "return" ? "return" : "error"
         });
         return { task: serializeTask(task) };
       }
@@ -5226,6 +5464,15 @@ async function startDaemonServer(orch, options = {}) {
         bus.publish("active-task", { taskId: optionalString(payload, "taskId") ?? null });
         return {};
       }
+      case "engine.reportEvent": {
+        const taskId = requireString(payload, "taskId");
+        const kind = requireString(payload, "kind");
+        if (!isEngineActivityKind(kind))
+          throw new Error(`unknown engine event kind: ${kind}`);
+        const detail = optionalActivityDetail(payload);
+        reportActivity(taskId, kind, detail);
+        return {};
+      }
       case "subscribe": {
         client.subscribed = true;
         const role = payload.role === "gui" ? "gui" : "pane";
@@ -5236,6 +5483,15 @@ async function startDaemonServer(orch, options = {}) {
         for (const event of bus.snapshot()) {
           writeFrame(client, { type: "event", name: event.channel, payload: event.payload });
         }
+        for (const [taskId, entry] of activity) {
+          if (entry.state === "idle")
+            continue;
+          writeFrame(client, {
+            type: "event",
+            name: "engine-state",
+            payload: { taskId, state: entry.state, ...entry.detail ? { detail: entry.detail } : {}, at: entry.at }
+          });
+        }
         return {};
       }
       default:
@@ -5286,7 +5542,7 @@ async function startDaemonServer(orch, options = {}) {
 }
 async function readPidFile(pidPath) {
   try {
-    const raw = await readFile5(pidPath, "utf8");
+    const raw = await readFile6(pidPath, "utf8");
     const pid = Number(raw.trim());
     return Number.isFinite(pid) ? pid : null;
   } catch {
@@ -5337,13 +5593,29 @@ function optionalVendor(payload, key) {
   }
   return value;
 }
-var DEFAULT_UPDATE_POLL_MS, DEFAULT_IDLE_GRACE_MS = 3000;
+function optionalActivityDetail(payload) {
+  const raw = payload.detail;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const d = raw;
+  const out = {};
+  if (d.failure === "rate_limit" || d.failure === "billing" || d.failure === "other")
+    out.failure = d.failure;
+  if (d.waiting === "permission" || d.waiting === "input")
+    out.waiting = d.waiting;
+  if (typeof d.note === "string")
+    out.note = d.note;
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+var DEFAULT_UPDATE_POLL_MS, DEFAULT_IDLE_GRACE_MS = 3000, DEFAULT_ENGINE_STATE_TTL_MS;
 var init_server = __esm(() => {
+  init_hook_events();
   init_version();
   init_auto_title_poller();
   init_paths2();
   init_protocol();
   DEFAULT_UPDATE_POLL_MS = 6 * 60 * 60 * 1000;
+  DEFAULT_ENGINE_STATE_TTL_MS = 10 * 60 * 1000;
 });
 
 // src/daemon/lifecycle.ts
@@ -5411,14 +5683,14 @@ __export(exports_daemon_process, {
   connectIfRunning: () => connectIfRunning
 });
 import { spawn } from "child_process";
-import { closeSync, existsSync, mkdirSync as mkdirSync2, openSync } from "fs";
-import { dirname as dirname5, resolve as resolve2 } from "path";
+import { closeSync, existsSync as existsSync2, mkdirSync as mkdirSync2, openSync } from "fs";
+import { dirname as dirname6, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function spawnDetachedDaemon(command, args, env, logPath) {
   let stdio = "ignore";
   let logFd;
   try {
-    mkdirSync2(dirname5(logPath), { recursive: true });
+    mkdirSync2(dirname6(logPath), { recursive: true });
     logFd = openSync(logPath, "a");
     stdio = ["ignore", logFd, logFd];
   } catch {
@@ -5485,12 +5757,12 @@ function resolveKobeSpawn(subcommand) {
   if (here.startsWith("/$bunfs") || here.startsWith("B:\\~BUN")) {
     return [process.execPath, ...subcommand];
   }
-  const dir = dirname5(here);
+  const dir = dirname6(here);
   const sourceEntry = resolve2(dir, "../cli/index.ts");
-  if (existsSync(sourceEntry))
+  if (existsSync2(sourceEntry))
     return [process.execPath, sourceEntry, ...subcommand];
   const distEntry = resolve2(dir, "../cli/index.js");
-  if (existsSync(distEntry))
+  if (existsSync2(distEntry))
     return [process.execPath, distEntry, ...subcommand];
   throw new Error(`kobe: could not locate kobe entry near ${dir}; expected ../cli/index.{ts,js}`);
 }
@@ -5581,14 +5853,14 @@ async function runRepoSubcommand(args) {
     return;
   }
   const { getRepoInitOverride: getRepoInitOverride2, setRepoInitOverride: setRepoInitOverride2, resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
-  const { existsSync: existsSync2 } = await import("fs");
-  const { join: join4 } = await import("path");
+  const { existsSync: existsSync3 } = await import("fs");
+  const { join: join5 } = await import("path");
   if (verb === "show") {
     const [pathArg] = rest.filter((a) => !a.startsWith("-"));
     const repo = resolveRepoRoot2(resolve3(process.cwd(), pathArg ?? "."));
     const override = getRepoInitOverride2(repo);
-    const hasFileScript = existsSync2(join4(repo, ".kobe", "init.sh"));
-    const hasFilePrompt = existsSync2(join4(repo, ".kobe", "init-prompt.md"));
+    const hasFileScript = existsSync3(join5(repo, ".kobe", "init.sh"));
+    const hasFilePrompt = existsSync3(join5(repo, ".kobe", "init-prompt.md"));
     console.log(`repo: ${repo}`);
     console.log(`  .kobe/init.sh:        ${hasFileScript ? "present (wins)" : "absent"}`);
     console.log(`  .kobe/init-prompt.md: ${hasFilePrompt ? "present (wins)" : "absent"}`);
@@ -6247,14 +6519,14 @@ var exports_repo_init = {};
 __export(exports_repo_init, {
   resolveRepoInit: () => resolveRepoInit
 });
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
 function repoFileScript(worktreePath) {
-  return existsSync2(join4(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
+  return existsSync3(join5(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
 }
 function repoFilePrompt(worktreePath) {
-  const p = join4(worktreePath, INIT_PROMPT_REL);
-  if (!existsSync2(p))
+  const p = join5(worktreePath, INIT_PROMPT_REL);
+  if (!existsSync3(p))
     return;
   try {
     const text = readFileSync3(p, "utf8");
@@ -6275,8 +6547,8 @@ function resolveRepoInit(repoRoot, worktreePath) {
 var INIT_SCRIPT_REL, INIT_PROMPT_REL;
 var init_repo_init = __esm(() => {
   init_repos();
-  INIT_SCRIPT_REL = join4(".kobe", "init.sh");
-  INIT_PROMPT_REL = join4(".kobe", "init-prompt.md");
+  INIT_SCRIPT_REL = join5(".kobe", "init.sh");
+  INIT_PROMPT_REL = join5(".kobe", "init-prompt.md");
 });
 
 // src/tui/panes/sidebar/worktree-changes.ts
@@ -6327,32 +6599,74 @@ var init_worktree_changes = __esm(() => {
 // src/cli/api-cmd.ts
 var exports_api_cmd = {};
 __export(exports_api_cmd, {
+  verbSchema: () => verbSchema,
+  verbHelp: () => verbHelp,
+  validateAgainstSpec: () => validateAgainstSpec,
+  schemaIndex: () => schemaIndex,
   runApiSubcommand: () => runApiSubcommand,
   parseFlags: () => parseFlags,
   parseAgentsSpec: () => parseAgentsSpec,
+  fullSchema: () => fullSchema,
+  findVerb: () => findVerb,
   apiUsage: () => apiUsage,
+  VERB_GROUPS: () => VERB_GROUPS,
+  VERBS: () => VERBS,
   FANOUT_CAP: () => FANOUT_CAP,
   ApiError: () => ApiError,
-  API_VERBS: () => API_VERBS
+  API_VERBS: () => API_VERBS,
+  API_SCHEMA_VERSION: () => API_SCHEMA_VERSION
 });
 import { resolve as resolve4 } from "path";
-function parseFlags(argv) {
+function groupOf(verbName) {
+  for (const [group, names] of Object.entries(VERB_GROUPS)) {
+    if (names.includes(verbName))
+      return group;
+  }
+  return "other";
+}
+async function handleSchema(_client, parsed) {
+  const { flags } = parsed;
+  const verbName = optional(flags, "verb");
+  if (verbName) {
+    const v = findVerb(verbName);
+    if (!v)
+      throw new ApiError(`unknown verb: ${verbName}`, "BAD_VERB");
+    return verbSchema(v);
+  }
+  const group = optional(flags, "group");
+  if (group)
+    return groupSchema(group);
+  if (optionalBool(flags, "all"))
+    return fullSchema();
+  return schemaIndex();
+}
+function findVerb(name) {
+  const canonical = VERB_ALIASES[name] ?? name;
+  return VERBS.find((v) => v.name === canonical);
+}
+function parseFlags(argv, booleanFlags = new Set) {
   const flags = new Map;
   let pretty = false;
+  let help = false;
   for (let i = 0;i < argv.length; i++) {
     const arg = argv[i];
-    if (!arg.startsWith("--")) {
+    if (!arg.startsWith("--") && arg !== "-h") {
       throw new ApiError(`unexpected positional arg: ${arg}`, "BAD_FLAG");
     }
+    if (arg === "-h") {
+      help = true;
+      continue;
+    }
     const eq = arg.indexOf("=");
     if (eq !== -1) {
       const key2 = arg.slice(2, eq);
       const value = arg.slice(eq + 1);
-      if (key2 === "pretty") {
+      if (key2 === "pretty")
         pretty = value !== "false" && value !== "0";
-      } else {
+      else if (key2 === "help")
+        help = value !== "false" && value !== "0";
+      else
         flags.set(key2, value);
-      }
       continue;
     }
     const key = arg.slice(2);
@@ -6360,6 +6674,14 @@ function parseFlags(argv) {
       pretty = true;
       continue;
     }
+    if (key === "help") {
+      help = true;
+      continue;
+    }
+    if (booleanFlags.has(key)) {
+      flags.set(key, "true");
+      continue;
+    }
     const next = argv[i + 1];
     if (next === undefined || next.startsWith("--")) {
       throw new ApiError(`flag --${key} requires a value`, "BAD_FLAG");
@@ -6367,19 +6689,50 @@ function parseFlags(argv) {
     flags.set(key, next);
     i += 1;
   }
-  return { flags, pretty };
+  return { flags, pretty, help };
+}
+function validateAgainstSpec(verb, flags) {
+  const known = new Set(verb.flags.map((f) => f.name));
+  for (const key of flags.keys()) {
+    if (!known.has(key)) {
+      throw new ApiError(`unknown flag --${key} for "${verb.name}". Run \`kobe api ${verb.name} --help\``, "BAD_FLAG");
+    }
+  }
+  for (const f of verb.flags) {
+    if (f.required && !flags.get(f.name))
+      throw new ApiError(`--${f.name} is required for "${verb.name}"`, "MISSING_FLAG");
+    if (f.type === "enum" && f.values) {
+      const raw = flags.get(f.name);
+      if (raw !== undefined && !f.values.includes(raw)) {
+        throw new ApiError(`--${f.name} must be one of ${f.values.join(", ")}`, "BAD_FLAG");
+      }
+    }
+    if (f.type === "int") {
+      const raw = flags.get(f.name);
+      if (raw !== undefined) {
+        const n = Number.parseInt(raw, 10);
+        if (!Number.isInteger(n) || n <= 0)
+          throw new ApiError(`--${f.name} must be a positive integer`, "BAD_FLAG");
+      }
+    }
+  }
 }
 function required(flags, key) {
   const v = flags.get(key);
-  if (v === undefined || v.length === 0) {
+  if (v === undefined || v.length === 0)
     throw new ApiError(`--${key} is required`, "MISSING_FLAG");
-  }
   return v;
 }
 function optional(flags, key) {
   const v = flags.get(key);
   return v && v.length > 0 ? v : undefined;
 }
+function requireEnum(flags, key, values) {
+  const v = required(flags, key);
+  if (!values.includes(v))
+    throw new ApiError(`--${key} must be one of ${values.join(", ")}`, "BAD_FLAG");
+  return v;
+}
 function optionalVendor2(flags) {
   const raw = optional(flags, "vendor");
   if (raw === undefined)
@@ -6389,16 +6742,28 @@ function optionalVendor2(flags) {
   }
   return raw;
 }
+function optionalBool(flags, key) {
+  const raw = optional(flags, key);
+  if (raw === undefined)
+    return;
+  if (["true", "1", "yes"].includes(raw))
+    return true;
+  if (["false", "0", "no"].includes(raw))
+    return false;
+  throw new ApiError(`--${key} must be a boolean (true/false)`, "BAD_FLAG");
+}
 function optionalPositiveInt(flags, key) {
   const raw = optional(flags, key);
   if (raw === undefined)
     return;
   const n = Number.parseInt(raw, 10);
-  if (!Number.isInteger(n) || n <= 0) {
+  if (!Number.isInteger(n) || n <= 0)
     throw new ApiError(`--${key} must be a positive integer`, "BAD_FLAG");
-  }
   return n;
 }
+function resolveRepoFlag(repo) {
+  return resolve4(process.cwd(), repo);
+}
 function parseAgentsSpec(spec) {
   const out = [];
   for (const part of spec.split(",")) {
@@ -6423,19 +6788,102 @@ function parseAgentsSpec(spec) {
     throw new ApiError('--agents specified no agents (e.g. "claude:2,codex:1")', "BAD_FLAG");
   return out;
 }
+function flagJson(f) {
+  return {
+    name: f.name,
+    type: f.type,
+    required: f.required ?? false,
+    ...f.values ? { values: f.values } : {},
+    ...f.default !== undefined ? { default: f.default } : {},
+    ...f.placeholder ? { placeholder: f.placeholder } : {},
+    description: f.description
+  };
+}
+function verbSchema(v) {
+  return {
+    name: v.name,
+    group: groupOf(v.name),
+    summary: v.summary,
+    offline: v.offline ?? false,
+    flags: v.flags.map(flagJson)
+  };
+}
+function schemaIndex() {
+  return {
+    apiVersion: API_SCHEMA_VERSION,
+    kobeVersion: CURRENT_VERSION,
+    hint: "Compact index. Drill into ONE verb: `kobe api schema --verb <name>` (or `kobe api <verb> --help`). One group: `--group <g>`. Whole spec: `--all`.",
+    groups: VERB_GROUPS,
+    verbs: VERBS.map((v) => ({ name: v.name, group: groupOf(v.name), summary: v.summary })),
+    globalFlags: GLOBAL_FLAGS,
+    aliases: VERB_ALIASES
+  };
+}
+function groupSchema(group) {
+  const names = VERB_GROUPS[group];
+  if (!names) {
+    throw new ApiError(`unknown group: ${group}. Groups: ${Object.keys(VERB_GROUPS).join(", ")}`, "BAD_FLAG");
+  }
+  return {
+    group,
+    verbs: names.map((n) => {
+      const v = findVerb(n);
+      return { name: n, summary: v?.summary ?? "" };
+    })
+  };
+}
+function fullSchema() {
+  return {
+    apiVersion: API_SCHEMA_VERSION,
+    kobeVersion: CURRENT_VERSION,
+    output: {
+      success: "one JSON object on stdout, newline-terminated, exit 0",
+      error: '{"error":{"message","code"}} on stderr, exit != 0',
+      pretty: "--pretty indents stdout JSON"
+    },
+    globalFlags: GLOBAL_FLAGS,
+    aliases: VERB_ALIASES,
+    groups: VERB_GROUPS,
+    verbs: VERBS.map(verbSchema)
+  };
+}
+function flagSignature(verb) {
+  return verb.flags.map((f) => {
+    const meta = f.type === "enum" && f.values ? f.values.join("|") : f.placeholder ?? (f.type === "bool" ? "" : "X");
+    const core = meta ? `--${f.name} ${meta}` : `--${f.name}`;
+    return f.required ? core : `[${core}]`;
+  }).join(" ");
+}
+function verbHelp(verb) {
+  const lines = [`kobe api ${verb.name} ${flagSignature(verb)}`.trimEnd(), "", verb.summary, ""];
+  const alias = Object.entries(VERB_ALIASES).find(([, canon]) => canon === verb.name)?.[0];
+  if (alias)
+    lines.push(`Alias: ${alias}`, "");
+  if (verb.flags.length > 0) {
+    lines.push("Flags:");
+    for (const f of verb.flags) {
+      const req = f.required ? " (required)" : "";
+      const def = f.default !== undefined ? ` [default: ${f.default}]` : "";
+      const vals = f.type === "enum" && f.values ? ` {${f.values.join("|")}}` : "";
+      lines.push(`  --${f.name}${vals}${req}${def}  ${f.description}`);
+    }
+    lines.push("");
+  }
+  lines.push("Global: [--pretty] [--help]");
+  return lines.join(`
+`);
+}
 function apiUsage() {
+  const rows = VERBS.map((v) => `  ${v.name.padEnd(18)} ${v.summary}`);
   return [
-    "usage: kobe api <verb> [flags] [--pretty]",
+    "usage: kobe api <verb> [flags] [--pretty] [--help]",
+    "",
+    "Explore the full surface (names, flags, types) with:  kobe api schema",
     "",
     "verbs:",
-    "  spawn-task  --repo PATH [--prompt TEXT] [--title T] [--base-branch B] [--vendor V]",
-    "  fan-out     --repo PATH --prompt TEXT [--count N | --agents claude:2,codex:1] [--base-branch B]",
-    "  send        [--task-id ID] --prompt TEXT",
-    "  get-task    --task-id ID",
-    "  collect     --task-ids a,b,c | --repo PATH",
-    "  list",
+    ...rows,
     "",
-    "Output is one JSON object on stdout (exit 0); errors are JSON on stderr (exit \u2260 0)."
+    "Output is one JSON object on stdout (exit 0); errors are JSON on stderr (exit != 0)."
   ].join(`
 `);
 }
@@ -6492,12 +6940,22 @@ async function resolveActiveTaskId(client) {
   }
   return activeId;
 }
-async function spawnTask(client, parsed) {
+async function simpleRpc(client, name, payload) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
+  return client.request(name, payload);
+}
+async function add(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   const { flags } = parsed;
-  const payload = { repo: required(flags, "repo") };
+  const payload = { repo: resolveRepoFlag(required(flags, "repo")) };
   const title = optional(flags, "title");
   if (title)
     payload.title = title;
+  const branch = optional(flags, "branch");
+  if (branch)
+    payload.branch = branch;
   const baseRef = optional(flags, "base-branch");
   if (baseRef)
     payload.baseRef = baseRef;
@@ -6505,25 +6963,26 @@ async function spawnTask(client, parsed) {
   if (vendor)
     payload.vendor = vendor;
   const res = await client.request("task.create", payload);
-  const prompt = optional(flags, "prompt");
-  if (!prompt) {
-    return { taskId: res.taskId, task: res.task, started: false };
+  const taskId = res.taskId;
+  const status = optional(flags, "status");
+  if (status)
+    await client.request("task.status", { taskId, status: requireEnum(flags, "status", TASK_STATUSES) });
+  const pin = optionalBool(flags, "pin");
+  if (pin !== undefined)
+    await client.request("task.pin", { taskId, pinned: pin });
+  let task = res.task;
+  if (status || pin !== undefined) {
+    task = (await client.request("task.get", { taskId })).task;
   }
-  const delivered = await deliverPrompt(client, {
-    id: res.taskId,
-    worktreePath: res.task.worktreePath,
-    vendor: res.task.vendor,
-    repo: res.task.repo
-  }, prompt);
-  return {
-    taskId: res.taskId,
-    task: res.task,
-    started: delivered.started,
-    engineReady: delivered.engineReady,
-    session: delivered.session
-  };
+  const prompt = optional(flags, "prompt");
+  if (!prompt)
+    return { taskId, task, started: false };
+  const delivered = await deliverPrompt(client, { id: taskId, worktreePath: task.worktreePath, vendor: task.vendor, repo: task.repo }, prompt);
+  return { taskId, task, started: delivered.started, engineReady: delivered.engineReady, session: delivered.session };
 }
 async function send(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   const { flags } = parsed;
   const prompt = required(flags, "prompt");
   let taskId = optional(flags, "task-id");
@@ -6550,17 +7009,50 @@ async function send(client, parsed) {
   };
 }
 async function getTask(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   const taskId = required(parsed.flags, "task-id");
   const res = await client.request("task.get", { taskId });
   const running = await sessionExists(tmuxSessionName(taskId));
   return { task: res.task, running };
 }
 async function list(client) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   return client.request("task.list");
 }
+async function setActive(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
+  const none = optionalBool(parsed.flags, "none");
+  const taskId = none ? null : required(parsed.flags, "task-id");
+  await client.request("task.setActive", { taskId });
+  return { ok: true, activeTaskId: taskId };
+}
+async function adopt(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
+  const { flags } = parsed;
+  const input = {
+    repo: resolveRepoFlag(required(flags, "repo")),
+    worktreePath: resolveRepoFlag(required(flags, "worktree"))
+  };
+  const branch = optional(flags, "branch");
+  if (branch)
+    input.branch = branch;
+  const vendor = optionalVendor2(flags);
+  if (vendor)
+    input.vendor = vendor;
+  const title = optional(flags, "title");
+  if (title)
+    input.title = title;
+  return client.request("worktree.adopt", input);
+}
 async function fanOut(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   const { flags } = parsed;
-  const repo = required(flags, "repo");
+  const repo = resolveRepoFlag(required(flags, "repo"));
   const prompt = required(flags, "prompt");
   const title = optional(flags, "title");
   const baseRef = optional(flags, "base-branch");
@@ -6589,6 +7081,8 @@ async function fanOut(client, parsed) {
   return { count: tasks.length, tasks };
 }
 async function collect(client, parsed) {
+  if (!client)
+    throw new ApiError("daemon required", "BAD_DAEMON");
   const { flags } = parsed;
   const idsFlag = optional(flags, "task-ids");
   const repoFlag = optional(flags, "repo");
@@ -6597,7 +7091,7 @@ async function collect(client, parsed) {
     taskIds = idsFlag.split(",").map((s) => s.trim()).filter(Boolean);
   } else if (repoFlag) {
     const { resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
-    const target = resolveRepoRoot2(resolve4(process.cwd(), repoFlag));
+    const target = resolveRepoRoot2(resolveRepoFlag(repoFlag));
     const { tasks } = await client.request("task.list");
     taskIds = tasks.filter((t) => !t.archived && resolveRepoRoot2(t.repo) === target).map((t) => t.id);
   } else {
@@ -6623,72 +7117,67 @@ async function collect(client, parsed) {
   return { tasks: out };
 }
 async function runApiSubcommand(argv) {
-  const [verb, ...rest] = argv;
-  if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
-    if (!verb) {
+  const [verbName, ...rest] = argv;
+  if (!verbName || verbName === "--help" || verbName === "-h" || verbName === "help") {
+    if (!verbName)
       fail(apiUsage(), "MISSING_VERB", 2);
-    }
     process.stdout.write(`${apiUsage()}
 `);
     return;
   }
-  if (!API_VERBS.includes(verb)) {
-    fail(`unknown verb: ${verb}
-${apiUsage()}`, "BAD_VERB", 2);
-  }
-  let parsed;
+  const verb = findVerb(verbName);
+  if (!verb)
+    fail(`unknown verb: ${verbName}
+${apiUsage()}`, "BAD_VERB", 2);
+  const booleanFlags = new Set(verb.flags.filter((f) => f.type === "bool").map((f) => f.name));
+  let parsed;
+  try {
+    parsed = parseFlags(rest, booleanFlags);
+  } catch (err) {
+    if (err instanceof ApiError)
+      fail(err.message, err.code, 2);
+    fail(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
+  }
+  if (parsed.help) {
+    process.stdout.write(`${verbHelp(verb)}
+`);
+    return;
+  }
   try {
-    parsed = parseFlags(rest);
+    validateAgainstSpec(verb, parsed.flags);
   } catch (err) {
     if (err instanceof ApiError)
       fail(err.message, err.code, 2);
     fail(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
   }
-  let client;
-  try {
-    client = await connectOrStartDaemon();
-  } catch (err) {
-    fail(`could not reach or start the kobe daemon: ${err instanceof Error ? err.message : String(err)}`, "BAD_DAEMON", 2);
+  let client = null;
+  if (!verb.offline) {
+    try {
+      client = await connectOrStartDaemon();
+    } catch (err) {
+      fail(`could not reach or start the kobe daemon: ${err instanceof Error ? err.message : String(err)}`, "BAD_DAEMON", 2);
+    }
   }
   try {
-    let result;
-    switch (verb) {
-      case "spawn-task":
-        result = await spawnTask(client, parsed);
-        break;
-      case "fan-out":
-        result = await fanOut(client, parsed);
-        break;
-      case "send":
-        result = await send(client, parsed);
-        break;
-      case "get-task":
-        result = await getTask(client, parsed);
-        break;
-      case "collect":
-        result = await collect(client, parsed);
-        break;
-      case "list":
-        result = await list(client);
-        break;
-    }
+    const result = await verb.handler(client, parsed);
     emit(result, parsed.pretty);
   } catch (err) {
     if (err instanceof ApiError)
       fail(err.message, err.code, 1);
     fail(err instanceof Error ? err.message : String(err), "RPC_ERROR", 1);
   } finally {
-    client.close();
+    client?.close();
   }
 }
-var API_VERBS, FANOUT_CAP = 10, ApiError;
+var API_SCHEMA_VERSION = 2, FANOUT_CAP = 10, TASK_STATUSES, ApiError, F, VERB_ALIASES, VERB_GROUPS, VERBS, API_VERBS, GLOBAL_FLAGS;
 var init_api_cmd = __esm(() => {
   init_daemon_process();
   init_interactive_command();
   init_client2();
   init_prompt_delivery();
   init_vendor();
-  API_VERBS = ["spawn-task", "fan-out", "send", "get-task", "collect", "list"];
+  init_version();
+  TASK_STATUSES = ["backlog", "in_progress", "in_review", "done", "canceled", "error"];
   ApiError = class ApiError extends Error {
     code;
     constructor(message, code) {
@@ -6696,6 +7185,241 @@ var init_api_cmd = __esm(() => {
       this.code = code;
     }
   };
+  F = {
+    repo: (required = true) => ({
+      name: "repo",
+      type: "string",
+      required,
+      placeholder: "PATH",
+      description: "Repo root (git toplevel). Relative paths resolve against $PWD."
+    }),
+    taskId: (required = true) => ({
+      name: "task-id",
+      type: "string",
+      required,
+      placeholder: "ID",
+      description: "Target task id (from `list` / `add`)."
+    }),
+    vendor: () => ({
+      name: "vendor",
+      type: "enum",
+      values: ALL_VENDORS,
+      placeholder: "V",
+      description: "Engine vendor for the task."
+    }),
+    title: () => ({ name: "title", type: "string", placeholder: "T", description: "Human task title." }),
+    prompt: (required, desc) => ({
+      name: "prompt",
+      type: "string",
+      required,
+      placeholder: "TEXT",
+      description: desc
+    })
+  };
+  VERB_ALIASES = { "spawn-task": "add" };
+  VERB_GROUPS = {
+    discover: ["schema"],
+    read: ["list", "get-task", "collect"],
+    create: ["add", "fan-out"],
+    drive: ["send", "set-active"],
+    edit: ["rename", "set-branch", "set-vendor", "set-status"],
+    lifecycle: ["archive", "pin", "delete"],
+    worktree: ["ensure-worktree", "adopt", "discover-adoptable"]
+  };
+  VERBS = [
+    {
+      name: "schema",
+      summary: "Explore the API. Default = a COMPACT index (groups + verb summaries, no flags). Drill in with --verb / --group; --all for the full spec.",
+      flags: [
+        { name: "verb", type: "string", placeholder: "NAME", description: "Full flag detail for ONE verb." },
+        { name: "group", type: "string", placeholder: "G", description: "List the verbs in one group (compact)." },
+        {
+          name: "all",
+          type: "bool",
+          description: "The COMPLETE spec \u2014 every verb AND every flag (large; avoid by default)."
+        }
+      ],
+      offline: true,
+      handler: handleSchema
+    },
+    { name: "list", summary: "List all tasks (incl. archived). Returns { tasks }.", flags: [], handler: list },
+    {
+      name: "get-task",
+      summary: "Read one task's metadata. `.running` = its tmux session is live.",
+      flags: [F.taskId()],
+      handler: getTask
+    },
+    {
+      name: "add",
+      summary: "Create a task (shows in the sidebar immediately). With --prompt it also starts the engine and delivers it. Alias: spawn-task.",
+      flags: [
+        F.repo(),
+        F.title(),
+        {
+          name: "branch",
+          type: "string",
+          placeholder: "B",
+          description: "Explicit branch name (else auto kobe/<slug>-<id>)."
+        },
+        { name: "base-branch", type: "string", placeholder: "B", description: "Base ref the worktree branches from." },
+        F.vendor(),
+        {
+          name: "status",
+          type: "enum",
+          values: TASK_STATUSES,
+          default: "backlog",
+          description: "Initial lifecycle status."
+        },
+        { name: "pin", type: "bool", description: "Pin the task to the top of the sidebar." },
+        F.prompt(false, "Optional first message \u2014 when set, materializes the worktree, starts the engine, and pastes it.")
+      ],
+      handler: add
+    },
+    {
+      name: "fan-out",
+      summary: `Spawn N tasks of ONE prompt in a single call (parallel attempts). Capped at ${FANOUT_CAP}.`,
+      flags: [
+        F.repo(),
+        F.prompt(true, "Shared prompt delivered to every spawned task."),
+        { name: "count", type: "int", placeholder: "N", description: "Number of tasks of one vendor (with --vendor)." },
+        {
+          name: "agents",
+          type: "string",
+          placeholder: "claude:2,codex:1",
+          description: "Per-vendor counts (alternative to --count)."
+        },
+        F.vendor(),
+        F.title(),
+        { name: "base-branch", type: "string", placeholder: "B", description: "Base ref for every worktree." }
+      ],
+      handler: fanOut
+    },
+    {
+      name: "send",
+      summary: "Paste a follow-up prompt into a task's running engine (one full turn). Defaults to the active task.",
+      flags: [F.taskId(false), F.prompt(true, "Text pasted + submitted into the engine pane.")],
+      handler: send
+    },
+    {
+      name: "collect",
+      summary: "Read-only comparison snapshot of several tasks (identity, branch, .running, uncommitted .changes).",
+      flags: [
+        { name: "task-ids", type: "csv", placeholder: "a,b,c", description: "Comma-separated task ids." },
+        F.repo(false)
+      ],
+      handler: collect
+    },
+    {
+      name: "rename",
+      summary: "Set a task's title.",
+      flags: [F.taskId(), { name: "title", type: "string", required: true, placeholder: "T", description: "New title." }],
+      handler: (c, p) => simpleRpc(c, "task.rename", { taskId: required(p.flags, "task-id"), title: required(p.flags, "title") })
+    },
+    {
+      name: "set-branch",
+      summary: "Rename a task's branch (git branch -m if materialized, else recorded).",
+      flags: [
+        F.taskId(),
+        { name: "branch", type: "string", required: true, placeholder: "B", description: "New branch name." }
+      ],
+      handler: (c, p) => simpleRpc(c, "task.setBranch", { taskId: required(p.flags, "task-id"), branch: required(p.flags, "branch") })
+    },
+    {
+      name: "set-vendor",
+      summary: "Change a task's engine vendor (takes effect on next session rebuild).",
+      flags: [F.taskId(), { ...F.vendor(), required: true }],
+      handler: (c, p) => simpleRpc(c, "task.setVendor", {
+        taskId: required(p.flags, "task-id"),
+        vendor: requireEnum(p.flags, "vendor", ALL_VENDORS)
+      })
+    },
+    {
+      name: "set-status",
+      summary: "Set a task's lifecycle status.",
+      flags: [
+        F.taskId(),
+        { name: "status", type: "enum", required: true, values: TASK_STATUSES, description: "New status." }
+      ],
+      handler: (c, p) => simpleRpc(c, "task.status", {
+        taskId: required(p.flags, "task-id"),
+        status: requireEnum(p.flags, "status", TASK_STATUSES)
+      })
+    },
+    {
+      name: "archive",
+      summary: "Archive (or with --archived=false, unarchive) a task. Non-destructive: worktree/branch/history stay.",
+      flags: [
+        F.taskId(),
+        { name: "archived", type: "bool", default: "true", description: "true to archive, false to unarchive." }
+      ],
+      handler: (c, p) => simpleRpc(c, "task.archive", {
+        taskId: required(p.flags, "task-id"),
+        archived: optionalBool(p.flags, "archived") ?? true
+      })
+    },
+    {
+      name: "pin",
+      summary: "Pin (or with --pinned=false, unpin) a task to the top of the sidebar.",
+      flags: [F.taskId(), { name: "pinned", type: "bool", default: "true", description: "true to pin, false to unpin." }],
+      handler: (c, p) => simpleRpc(c, "task.pin", {
+        taskId: required(p.flags, "task-id"),
+        pinned: optionalBool(p.flags, "pinned") ?? true
+      })
+    },
+    {
+      name: "set-active",
+      summary: "Set the shared active task (the focus every Tasks pane highlights). Pass --none to clear.",
+      flags: [
+        F.taskId(false),
+        { name: "none", type: "bool", description: "Clear the active task instead of setting one." }
+      ],
+      handler: setActive
+    },
+    {
+      name: "ensure-worktree",
+      summary: "Materialize a task's git worktree on disk now (without starting an engine). Returns { worktreePath }.",
+      flags: [F.taskId()],
+      handler: (c, p) => simpleRpc(c, "task.ensureWorktree", { taskId: required(p.flags, "task-id") })
+    },
+    {
+      name: "delete",
+      summary: "Permanently remove a task (and its worktree). DESTRUCTIVE \u2014 prefer `archive`. Needs --force on a dirty worktree.",
+      flags: [F.taskId(), { name: "force", type: "bool", description: "Delete even with uncommitted changes." }],
+      handler: (c, p) => simpleRpc(c, "task.delete", {
+        taskId: required(p.flags, "task-id"),
+        force: optionalBool(p.flags, "force") ?? false
+      })
+    },
+    {
+      name: "discover-adoptable",
+      summary: "List existing git worktrees in a repo not yet tracked as kobe tasks. Returns { worktrees }.",
+      flags: [F.repo()],
+      handler: (c, p) => simpleRpc(c, "worktree.discoverAdoptable", { repo: resolveRepoFlag(required(p.flags, "repo")) })
+    },
+    {
+      name: "adopt",
+      summary: "Import an existing git worktree as a kobe task. Returns { task }.",
+      flags: [
+        F.repo(),
+        {
+          name: "worktree",
+          type: "string",
+          required: true,
+          placeholder: "PATH",
+          description: "Path of the worktree to adopt."
+        },
+        { name: "branch", type: "string", placeholder: "B", description: "Branch override (else the worktree's own)." },
+        F.vendor(),
+        F.title()
+      ],
+      handler: adopt
+    }
+  ];
+  API_VERBS = VERBS.map((v) => v.name);
+  GLOBAL_FLAGS = [
+    { name: "pretty", type: "bool", description: "Pretty-print stdout JSON." },
+    { name: "help", type: "bool", description: "Show usage for the verb and exit." }
+  ];
 });
 
 // src/cli/update.ts
@@ -6836,9 +7560,9 @@ var init_schema = () => {};
 
 // src/tui/context/theme/loader.ts
 import { readFileSync as readFileSync4, readdirSync } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function userThemesDir() {
-  return join5(kobeStateDir(), "themes");
+  return join6(kobeStateDir(), "themes");
 }
 function loadUserThemes() {
   const dir = userThemesDir();
@@ -6852,7 +7576,7 @@ function loadUserThemes() {
   for (const file of entries) {
     if (!file.endsWith(".json"))
       continue;
-    const path6 = join5(dir, file);
+    const path6 = join6(dir, file);
     let parsed;
     try {
       const text = readFileSync4(path6, "utf8");
@@ -6882,8 +7606,8 @@ var exports_theme = {};
 __export(exports_theme, {
   runThemeSubcommand: () => runThemeSubcommand
 });
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename3, join as join6, resolve as resolve5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3, join as join7, resolve as resolve5 } from "path";
 function fail2(message) {
   process.stderr.write(`kobe theme: ${message}
 `);
@@ -6914,7 +7638,7 @@ function listThemes() {
   } else {
     for (const f of userFiles) {
       const name = f.slice(0, -".json".length);
-      const path6 = join6(dir, f);
+      const path6 = join7(dir, f);
       const overridesBundled = BUNDLED_NAMES.includes(name) ? " (overrides built-in)" : "";
       lines.push(`  ${name}${overridesBundled}  ${path6}`);
     }
@@ -7004,8 +7728,8 @@ async function addTheme(args) {
   }
   const dir = userThemesDir();
   mkdirSync3(dir, { recursive: true });
-  const dest = join6(dir, `${name}.json`);
-  if (existsSync3(dest) && !opts.force) {
+  const dest = join7(dir, `${name}.json`);
+  if (existsSync4(dest) && !opts.force) {
     fail2(`${dest} already exists (pass --force to overwrite)`);
   }
   writeFileSync2(dest, `${JSON.stringify(result.theme, null, 2)}
@@ -7022,8 +7746,8 @@ function removeTheme(args) {
   if (BUNDLED_NAMES.includes(name)) {
     fail2(`"${name}" is a built-in theme and cannot be removed`);
   }
-  const dest = join6(userThemesDir(), `${name}.json`);
-  if (!existsSync3(dest)) {
+  const dest = join7(userThemesDir(), `${name}.json`);
+  if (!existsSync4(dest)) {
     fail2(`no user theme named "${name}" (looked for ${dest})`);
   }
   unlinkSync(dest);
@@ -7206,31 +7930,66 @@ var init_daemon_cmd = __esm(() => {
 });
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
+function npxSkillsArgv(opts = {}) {
+  return ["skills", "add", SKILL_SOURCE_SLUG, "--skill", "kobe", "--agent", opts.agent ?? DEFAULT_SKILL_AGENT];
+}
+function npxSkillsCommand(opts = {}) {
+  return `npx ${npxSkillsArgv(opts).join(" ")}`;
+}
 function kobeSkillPaths(opts = {}) {
   const home = opts.home ?? homedir9();
   const cwd = opts.cwd ?? process.cwd();
-  return [join7(home, SKILL_REL_PATH), join7(cwd, SKILL_REL_PATH)];
+  return [join8(home, SKILL_REL_PATH), join8(cwd, SKILL_REL_PATH)];
 }
-function isKobeSkillInstalled(opts) {
-  return kobeSkillPaths(opts).some((p) => existsSync4(p));
+function parseSkillVersion(content) {
+  const m = content.match(/kobe-skill-version:\s*(\d+)/);
+  return m ? Number.parseInt(m[1], 10) : null;
+}
+function kobeSkillState(opts) {
+  const path6 = kobeSkillPaths(opts).find((p) => existsSync5(p));
+  if (!path6) {
+    return { installed: false, installedVersion: null, currentVersion: KOBE_SKILL_VERSION, stale: false };
+  }
+  let installedVersion = null;
+  try {
+    installedVersion = parseSkillVersion(readFileSync6(path6, "utf8"));
+  } catch {
+    installedVersion = null;
+  }
+  const stale = installedVersion === null || installedVersion < KOBE_SKILL_VERSION;
+  return { installed: true, installedVersion, currentVersion: KOBE_SKILL_VERSION, stale };
 }
 function maybeHintSkillInstall() {
-  if (isKobeSkillInstalled())
-    return;
-  if (getPersistedString(HINT_SEEN_KEY) === "1")
+  const state = kobeSkillState();
+  if (!state.installed) {
+    if (getPersistedString(HINT_SEEN_KEY) === "1")
+      return;
+    setPersistedString(HINT_SEEN_KEY, "1");
+    process.stderr.write(`
+kobe: the kobe agent skill isn't installed \u2014 install it so your coding agent can drive kobe via \`kobe api\`:
+  ${SKILL_INSTALL_COMMAND}
+  (wraps \`${npxSkillsCommand()}\`; check anytime with \`kobe doctor\`)
+
+`);
     return;
-  setPersistedString(HINT_SEEN_KEY, "1");
-  process.stderr.write(`
-kobe: the kobe agent skill isn't installed \u2014 install it so Claude Code can fan out parallel tasks via \`kobe api\`:
+  }
+  if (state.stale) {
+    const key = `${HINT_SEEN_KEY}:v${state.currentVersion}`;
+    if (getPersistedString(key) === "1")
+      return;
+    setPersistedString(key, "1");
+    const was = state.installedVersion === null ? "an older" : `v${state.installedVersion}`;
+    process.stderr.write(`
+kobe: your kobe agent skill is out of date (${was}; this kobe wants v${state.currentVersion}) \u2014 refresh it so \`kobe api\` guidance matches:
   ${SKILL_INSTALL_COMMAND}
-  (check anytime with \`kobe doctor\`)
 
 `);
+  }
 }
-var SKILL_REL_PATH = ".claude/skills/kobe/SKILL.md", SKILL_INSTALL_COMMAND = "npx skills add Sma1lboy/kobe --skill kobe --agent claude-code", HINT_SEEN_KEY = "skillHintSeen";
+var KOBE_SKILL_VERSION = 1, SKILL_REL_PATH = ".claude/skills/kobe/SKILL.md", SKILL_INSTALL_COMMAND = "kobe skill install", SKILL_SOURCE_SLUG = "Sma1lboy/kobe", DEFAULT_SKILL_AGENT = "claude-code", HINT_SEEN_KEY = "skillHintSeen";
 var init_skill_install = __esm(() => {
   init_repos();
 });
@@ -7242,9 +8001,9 @@ __export(exports_maintenance, {
   runReloadSubcommand: () => runReloadSubcommand,
   runDoctorSubcommand: () => runDoctorSubcommand
 });
-import { existsSync as existsSync5, readFileSync as readFileSync6, statSync } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, statSync } from "fs";
 import { unlink as unlink6 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { createInterface } from "readline";
 function isProcessAlive2(pid) {
   try {
@@ -7291,7 +8050,7 @@ function describeFile(path6) {
 }
 function taskCount(tasksPath) {
   try {
-    const parsed = JSON.parse(readFileSync6(tasksPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(tasksPath, "utf8"));
     return Array.isArray(parsed.tasks) ? parsed.tasks.length : null;
   } catch {
     return null;
@@ -7299,7 +8058,7 @@ function taskCount(tasksPath) {
 }
 function tailFile(path6, n) {
   try {
-    const lines = readFileSync6(path6, "utf8").split(`
+    const lines = readFileSync7(path6, "utf8").split(`
 `).filter((l) => l.trim().length > 0);
     return lines.slice(-n).join(`
 `);
@@ -7341,7 +8100,7 @@ async function runDoctorSubcommand(argv = []) {
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
   const logPath = defaultDaemonLogPath();
-  const tasksPath = join8(kobeStateDir(), "tasks.json");
+  const tasksPath = join9(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   const out = ["kobe doctor", `  home:   ${homeDir()}`, `  socket: ${socketPath}`, ""];
   const status = await probeDaemonStatus(socketPath);
@@ -7362,7 +8121,7 @@ async function runDoctorSubcommand(argv = []) {
     } else {
       out.push("daemon:  \u2717 not running (no pidfile)");
     }
-    if (existsSync5(socketPath))
+    if (existsSync6(socketPath))
       out.push(`         orphan socket file present: ${socketPath}`);
     const tail = tailFile(logPath, 8);
     if (tail) {
@@ -7379,11 +8138,16 @@ async function runDoctorSubcommand(argv = []) {
     out.push("tmux:    \u2717 not found on PATH (task sessions need tmux)");
   }
   out.push("");
-  if (isKobeSkillInstalled()) {
-    out.push("skill:   \u2713 kobe agent skill installed");
-  } else {
-    out.push("skill:   \u2717 kobe agent skill not installed (optional \u2014 lets Claude Code drive `kobe api`)");
+  const skill = kobeSkillState();
+  if (!skill.installed) {
+    out.push("skill:   \u2717 kobe agent skill not installed (optional \u2014 lets a coding agent drive `kobe api`)");
+    out.push(`         \u2192 ${SKILL_INSTALL_COMMAND}`);
+  } else if (skill.stale) {
+    const was = skill.installedVersion === null ? "unstamped" : `v${skill.installedVersion}`;
+    out.push(`skill:   \u26A0 kobe agent skill out of date (${was}; this kobe wants v${skill.currentVersion})`);
     out.push(`         \u2192 ${SKILL_INSTALL_COMMAND}`);
+  } else {
+    out.push(`skill:   \u2713 kobe agent skill installed (v${skill.installedVersion})`);
   }
   out.push("");
   const count = taskCount(tasksPath);
@@ -7448,7 +8212,7 @@ async function runResetSubcommand(argv) {
   const yes = argv.includes("--yes") || argv.includes("-y");
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
-  const tasksPath = join8(kobeStateDir(), "tasks.json");
+  const tasksPath = join9(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   console.log("kobe reset will:");
   console.log("  \u2022 stop the kobe daemon (graceful \u2192 SIGTERM \u2192 SIGKILL)");
@@ -7551,6 +8315,275 @@ var init_maintenance = __esm(() => {
   init_client2();
 });
 
+// src/cli/skill-cmd.ts
+var exports_skill_cmd = {};
+__export(exports_skill_cmd, {
+  runSkillSubcommand: () => runSkillSubcommand
+});
+function skillUsage() {
+  return [
+    "usage: kobe skill <verb>",
+    "",
+    "verbs:",
+    "  install [--agent NAME]   Install the kobe agent skill (wraps `npx skills add`)",
+    "  status                   Show whether the skill is installed",
+    "  command [--agent NAME]   Print the underlying npx command without running it",
+    "",
+    `The skill teaches a coding agent how to drive \`kobe api\`. Default agent: ${DEFAULT_SKILL_AGENT}.`
+  ].join(`
+`);
+}
+function parseAgent(rest) {
+  let agent = DEFAULT_SKILL_AGENT;
+  for (let i = 0;i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--agent") {
+      const v = rest[i + 1];
+      if (!v || v.startsWith("--")) {
+        process.stderr.write(`kobe skill: --agent requires a value
+`);
+        process.exit(2);
+      }
+      agent = v;
+      i++;
+    } else if (arg.startsWith("--agent=")) {
+      agent = arg.slice("--agent=".length);
+    } else {
+      process.stderr.write(`kobe skill: unknown flag "${arg}"
+
+${skillUsage()}
+`);
+      process.exit(2);
+    }
+  }
+  return agent;
+}
+async function runSkillSubcommand(argv) {
+  const [verb, ...rest] = argv;
+  if (!verb || verb === "--help" || verb === "-h" || verb === "help") {
+    process.stdout.write(`${skillUsage()}
+`);
+    if (!verb)
+      process.exitCode = 2;
+    return;
+  }
+  if (!SKILL_VERBS.includes(verb)) {
+    process.stderr.write(`kobe skill: unknown verb "${verb}"
+
+${skillUsage()}
+`);
+    process.exit(2);
+  }
+  if (verb === "status") {
+    const state = kobeSkillState();
+    const [userPath, projectPath] = kobeSkillPaths();
+    const head = !state.installed ? "\u2717 not installed" : state.stale ? `\u26A0 out of date (installed ${state.installedVersion === null ? "unstamped" : `v${state.installedVersion}`}, this kobe wants v${state.currentVersion})` : `\u2713 installed (v${state.installedVersion})`;
+    process.stdout.write([
+      `kobe skill: ${head}`,
+      `  looked in: ${userPath}`,
+      `             ${projectPath}`,
+      state.installed && !state.stale ? "" : "  \u2192 run `kobe skill install` to install / refresh",
+      ""
+    ].join(`
+`));
+    return;
+  }
+  if (verb === "command") {
+    process.stdout.write(`${npxSkillsCommand({ agent: parseAgent(rest) })}
+`);
+    return;
+  }
+  const agent = parseAgent(rest);
+  const args = npxSkillsArgv({ agent });
+  process.stdout.write(`kobe skill: running \`npx ${args.join(" ")}\`
+`);
+  const proc = Bun.spawn(["npx", ...args], { stdin: "inherit", stdout: "inherit", stderr: "inherit" });
+  const code = await proc.exited;
+  if (code !== 0) {
+    process.stderr.write(`
+kobe skill install failed (npx exited ${code}). Is \`npx\` on PATH and are you online?
+` + `You can run it yourself: ${npxSkillsCommand({ agent })}
+`);
+    process.exit(code || 1);
+  }
+  process.stdout.write(`kobe skill: installed.
+`);
+}
+var SKILL_VERBS;
+var init_skill_cmd = __esm(() => {
+  init_skill_install();
+  SKILL_VERBS = ["install", "status", "command"];
+});
+
+// src/cli/hook-cmd.ts
+var exports_hook_cmd = {};
+__export(exports_hook_cmd, {
+  runHookSubcommand: () => runHookSubcommand
+});
+import { homedir as homedir10 } from "os";
+import { dirname as dirname7, join as join10, resolve as resolve6 } from "path";
+async function readStdinPayload() {
+  try {
+    const text = await Promise.race([
+      Bun.stdin.text(),
+      new Promise((resolve7) => setTimeout(() => resolve7(""), 500))
+    ]);
+    if (!text.trim())
+      return {};
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function failureFromErrorType(errorType) {
+  if (typeof errorType !== "string")
+    return "other";
+  if (errorType === "rate_limit" || errorType === "overloaded")
+    return "rate_limit";
+  if (errorType === "billing_error")
+    return "billing";
+  return "other";
+}
+function flagValue(argv, name) {
+  for (let i = 0;i < argv.length; i++) {
+    if (argv[i] === name)
+      return argv[i + 1];
+    if (argv[i].startsWith(`${name}=`))
+      return argv[i].slice(name.length + 1);
+  }
+  return;
+}
+async function runHookSubcommand(argv) {
+  const [verb, ...rest] = argv;
+  if (verb === "setup") {
+    await runHookSetup(rest);
+    return;
+  }
+  try {
+    if (verb === "worktree-created") {
+      await reportWorktreeCreated();
+      return;
+    }
+    if (!verb || !isEngineActivityKind(verb))
+      return;
+    const taskId = flagValue(rest, "--task-id");
+    if (!taskId)
+      return;
+    const payload = await readStdinPayload();
+    let detail;
+    if (verb === "turn-failed") {
+      detail = { failure: failureFromErrorType(payload.error_type) };
+    } else if (verb === "awaiting-input") {
+      detail = { waiting: "permission" };
+    }
+    const client = await connectIfRunning();
+    if (!client)
+      return;
+    try {
+      await client.request("engine.reportEvent", { taskId, kind: verb, ...detail ? { detail } : {} });
+    } finally {
+      client.close();
+    }
+  } catch {}
+}
+async function reportWorktreeCreated() {
+  const payload = await readStdinPayload();
+  const worktreePath = typeof payload.worktree_path === "string" ? payload.worktree_path : undefined;
+  if (!worktreePath)
+    return;
+  const repo = await deriveRepoRoot(worktreePath);
+  if (!repo)
+    return;
+  const client = await connectIfRunning();
+  if (!client)
+    return;
+  try {
+    await client.request("worktree.adopt", { repo, worktreePath, ifExists: "return" });
+  } finally {
+    client.close();
+  }
+}
+async function deriveRepoRoot(worktreePath) {
+  try {
+    const proc = Bun.spawn(["git", "-C", worktreePath, "rev-parse", "--path-format=absolute", "--git-common-dir"], {
+      stdout: "pipe",
+      stderr: "ignore"
+    });
+    const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+    if (code !== 0)
+      return;
+    const commonDir = out.trim();
+    return commonDir ? dirname7(commonDir) : undefined;
+  } catch {
+    return;
+  }
+}
+function syncSettingsPath(scope) {
+  if (scope.kind === "repo")
+    return join10(resolve6(scope.path), ".claude", "settings.json");
+  return join10(homedir10(), ".claude", "settings.json");
+}
+function worktreeSyncAdapters() {
+  return ALL_VENDORS.map((v) => createEngineHookAdapter(v)).filter((a) => a.supportsWorktreeSync());
+}
+async function runHookSetup(argv) {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write([
+      "Usage: kobe hook setup [--global | --repo <path> | --off]",
+      "",
+      "Install (or remove with --off) the hook that syncs an external",
+      "`claude --worktree` into kobe as a task. Default: --global (~/.claude).",
+      ""
+    ].join(`
+`));
+    return;
+  }
+  const off = argv.includes("--off");
+  const repoIdx = argv.indexOf("--repo");
+  const repoPath = repoIdx !== -1 ? argv[repoIdx + 1] : undefined;
+  if (repoIdx !== -1 && !repoPath) {
+    process.stderr.write(`kobe hook setup: --repo requires a path
+`);
+    process.exit(2);
+  }
+  const adapters = worktreeSyncAdapters();
+  if (adapters.length === 0) {
+    process.stdout.write(`kobe hook setup: no engine supports external worktree sync \u2014 nothing to do
+`);
+    return;
+  }
+  if (off) {
+    const prev = getPersistedString(SYNC_SETTING_KEY);
+    const path7 = prev?.startsWith("repo:") ? syncSettingsPath({ kind: "repo", path: prev.slice(5) }) : syncSettingsPath({ kind: "global" });
+    for (const a of adapters)
+      await a.removeWorktreeSyncHook(path7);
+    setPersistedString(SYNC_SETTING_KEY, "off");
+    process.stdout.write(`kobe hook setup: external worktree sync disabled (removed from ${path7})
+`);
+    return;
+  }
+  const scope = repoPath ? { kind: "repo", path: repoPath } : { kind: "global" };
+  const path6 = syncSettingsPath(scope);
+  for (const a of adapters)
+    await a.installWorktreeSyncHook(path6);
+  setPersistedString(SYNC_SETTING_KEY, scope.kind === "repo" ? `repo:${resolve6(scope.path)}` : "global");
+  process.stdout.write([
+    `kobe hook setup: external worktree sync enabled (${scope.kind}) \u2014 wrote ${path6}`,
+    "New `claude --worktree` worktrees will appear as kobe tasks.",
+    ""
+  ].join(`
+`));
+}
+var SYNC_SETTING_KEY = "externalWorktreeSync";
+var init_hook_cmd = __esm(() => {
+  init_daemon_process();
+  init_hook_adapter2();
+  init_hook_events();
+  init_repos();
+  init_vendor();
+});
+
 // ../../node_modules/.bun/entities@7.0.1/node_modules/entities/dist/esm/decode-codepoint.js
 function replaceCodePoint(codePoint) {
   var _a2;
@@ -8836,6 +9869,8 @@ class RemoteOrchestrator {
   setActiveTaskSig;
   updateAcc;
   setUpdateSig;
+  engineStateAcc;
+  setEngineStateSig;
   connectionStateAcc;
   setConnectionState;
   ensureReachable;
@@ -8846,6 +9881,7 @@ class RemoteOrchestrator {
     const [tasks, setTasks] = createSignal([]);
     const [activeTask, setActiveTask] = createSignal(null);
     const [update, setUpdate] = createSignal(null);
+    const [engineState, setEngineState] = createSignal(new Map);
     const [connectionState, setConnectionState] = createSignal("online");
     this.tasksAcc = tasks;
     this.setTasks = (next) => setTasks(() => next);
@@ -8853,6 +9889,8 @@ class RemoteOrchestrator {
     this.setActiveTaskSig = (next) => setActiveTask(() => next);
     this.updateAcc = update;
     this.setUpdateSig = (next) => setUpdate(() => next);
+    this.engineStateAcc = engineState;
+    this.setEngineStateSig = (next) => setEngineState(() => next);
     this.connectionStateAcc = connectionState;
     this.setConnectionState = (next) => setConnectionState(() => next);
     this.ensureReachable = options.ensureReachable ?? ensureDaemonReachable;
@@ -8931,6 +9969,9 @@ class RemoteOrchestrator {
   updateSignal() {
     return this.updateAcc;
   }
+  engineStateSignal() {
+    return this.engineStateAcc;
+  }
   listTasks() {
     return this.tasksAcc();
   }
@@ -9021,6 +10062,18 @@ class RemoteOrchestrator {
       this.setUpdateSig(info ?? null);
       return;
     }
+    if (name === "engine-state") {
+      const p = payload;
+      if (typeof p?.taskId !== "string" || typeof p.state !== "string")
+        return;
+      const next = new Map(this.engineStateAcc());
+      if (p.state === "idle")
+        next.delete(p.taskId);
+      else
+        next.set(p.taskId, { state: p.state, detail: p.detail, at: typeof p.at === "number" ? p.at : 0 });
+      this.setEngineStateSig(next);
+      return;
+    }
   }
 }
 function deserializeTask(s) {
@@ -10706,7 +11759,7 @@ function addTheme2(name, theme) {
 }
 function resolveTheme(theme, mode = "dark") {
   const defs = theme.defs ?? {};
-  function resolve6(c, chain = []) {
+  function resolve7(c, chain = []) {
     if (typeof c === "string") {
       if (c === "transparent" || c === "none")
         return RGBA.fromInts(0, 0, 0, 0);
@@ -10718,13 +11771,13 @@ function resolveTheme(theme, mode = "dark") {
       const next = defs[c] ?? theme.theme[c];
       if (next === undefined)
         return RGBA.fromInts(0, 0, 0);
-      return resolve6(next, [...chain, c]);
+      return resolve7(next, [...chain, c]);
     }
-    return resolve6(c[mode], chain);
+    return resolve7(c[mode], chain);
   }
   const out = {};
   for (const [k, v] of Object.entries(theme.theme)) {
-    out[k] = resolve6(v);
+    out[k] = resolve7(v);
   }
   const text = out.text ?? RGBA.fromHex("#ffffff");
   const background = out.background ?? RGBA.fromHex("#000000");
@@ -11503,7 +12556,7 @@ function findAvailableFolderName(parentDir, base) {
   return trimmed;
 }
 function cloneRepo(url, target, onProgress) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     let stderrBuf = "";
     try {
       const child = spawn2("git", ["clone", "--progress", url, target], {
@@ -11520,18 +12573,18 @@ function cloneRepo(url, target, onProgress) {
         }
       });
       child.on("error", (err) => {
-        resolve6({ ok: false, error: err.message });
+        resolve7({ ok: false, error: err.message });
       });
       child.on("close", (code) => {
         if (code === 0) {
-          resolve6({ ok: true, path: target });
+          resolve7({ ok: true, path: target });
           return;
         }
         const tail = stderrBuf.split(/[\r\n]+/).filter((s) => s.trim().length > 0).pop() ?? `git clone exited with ${code}`;
-        resolve6({ ok: false, error: tail });
+        resolve7({ ok: false, error: tail });
       });
     } catch (err) {
-      resolve6({ ok: false, error: err instanceof Error ? err.message : String(err) });
+      resolve7({ ok: false, error: err instanceof Error ? err.message : String(err) });
     }
   });
 }
@@ -12594,7 +13647,7 @@ var init_dialog2 = __esm(() => {
 
 // src/tui/component/new-task-dialog/index.tsx
 function show(dialog, defaultRepo, savedRepos, options) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     dialog.replace(() => createComponent2(NewTaskDialogView, {
       defaultRepo,
       savedRepos,
@@ -12607,9 +13660,9 @@ function show(dialog, defaultRepo, savedRepos, options) {
       get discoverAdoptable() {
         return options?.discoverAdoptable;
       },
-      onSubmit: (v) => resolve6(v),
-      onCancel: () => resolve6(undefined)
-    }), () => resolve6(undefined));
+      onSubmit: (v) => resolve7(v),
+      onCancel: () => resolve7(undefined)
+    }), () => resolve7(undefined));
     dialog.setSize("medium");
   });
 }
@@ -12701,15 +13754,15 @@ var init_dialog3 = __esm(() => {
 
 // src/tui/component/rename-task-dialog/index.tsx
 function show2(dialog, currentTitle, opts = {}) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     dialog.replace(() => createComponent2(RenameTaskDialogView, {
       currentTitle,
       get dialogTitle() {
         return opts.dialogTitle;
       },
-      onSubmit: (v) => resolve6(v),
-      onCancel: () => resolve6(undefined)
-    }), () => resolve6(undefined));
+      onSubmit: (v) => resolve7(v),
+      onCancel: () => resolve7(undefined)
+    }), () => resolve7(undefined));
   });
 }
 var RenameTaskDialog;
@@ -12723,8 +13776,8 @@ var init_rename_task_dialog = __esm(() => {
 
 // src/engine/claude-code-local/binary.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { homedir as homedir11 } from "os";
+import { existsSync as existsSync8, statSync as statSync3 } from "fs";
+import { homedir as homedir12 } from "os";
 import path7 from "path";
 async function findClaudeBinary(deps = defaultDeps4) {
   const checked = [];
@@ -12797,7 +13850,7 @@ var init_binary = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir11();
+      return homedir12();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -12810,7 +13863,7 @@ var init_binary = __esm(() => {
         return;
       if (first.startsWith("claude:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync7(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync8(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -12827,8 +13880,8 @@ var init_binary = __esm(() => {
 
 // src/engine/codex-local/binary.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync8, statSync as statSync4 } from "fs";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync9, statSync as statSync4 } from "fs";
+import { homedir as homedir13 } from "os";
 import path8 from "path";
 async function findCodexBinary(deps = defaultDeps5) {
   const checked = [];
@@ -12885,7 +13938,7 @@ var init_binary2 = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir12();
+      return homedir13();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -12898,7 +13951,7 @@ var init_binary2 = __esm(() => {
         return;
       if (first.startsWith("codex:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync8(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -12915,8 +13968,8 @@ var init_binary2 = __esm(() => {
 
 // src/engine/copilot-local/binary.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync9, statSync as statSync5 } from "fs";
-import { homedir as homedir13 } from "os";
+import { existsSync as existsSync10, statSync as statSync5 } from "fs";
+import { homedir as homedir14 } from "os";
 import path9 from "path";
 async function findCopilotBinary(deps = defaultDeps6) {
   const checked = [];
@@ -12997,7 +14050,7 @@ var init_binary3 = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir13();
+      return homedir14();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -13010,7 +14063,7 @@ var init_binary3 = __esm(() => {
         return;
       if (first.startsWith("copilot:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync10(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -13021,8 +14074,8 @@ var init_binary3 = __esm(() => {
 });
 
 // src/engine/account-detect.ts
-import { readFileSync as readFileSync7, statSync as statSync6 } from "fs";
-import { homedir as homedir14 } from "os";
+import { readFileSync as readFileSync8, statSync as statSync6 } from "fs";
+import { homedir as homedir15 } from "os";
 import path10 from "path";
 function claudeGlobalConfigPath(env, home) {
   const override = env("CLAUDE_CONFIG_DIR")?.trim();
@@ -13234,13 +14287,13 @@ var init_account_detect = __esm(() => {
           return null;
         throw err;
       }
-      return readFileSync7(p, "utf8");
+      return readFileSync8(p, "utf8");
     },
     env(name) {
       return process.env[name];
     },
     home() {
-      return homedir14();
+      return homedir15();
     },
     findClaudeBinary() {
       return findClaudeBinary();
@@ -13379,18 +14432,18 @@ var init_dialog_confirm = __esm(() => {
   init_keymap();
   init_dialog();
   DialogConfirm.show = (dialog, title, message, label, confirmLabel, options) => {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       dialog.replace(() => createComponent2(DialogConfirm, {
         title,
         message,
-        onConfirm: () => resolve6(true),
-        onCancel: () => resolve6(false),
+        onConfirm: () => resolve7(true),
+        onCancel: () => resolve7(false),
         label,
         confirmLabel,
         get initialActive() {
           return options?.initialActive;
         }
-      }), () => resolve6(undefined));
+      }), () => resolve7(undefined));
       dialog.setSize("small");
     });
   };
@@ -13398,7 +14451,7 @@ var init_dialog_confirm = __esm(() => {
 
 // src/tui/component/settings-dialog/actions.ts
 import { unlinkSync as unlinkSync2 } from "fs";
-import { join as join10 } from "path";
+import { join as join12 } from "path";
 function hasRestartableDaemon(orchestrator) {
   return orchestrator instanceof RemoteOrchestrator;
 }
@@ -13415,7 +14468,7 @@ async function confirmResetState(dialog, kv, renderer) {
     return;
   kv.clear();
   try {
-    unlinkSync2(join10(homeDir(), ".kobe", "tasks.json"));
+    unlinkSync2(join12(homeDir(), ".kobe", "tasks.json"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error("kobe: failed to delete tasks.json during reset:", err);
@@ -14706,17 +15759,17 @@ var init_settings_dialog = __esm(() => {
   init_sections();
   SettingsDialog.show = (dialog, kv, orchestrator) => {
     let visualPrefsChanged = false;
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       dialog.replace(() => createComponent2(SettingsDialog, {
         kv,
         orchestrator,
         onVisualPrefsChange: () => {
           visualPrefsChanged = true;
         },
-        onClose: () => resolve6({
+        onClose: () => resolve7({
           visualPrefsChanged
         })
-      }), () => resolve6({
+      }), () => resolve7({
         visualPrefsChanged
       }));
     });
@@ -14785,12 +15838,12 @@ var init_focus = __esm(() => {
 });
 
 // src/tui/context/kv.tsx
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname6 } from "path";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname8 } from "path";
 function loadInitial() {
   const statePath2 = kvStatePath();
   try {
-    const text = readFileSync8(statePath2, "utf8");
+    const text = readFileSync9(statePath2, "utf8");
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -14814,7 +15867,7 @@ var init_kv = __esm(() => {
       function writeNow(label) {
         const statePath2 = kvStatePath();
         try {
-          mkdirSync4(dirname6(statePath2), {
+          mkdirSync4(dirname8(statePath2), {
             recursive: true
           });
           const tmp = `${statePath2}.tmp`;
@@ -14869,7 +15922,7 @@ var init_kv = __esm(() => {
           }
           const statePath2 = kvStatePath();
           try {
-            mkdirSync4(dirname6(statePath2), {
+            mkdirSync4(dirname8(statePath2), {
               recursive: true
             });
             const tmp = `${statePath2}.tmp`;
@@ -14886,10 +15939,10 @@ var init_kv = __esm(() => {
 });
 
 // src/tui/lib/persisted-ui-prefs.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 function readPersistedUiPrefs(fallbackTheme) {
   try {
-    const parsed = JSON.parse(readFileSync9(kvStatePath(), "utf8"));
+    const parsed = JSON.parse(readFileSync10(kvStatePath(), "utf8"));
     const theme = typeof parsed.activeTheme === "string" && hasTheme(parsed.activeTheme) ? parsed.activeTheme : fallbackTheme;
     const transparent = parsed.transparentBackground === true;
     const focusAccent = typeof parsed.focusAccent === "string" && FOCUS_ACCENT_SLOTS.includes(parsed.focusAccent) ? parsed.focusAccent : null;
@@ -14905,8 +15958,8 @@ var init_persisted_ui_prefs = __esm(() => {
 
 // src/tui/lib/worktree-opener.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync10 } from "fs";
-import { basename as basename4, delimiter, isAbsolute, join as join11 } from "path";
+import { existsSync as existsSync11 } from "fs";
+import { basename as basename4, delimiter, isAbsolute, join as join13 } from "path";
 function executableOnPath(command, env, exists) {
   if (isAbsolute(command))
     return exists(command);
@@ -14914,7 +15967,7 @@ function executableOnPath(command, env, exists) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir)
       continue;
-    if (exists(join11(dir, command)))
+    if (exists(join13(dir, command)))
       return true;
   }
   return false;
@@ -14934,7 +15987,7 @@ function labelForOverride(command) {
 function detectWorktreeOpener(deps = {}) {
   const env = deps.env ?? process.env;
   const platform = deps.platform ?? process.platform;
-  const exists = deps.exists ?? existsSync10;
+  const exists = deps.exists ?? existsSync11;
   const override = env.KOBE_OPEN_EDITOR?.trim();
   if (override) {
     return { id: "env", label: labelForOverride(override), command: override, args: [] };
@@ -16269,7 +17322,34 @@ function Sidebar(props) {
           return readWorktreeChanges(task.worktreePath);
         });
         const titleText = isMain ? repoBasename(task.repo) : task.title;
-        const loading = () => isLive() || !isMain && task.status === "in_progress";
+        const activity = () => props.engineState?.().get(task.id)?.state;
+        const loading = () => activity() === "running" || isLive() || !isMain && task.status === "in_progress";
+        const activityChip = () => {
+          switch (activity()) {
+            case "rate_limited":
+              return {
+                text: "limited",
+                tone: "warning"
+              };
+            case "permission_needed":
+              return {
+                text: "approve?",
+                tone: "warning"
+              };
+            case "error":
+              return {
+                text: "error",
+                tone: "error"
+              };
+            case "turn_complete":
+              return {
+                text: "done",
+                tone: "primary"
+              };
+            default:
+              return null;
+          }
+        };
         const subtitleText = createMemo(() => {
           if (task.branch.length > 0)
             return truncateBranchLabel(task.branch, subtitleBudget());
@@ -16432,6 +17512,18 @@ function Sidebar(props) {
                     return _el$43;
                   }
                 }), null);
+                insert(_el$40, createComponent2(Show, {
+                  get when() {
+                    return memo2(() => !!!loading())() && activityChip();
+                  },
+                  children: (chip) => (() => {
+                    var _el$55 = createElement("text");
+                    setProp(_el$55, "wrapMode", "none");
+                    insert(_el$55, () => chip().text);
+                    effect((_$p) => setProp(_el$55, "fg", chip().tone === "error" ? theme.error : chip().tone === "warning" ? theme.warning : theme.primary, _$p));
+                    return _el$55;
+                  })()
+                }), null);
                 effect((_p$) => {
                   var _v$22 = barColor(), _v$23 = badgeColor(), _v$24 = TextAttributes8.BOLD, _v$25 = theme.text, _v$26 = isSelected() || isCursor() ? TextAttributes8.BOLD : undefined;
                   _v$22 !== _p$.e && (_p$.e = setProp(_el$39, "fg", _v$22, _p$.e));
@@ -16577,43 +17669,43 @@ function Sidebar(props) {
         const left = createMemo(() => Math.max(0, Math.min(h().x + 2, dims().width - boxW() - 1)));
         const top = createMemo(() => Math.max(0, Math.min(h().y + 1, dims().height - boxH() - 1)));
         return (() => {
-          var _el$55 = createElement("box");
-          setProp(_el$55, "position", "absolute");
-          setProp(_el$55, "zIndex", 2600);
-          setProp(_el$55, "flexDirection", "column");
-          setProp(_el$55, "border", true);
-          setProp(_el$55, "paddingLeft", 1);
-          setProp(_el$55, "paddingRight", 1);
-          insert(_el$55, createComponent2(For, {
+          var _el$56 = createElement("box");
+          setProp(_el$56, "position", "absolute");
+          setProp(_el$56, "zIndex", 2600);
+          setProp(_el$56, "flexDirection", "column");
+          setProp(_el$56, "border", true);
+          setProp(_el$56, "paddingLeft", 1);
+          setProp(_el$56, "paddingRight", 1);
+          insert(_el$56, createComponent2(For, {
             get each() {
               return lines();
             },
             children: (l) => (() => {
-              var _el$56 = createElement("text");
-              setProp(_el$56, "wrapMode", "none");
-              insert(_el$56, (() => {
+              var _el$57 = createElement("text");
+              setProp(_el$57, "wrapMode", "none");
+              insert(_el$57, (() => {
                 var _c$4 = memo2(() => !!l.dim);
                 return () => _c$4() ? truncatePathTail(l.text, innerW()) : truncateTitle(l.text, innerW());
               })());
               effect((_p$) => {
                 var _v$35 = l.dim ? theme.textMuted : theme.text, _v$36 = l.bold ? TextAttributes8.BOLD : l.dim ? TextAttributes8.DIM : undefined;
-                _v$35 !== _p$.e && (_p$.e = setProp(_el$56, "fg", _v$35, _p$.e));
-                _v$36 !== _p$.t && (_p$.t = setProp(_el$56, "attributes", _v$36, _p$.t));
+                _v$35 !== _p$.e && (_p$.e = setProp(_el$57, "fg", _v$35, _p$.e));
+                _v$36 !== _p$.t && (_p$.t = setProp(_el$57, "attributes", _v$36, _p$.t));
                 return _p$;
               }, {
                 e: undefined,
                 t: undefined
               });
-              return _el$56;
+              return _el$57;
             })()
           }));
           effect((_p$) => {
             var _v$30 = left(), _v$31 = top(), _v$32 = boxW(), _v$33 = theme.focusAccent, _v$34 = theme.backgroundElement;
-            _v$30 !== _p$.e && (_p$.e = setProp(_el$55, "left", _v$30, _p$.e));
-            _v$31 !== _p$.t && (_p$.t = setProp(_el$55, "top", _v$31, _p$.t));
-            _v$32 !== _p$.a && (_p$.a = setProp(_el$55, "width", _v$32, _p$.a));
-            _v$33 !== _p$.o && (_p$.o = setProp(_el$55, "borderColor", _v$33, _p$.o));
-            _v$34 !== _p$.i && (_p$.i = setProp(_el$55, "backgroundColor", _v$34, _p$.i));
+            _v$30 !== _p$.e && (_p$.e = setProp(_el$56, "left", _v$30, _p$.e));
+            _v$31 !== _p$.t && (_p$.t = setProp(_el$56, "top", _v$31, _p$.t));
+            _v$32 !== _p$.a && (_p$.a = setProp(_el$56, "width", _v$32, _p$.a));
+            _v$33 !== _p$.o && (_p$.o = setProp(_el$56, "borderColor", _v$33, _p$.o));
+            _v$34 !== _p$.i && (_p$.i = setProp(_el$56, "backgroundColor", _v$34, _p$.i));
             return _p$;
           }, {
             e: undefined,
@@ -16622,7 +17714,7 @@ function Sidebar(props) {
             o: undefined,
             i: undefined
           });
-          return _el$55;
+          return _el$56;
         })();
       }
     }), null);
@@ -16708,7 +17800,7 @@ var exports_host = {};
 __export(exports_host, {
   startTasksPane: () => startTasksPane
 });
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { TextAttributes as TextAttributes9 } from "@opentui/core";
 function TasksShell(props) {
   const themeCtx = useTheme();
@@ -16943,7 +18035,7 @@ function TasksShell(props) {
   async function openSelectedWorktree(id) {
     const task = props.tasks().find((t) => t.id === id);
     let worktree = task?.worktreePath;
-    if (!worktree || !existsSync11(worktree)) {
+    if (!worktree || !existsSync12(worktree)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         return;
@@ -16956,7 +18048,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!worktree || !existsSync11(worktree))
+    if (!worktree || !existsSync12(worktree))
       return;
     const opener = detectWorktreeOpener();
     if (!opener) {
@@ -17007,7 +18099,7 @@ function TasksShell(props) {
     const exists = await sessionExists(name);
     if (exists) {
       const cwd2 = await getSessionOption(name, "@kobe_worktree") || task?.worktreePath || "";
-      if (cwd2 && existsSync11(cwd2)) {
+      if (cwd2 && existsSync12(cwd2)) {
         await ensureSession({
           name,
           cwd: cwd2,
@@ -17021,7 +18113,7 @@ function TasksShell(props) {
       return;
     }
     let cwd = task?.worktreePath;
-    if (!cwd || !existsSync11(cwd)) {
+    if (!cwd || !existsSync12(cwd)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         return;
@@ -17034,7 +18126,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!cwd || !existsSync11(cwd))
+    if (!cwd || !existsSync12(cwd))
       return;
     const init2 = task?.repo ? resolveRepoInit(task.repo, cwd) : {};
     const ready = await ensureSession({
@@ -17083,6 +18175,9 @@ function TasksShell(props) {
       headerStatus,
       onHeaderStatusClick: () => void openUpdate(),
       width: () => dimensions().width,
+      get engineState() {
+        return memo2(() => !!props.orch)() ? props.orch.engineStateSignal() : undefined;
+      },
       onAddTask: () => void createTask(),
       onRenameRequest: (id) => void renameTask(id),
       onDeleteRequest: (id) => void deleteTask(id),
@@ -17302,6 +18397,7 @@ var init_host = __esm(() => {
   init_solid();
   init_solid();
   init_solid();
+  init_solid();
   init_client2();
   init_solid();
   init_dev();
@@ -17652,13 +18748,13 @@ function releaseBodyLines(body) {
 function waitForKeypress() {
   if (!process.stdin.isTTY)
     return Promise.resolve();
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const stdin = process.stdin;
     const done = () => {
       stdin.off("data", done);
       stdin.setRawMode?.(false);
       stdin.pause();
-      resolve6();
+      resolve7();
     };
     stdin.setRawMode?.(true);
     stdin.resume();
@@ -17724,7 +18820,7 @@ function UpdatePage() {
   }
   async function runUpdater() {
     setStatus("Leaving the TUI page and running the updater in this tmux window...");
-    await new Promise((resolve6) => setTimeout(resolve6, 30));
+    await new Promise((resolve7) => setTimeout(resolve7, 30));
     renderer?.destroy();
     process.stdout.write(`
 kobe ${CURRENT_VERSION} -> latest
@@ -18031,7 +19127,7 @@ var init_host4 = __esm(() => {
 });
 
 // src/engine/turn-detector.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 
 class EngineTurnDetector {
   supportsCompletionMarkers() {
@@ -18054,7 +19150,7 @@ function latestClaudeCompletionMarkerFromJsonl(raw, sourceId = "claude", fallbac
     const record = parseJsonLine(line);
     if (!record)
       continue;
-    const inner = isObject6(record.message) ? record.message : record;
+    const inner = isObject7(record.message) ? record.message : record;
     if (inner.role !== "assistant")
       continue;
     if (!("content" in inner))
@@ -18096,7 +19192,7 @@ function parseJsonLine(line) {
     return null;
   try {
     const parsed = JSON.parse(trimmed);
-    return isObject6(parsed) ? parsed : null;
+    return isObject7(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -18105,7 +19201,7 @@ function timestampFromRecord(record, fallback) {
   const ts = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN;
   return Number.isFinite(ts) ? ts : fallback;
 }
-function isObject6(v) {
+function isObject7(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 var ClaudeTurnDetector, CodexTurnDetector, UnknownTurnDetector;
@@ -18118,7 +19214,7 @@ var init_turn_detector = __esm(() => {
       const files = await listSessionFilesForWorktree(worktree);
       let latest = null;
       for (const file of files.slice(0, 4)) {
-        const raw = await readFile6(file.path, "utf8").catch(() => "");
+        const raw = await readFile7(file.path, "utf8").catch(() => "");
         const marker = latestClaudeCompletionMarkerFromJsonl(raw, file.path, file.mtimeMs);
         if (marker && (!latest || marker.timestampMs > latest.timestampMs))
           latest = marker;
@@ -18137,7 +19233,7 @@ var init_turn_detector = __esm(() => {
         if (scanned >= 12)
           break;
         scanned++;
-        const raw = await readFile6(file, "utf8").catch(() => "");
+        const raw = await readFile7(file, "utf8").catch(() => "");
         if (!raw || rolloutCwd(raw) !== worktree)
           continue;
         return latestCodexCompletionMarkerFromJsonl(raw, file);
@@ -18386,7 +19482,7 @@ var gitWrapper;
 var init_git2 = __esm(() => {
   gitWrapper = {
     spawn(args, cwd) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const child = nodeSpawn("git", [...args], {
           cwd,
           shell: false,
@@ -18405,7 +19501,7 @@ var init_git2 = __esm(() => {
         });
         child.on("error", reject);
         child.on("close", (status, signal) => {
-          resolve6({ stdout, stderr, status, signal });
+          resolve7({ stdout, stderr, status, signal });
         });
       });
     }
@@ -18459,14 +19555,14 @@ var init_keys2 = __esm(() => {
 
 // src/tui/panes/filetree/open-external.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { platform } from "os";
 function openExternally(absPath) {
   if (!absPath)
     return;
   const plat = platform();
   if (plat === "linux") {
-    if (existsSync12("/proc/sys/fs/binfmt_misc/WSLInterop") || process.env.WSL_DISTRO_NAME) {
+    if (existsSync13("/proc/sys/fs/binfmt_misc/WSLInterop") || process.env.WSL_DISTRO_NAME) {
       spawnDetached("wslview", [absPath], () => {
         const child = spawn5("wslpath", ["-w", absPath], { stdio: ["ignore", "pipe", "ignore"] });
         let out = "";
@@ -19857,7 +20953,7 @@ __export(exports_direct, {
   startDirectTmux: () => startDirectTmux,
   chooseInitialTask: () => chooseInitialTask
 });
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 function chooseInitialTask(tasks, choice = {}) {
   const byId = (id) => id ? tasks.find((t) => t.id === id) : undefined;
   const active = byId(choice.activeTaskId);
@@ -19893,7 +20989,7 @@ async function ensureRepos(orchestrator) {
   normalizeSavedRepos();
   let repos = [...getSavedRepos()];
   if (repos.length === 0) {
-    const added = addSavedRepo(resolve6(process.cwd()));
+    const added = addSavedRepo(resolve7(process.cwd()));
     repos = [added.path];
   }
   for (const repo of repos) {
@@ -19903,7 +20999,7 @@ async function ensureRepos(orchestrator) {
       console.error(`[kobe] ensureMainTask failed for ${repo}:`, err);
     }
   }
-  return repos[0] ?? resolve6(process.cwd());
+  return repos[0] ?? resolve7(process.cwd());
 }
 async function startDirectTmux() {
   setClientLogContext("gui");
@@ -20500,9 +21596,9 @@ var pulse_default = "../pulse-n3cq1btw.wav";
 var init_pulse = () => {};
 
 // src/tui/lib/sound.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync5 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename6, isAbsolute as isAbsolute2, join as join12, resolve as resolve7 } from "path";
+import { basename as basename6, isAbsolute as isAbsolute2, join as join14, resolve as resolve8 } from "path";
 function args(player, file, volume) {
   if (player === "ffplay")
     return [player, "-autoexit", "-nodisp", "-af", `volume=${volume}`, file];
@@ -20525,13 +21621,13 @@ function pickPlayer() {
     return cachedPlayer;
   const path12 = process.env.PATH ?? "";
   const segments = path12.split(":").filter(Boolean);
-  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync13(join12(dir, p)))) ?? null;
+  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync14(join14(dir, p)))) ?? null;
   return cachedPlayer;
 }
 async function ensureAsset() {
   cachedPath ??= (async () => {
     mkdirSync5(DIR, { recursive: true });
-    const dest = join12(DIR, basename6(pulseAsset));
+    const dest = join14(DIR, basename6(pulseAsset));
     const out = Bun.file(dest);
     if (await out.exists())
       return dest;
@@ -20560,8 +21656,8 @@ function pulse(volume = 0.4) {
 var pulseAsset, DIR, PLAYERS, cachedPlayer, cachedPath;
 var init_sound = __esm(() => {
   init_pulse();
-  pulseAsset = isAbsolute2(pulse_default) ? pulse_default : resolve7(import.meta.dir, pulse_default);
-  DIR = join12(tmpdir2(), "kobe-sfx");
+  pulseAsset = isAbsolute2(pulse_default) ? pulse_default : resolve8(import.meta.dir, pulse_default);
+  DIR = join14(tmpdir2(), "kobe-sfx");
   PLAYERS = [
     "ffplay",
     "mpv",
@@ -21087,7 +22183,7 @@ var init_use_theme_persistence = __esm(() => {
 });
 
 // src/monitor/cost.ts
-import { readFile as readFile7 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 async function summarizeTaskCost(opts) {
   const files = await listSessionFilesForWorktree(opts.worktree);
   const base = {
@@ -21109,7 +22205,7 @@ async function summarizeTaskCost(opts) {
   for (const file of files) {
     let raw;
     try {
-      raw = await readFile7(file.path, "utf8");
+      raw = await readFile8(file.path, "utf8");
     } catch {
       continue;
     }
@@ -21620,7 +22716,7 @@ var exports_app = {};
 __export(exports_app, {
   startApp: () => startApp
 });
-import { homedir as homedir15 } from "os";
+import { homedir as homedir16 } from "os";
 function Shell(props) {
   const themeCtx = useTheme();
   const {
@@ -22128,7 +23224,7 @@ async function startApp() {
   } of loadUserThemes()) {
     addTheme2(name, theme);
   }
-  const homeDir2 = process.env.KOBE_HOME_DIR ?? homedir15();
+  const homeDir2 = process.env.KOBE_HOME_DIR ?? homedir16();
   let orchestrator;
   if (process.env.KOBE_NO_DAEMON === "1") {
     const store2 = new TaskIndexStore({
@@ -22241,7 +23337,7 @@ var init_tui = __esm(() => {
 // src/cli/index.ts
 init_path_glob();
 init_vendor();
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 
 // src/cli/usage.ts
 init_version();
@@ -22260,6 +23356,7 @@ function topLevelUsage() {
     "  api <verb>              Scriptable RPC surface for agents (see `kobe api --help`)",
     "  daemon <verb>           Manage the daemon (start|stop|status|restart)",
     "  theme <verb>            Manage user themes (list|add|remove)",
+    "  skill <verb>            Install the kobe agent skill (install|status|command)",
     "  update [target]         Self-update kobe",
     "  doctor                  Diagnose daemon / tmux / state (read-only)",
     "  reset [--hard]          Recover a wedged install",
@@ -22289,7 +23386,7 @@ Usage: kobe add [path]
 `);
     process.exit(2);
   }
-  const target = resolve8(process.cwd(), arg && arg.length > 0 ? arg : ".");
+  const target = resolve9(process.cwd(), arg && arg.length > 0 ? arg : ".");
   const { addSavedRepo: addSavedRepo2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
   const result = addSavedRepo2(target);
   if (result.added) {
@@ -22388,7 +23485,7 @@ async function runAdoptSubcommand(args2) {
     }
   }
   const { resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
-  const repo = resolveRepoRoot2(resolve8(process.cwd(), repoArg && repoArg.length > 0 ? repoArg : "."));
+  const repo = resolveRepoRoot2(resolve9(process.cwd(), repoArg && repoArg.length > 0 ? repoArg : "."));
   const vendor = coerceVendorId(vendorArg);
   const orch = await openLocalOrchestrator();
   const worktrees = await orch.discoverAdoptableWorktrees(repo);
@@ -22521,6 +23618,16 @@ async function main() {
     await runReloadSubcommand2(rest);
     return;
   }
+  if (subcommand === "skill") {
+    const { runSkillSubcommand: runSkillSubcommand2 } = await Promise.resolve().then(() => (init_skill_cmd(), exports_skill_cmd));
+    await runSkillSubcommand2(rest);
+    return;
+  }
+  if (subcommand === "hook") {
+    const { runHookSubcommand: runHookSubcommand2 } = await Promise.resolve().then(() => (init_hook_cmd(), exports_hook_cmd));
+    await runHookSubcommand2(rest);
+    return;
+  }
   if (subcommand === "new-chattab") {
     const flags = parseOpsFlags(rest);
     const session = flags.session;