@sma1lboy/kobe 0.7.8 → 0.7.10

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.8",
+    version: "0.7.10",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -4997,6 +4997,58 @@ var init_auto_title_poller = __esm(() => {
   init_chat_tab_naming();
 });
 
+// src/daemon/cwd-task.ts
+function normalize(p) {
+  return p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+}
+function isAncestorOrSelf(wt, cwd) {
+  return cwd === wt || cwd.startsWith(`${wt}/`);
+}
+function matchTaskByCwd(tasks, cwd) {
+  const target = normalize(cwd);
+  let bestId;
+  let bestLen = -1;
+  for (const t of tasks) {
+    if (!t.worktreePath)
+      continue;
+    const wt = normalize(t.worktreePath);
+    if (isAncestorOrSelf(wt, target) && wt.length > bestLen) {
+      bestLen = wt.length;
+      bestId = t.id;
+    }
+  }
+  return bestId;
+}
+function findAdoptableWorktree(tasks, cwd) {
+  const target = normalize(cwd);
+  const repos = new Set;
+  const known = new Set;
+  for (const t of tasks) {
+    if (t.repo)
+      repos.add(normalize(t.repo));
+    if (t.worktreePath)
+      known.add(normalize(t.worktreePath));
+  }
+  const seg = `/${KOBE_WORKTREE_ROOT_SUBPATH}/`;
+  for (const repo of repos) {
+    const prefix = `${repo}${seg}`;
+    if (!target.startsWith(prefix))
+      continue;
+    const rest = target.slice(prefix.length);
+    const name = rest.split("/")[0];
+    if (!name)
+      continue;
+    const worktreePath = `${prefix}${name}`;
+    if (known.has(worktreePath))
+      return;
+    return { repo, worktreePath };
+  }
+  return;
+}
+var init_cwd_task = __esm(() => {
+  init_paths();
+});
+
 // src/daemon/event-bus.ts
 class DaemonEventBus {
   last = new Map;
@@ -5317,10 +5369,24 @@ async function startDaemonServer(orch, options = {}) {
         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 explicitId = optionalString(payload, "taskId");
+        const cwd = optionalString(payload, "cwd");
+        if (!explicitId && cwd && kind === "session-start") {
+          const cand = findAdoptableWorktree(orch.listTasks(), cwd);
+          if (cand) {
+            try {
+              await orch.adoptWorktree({ repo: cand.repo, worktreePath: cand.worktreePath, ifExists: "return" });
+            } catch (err) {
+              logDaemonError("worktree-autosync", err);
+            }
+          }
+        }
+        const taskId = explicitId ?? (cwd ? matchTaskByCwd(orch.listTasks(), cwd) : undefined);
+        if (!taskId)
+          return {};
         const detail = optionalActivityDetail(payload);
         reportActivity(taskId, kind, detail);
         return {};
@@ -5464,6 +5530,7 @@ var init_server = __esm(() => {
   init_hook_events();
   init_version();
   init_auto_title_poller();
+  init_cwd_task();
   init_paths2();
   init_protocol();
   DEFAULT_UPDATE_POLL_MS = 6 * 60 * 60 * 1000;
@@ -5863,172 +5930,6 @@ var init_prompt_delivery = __esm(() => {
   init_client2();
 });
 
-// src/engine/claude-code-local/hook-adapter.ts
-import { existsSync as existsSync2 } from "fs";
-import { appendFile as appendFile3, mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { dirname as dirname6, join as join4 } from "path";
-function isObject6(v) {
-  return !!v && typeof v === "object" && !Array.isArray(v);
-}
-async function readJsonObject(path6) {
-  try {
-    const parsed = JSON.parse(await readFile6(path6, "utf8"));
-    return isObject6(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function isKobeWorktreeSyncGroup(group) {
-  if (!isObject6(group) || !Array.isArray(group.hooks))
-    return false;
-  return group.hooks.some((h) => isObject6(h) && typeof h.command === "string" && h.command.includes(WORKTREE_SYNC_MARKER));
-}
-function mergeWorktreeSyncHook(current, command) {
-  const { hooks: rawHooks, ...restSettings } = current;
-  const { WorktreeCreate, ...otherHooks } = isObject6(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);
-    if (JSON.stringify(next) === JSON.stringify(current))
-      return;
-    await mkdir5(dirname6(settingsFilePath), { recursive: true });
-    await writeFile4(settingsFilePath, `${JSON.stringify(next, null, 2)}
-`);
-  }
-  async installTaskHooks(ctx) {
-    try {
-      const claudeDir = join4(ctx.worktreeDir, ".claude");
-      const settingsPath = join4(claudeDir, "settings.local.json");
-      await mkdir5(claudeDir, { recursive: true });
-      let current = {};
-      try {
-        const raw = await readFile6(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 writeFile4(settingsPath, `${JSON.stringify(current, null, 2)}
-`);
-      await hideFromGit(ctx.worktreeDir, ".claude/settings.local.json");
-    } catch {}
-  }
-}
-async function hideFromGit(worktreeDir, relPath) {
-  if (hiddenWorktrees.has(worktreeDir))
-    return;
-  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 = join4(worktreeDir, commonDir);
-    const excludePath = join4(commonDir, "info", "exclude");
-    const existing = existsSync2(excludePath) ? await readFile6(excludePath, "utf8") : "";
-    if (existing.split(`
-`).some((l) => l.trim() === relPath)) {
-      hiddenWorktrees.add(worktreeDir);
-      return;
-    }
-    await mkdir5(join4(commonDir, "info"), { recursive: true });
-    await appendFile3(excludePath, `${existing.endsWith(`
-`) || existing === "" ? "" : `
-`}${relPath}
-`);
-    hiddenWorktrees.add(worktreeDir);
-  } catch {}
-}
-var EVENT_MAP, KOBE_HOOK_EVENTS, WORKTREE_SYNC_MARKER = "worktree-created", hiddenWorktrees;
-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);
-  hiddenWorktrees = new Set;
-});
-
-// 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/tui/panes/terminal/tmux.ts
 var exports_tmux = {};
 __export(exports_tmux, {
@@ -6079,12 +5980,6 @@ async function ensureSession(opts) {
   }
 }
 async function ensureSessionImpl(opts) {
-  if (opts.taskId && opts.cwd && opts.cwd.includes(`/${KOBE_WORKTREE_ROOT_SUBPATH}/`)) {
-    await createEngineHookAdapter(coerceVendorId(opts.vendor)).installTaskHooks({
-      worktreeDir: opts.cwd,
-      taskId: opts.taskId
-    });
-  }
   if (await sessionExists(opts.name)) {
     const sessionOptions = await getSessionOptions(opts.name, ["@kobe_worktree", "@kobe_vendor"]);
     const taggedWorktree = sessionOptions["@kobe_worktree"] ?? "";
@@ -6499,10 +6394,8 @@ async function quickCreate(session) {
 var CHAT_TAB_SWITCH_BINDINGS, CHAT_TAB_CLOSE_BINDING, CHAT_TAB_RENAME_BINDING, CHAT_TAB_ENGINE_PROMPT, CHAT_TAB_CHOOSE_ENGINE_BINDINGS, CHAT_TAB_STATE_OPTION = "@kobe_tab_state", PANE_VERSION_OPTION = "@kobe_pane_version", CHAT_TAB_STATUS_FORMAT = "#{?#{==:#{@kobe_tab_state},running},\u25CF,#{?#{==:#{@kobe_tab_state},done},\u2713,#{?#{==:#{@kobe_tab_state},error},!,#{?#{==:#{@kobe_tab_state},unknown},?,\u25CB}}}} #I:#W", CHAT_TAB_STATUS_CURRENT_FORMAT, ensureSessionLocks;
 var init_tmux = __esm(() => {
   init_invocation();
-  init_hook_adapter2();
   init_interactive_command();
   init_env();
-  init_paths();
   init_client2();
   init_prompt_delivery();
   init_vendor();
@@ -6545,14 +6438,14 @@ var exports_repo_init = {};
 __export(exports_repo_init, {
   resolveRepoInit: () => resolveRepoInit
 });
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
 function repoFileScript(worktreePath) {
-  return existsSync3(join5(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
+  return existsSync2(join4(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
 }
 function repoFilePrompt(worktreePath) {
-  const p = join5(worktreePath, INIT_PROMPT_REL);
-  if (!existsSync3(p))
+  const p = join4(worktreePath, INIT_PROMPT_REL);
+  if (!existsSync2(p))
     return;
   try {
     const text = readFileSync3(p, "utf8");
@@ -6573,8 +6466,8 @@ function resolveRepoInit(repoRoot, worktreePath) {
 var INIT_SCRIPT_REL, INIT_PROMPT_REL;
 var init_repo_init = __esm(() => {
   init_repos();
-  INIT_SCRIPT_REL = join5(".kobe", "init.sh");
-  INIT_PROMPT_REL = join5(".kobe", "init-prompt.md");
+  INIT_SCRIPT_REL = join4(".kobe", "init.sh");
+  INIT_PROMPT_REL = join4(".kobe", "init-prompt.md");
 });
 
 // src/tui/panes/sidebar/worktree-changes.ts
@@ -7586,9 +7479,9 @@ var init_schema = () => {};
 
 // src/tui/context/theme/loader.ts
 import { readFileSync as readFileSync4, readdirSync } from "fs";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 function userThemesDir() {
-  return join6(kobeStateDir(), "themes");
+  return join5(kobeStateDir(), "themes");
 }
 function loadUserThemes() {
   const dir = userThemesDir();
@@ -7602,7 +7495,7 @@ function loadUserThemes() {
   for (const file of entries) {
     if (!file.endsWith(".json"))
       continue;
-    const path6 = join6(dir, file);
+    const path6 = join5(dir, file);
     let parsed;
     try {
       const text = readFileSync4(path6, "utf8");
@@ -7632,8 +7525,8 @@ var exports_theme = {};
 __export(exports_theme, {
   runThemeSubcommand: () => runThemeSubcommand
 });
-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";
+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";
 function fail2(message) {
   process.stderr.write(`kobe theme: ${message}
 `);
@@ -7664,7 +7557,7 @@ function listThemes() {
   } else {
     for (const f of userFiles) {
       const name = f.slice(0, -".json".length);
-      const path6 = join7(dir, f);
+      const path6 = join6(dir, f);
       const overridesBundled = BUNDLED_NAMES.includes(name) ? " (overrides built-in)" : "";
       lines.push(`  ${name}${overridesBundled}  ${path6}`);
     }
@@ -7754,8 +7647,8 @@ async function addTheme(args) {
   }
   const dir = userThemesDir();
   mkdirSync3(dir, { recursive: true });
-  const dest = join7(dir, `${name}.json`);
-  if (existsSync4(dest) && !opts.force) {
+  const dest = join6(dir, `${name}.json`);
+  if (existsSync3(dest) && !opts.force) {
     fail2(`${dest} already exists (pass --force to overwrite)`);
   }
   writeFileSync2(dest, `${JSON.stringify(result.theme, null, 2)}
@@ -7772,8 +7665,8 @@ function removeTheme(args) {
   if (BUNDLED_NAMES.includes(name)) {
     fail2(`"${name}" is a built-in theme and cannot be removed`);
   }
-  const dest = join7(userThemesDir(), `${name}.json`);
-  if (!existsSync4(dest)) {
+  const dest = join6(userThemesDir(), `${name}.json`);
+  if (!existsSync3(dest)) {
     fail2(`no user theme named "${name}" (looked for ${dest})`);
   }
   unlinkSync(dest);
@@ -7956,9 +7849,9 @@ var init_daemon_cmd = __esm(() => {
 });
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 function npxSkillsArgv(opts = {}) {
   return ["skills", "add", SKILL_SOURCE_SLUG, "--skill", "kobe", "--agent", opts.agent ?? DEFAULT_SKILL_AGENT];
 }
@@ -7968,14 +7861,14 @@ function npxSkillsCommand(opts = {}) {
 function kobeSkillPaths(opts = {}) {
   const home = opts.home ?? homedir9();
   const cwd = opts.cwd ?? process.cwd();
-  return [join8(home, SKILL_REL_PATH), join8(cwd, SKILL_REL_PATH)];
+  return [join7(home, SKILL_REL_PATH), join7(cwd, SKILL_REL_PATH)];
 }
 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));
+  const path6 = kobeSkillPaths(opts).find((p) => existsSync4(p));
   if (!path6) {
     return { installed: false, installedVersion: null, currentVersion: KOBE_SKILL_VERSION, stale: false };
   }
@@ -8027,9 +7920,9 @@ __export(exports_maintenance, {
   runReloadSubcommand: () => runReloadSubcommand,
   runDoctorSubcommand: () => runDoctorSubcommand
 });
-import { existsSync as existsSync6, readFileSync as readFileSync7, statSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync7, statSync } from "fs";
 import { unlink as unlink6 } from "fs/promises";
-import { join as join9 } from "path";
+import { join as join8 } from "path";
 import { createInterface } from "readline";
 function isProcessAlive2(pid) {
   try {
@@ -8126,7 +8019,7 @@ async function runDoctorSubcommand(argv = []) {
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
   const logPath = defaultDaemonLogPath();
-  const tasksPath = join9(kobeStateDir(), "tasks.json");
+  const tasksPath = join8(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   const out = ["kobe doctor", `  home:   ${homeDir()}`, `  socket: ${socketPath}`, ""];
   const status = await probeDaemonStatus(socketPath);
@@ -8154,7 +8047,7 @@ async function runDoctorSubcommand(argv = []) {
     } else {
       out.push("daemon:  \u2717 not running (no pidfile)");
     }
-    if (existsSync6(socketPath))
+    if (existsSync5(socketPath))
       out.push(`         orphan socket file present: ${socketPath}`);
     const tail = tailFile(logPath, 8);
     if (tail) {
@@ -8245,7 +8138,7 @@ async function runResetSubcommand(argv) {
   const yes = argv.includes("--yes") || argv.includes("-y");
   const socketPath = defaultDaemonSocketPath();
   const pidPath = defaultDaemonPidPath();
-  const tasksPath = join9(kobeStateDir(), "tasks.json");
+  const tasksPath = join8(kobeStateDir(), "tasks.json");
   const statePath2 = kvStatePath();
   console.log("kobe reset will:");
   console.log("  \u2022 stop the kobe daemon (graceful \u2192 SIGTERM \u2192 SIGKILL)");
@@ -8449,14 +8342,148 @@ var init_skill_cmd = __esm(() => {
   SKILL_VERBS = ["install", "status", "command"];
 });
 
+// src/engine/claude-code-local/hook-adapter.ts
+import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+function isObject6(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+async function readJsonObject(path6) {
+  try {
+    const parsed = JSON.parse(await readFile6(path6, "utf8"));
+    return isObject6(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function isKobeWorktreeSyncGroup(group) {
+  if (!isObject6(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((h) => isObject6(h) && typeof h.command === "string" && h.command.includes(WORKTREE_SYNC_MARKER));
+}
+function isKobeActivityGroup(group) {
+  if (!isObject6(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((h) => isObject6(h) && typeof h.command === "string" && ACTIVITY_MARKERS.some((m) => h.command.includes(m)));
+}
+function mergeWorktreeSyncHook(current, command) {
+  const { hooks: rawHooks, ...restSettings } = current;
+  const { WorktreeCreate, ...otherHooks } = isObject6(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(inv = kobeCliInvocation()) {
+  const out = {};
+  for (const { event, matcher, verb } of EVENT_MAP) {
+    const command = shellQuoteArgv([...inv, "hook", verb]);
+    const group = { hooks: [{ type: "command", command }] };
+    if (matcher)
+      group.matcher = matcher;
+    out[event] = [group];
+  }
+  return out;
+}
+function mergeActivityHooks(current, install, inv = kobeCliInvocation()) {
+  const { hooks: rawHooks, ...restSettings } = current;
+  const hooks = isObject6(rawHooks) ? { ...rawHooks } : {};
+  const built = install ? buildClaudeHooks(inv) : {};
+  for (const { event } of EVENT_MAP) {
+    const prior = Array.isArray(hooks[event]) ? hooks[event] : [];
+    const kept = prior.filter((g) => !isKobeActivityGroup(g));
+    if (install && Array.isArray(built[event]))
+      kept.push(...built[event]);
+    if (kept.length > 0)
+      hooks[event] = kept;
+    else
+      delete hooks[event];
+  }
+  return Object.keys(hooks).length > 0 ? { ...restSettings, hooks } : { ...restSettings };
+}
+
+class ClaudeHookAdapter {
+  vendor = "claude";
+  supportsHooks() {
+    return true;
+  }
+  supportsWorktreeSync() {
+    return true;
+  }
+  async installActivityHooks(settingsFilePath) {
+    await this.editSettings(settingsFilePath, (cur) => mergeActivityHooks(cur, true));
+  }
+  async removeActivityHooks(settingsFilePath) {
+    await this.editSettings(settingsFilePath, (cur) => mergeActivityHooks(cur, false));
+  }
+  async removeWorktreeSyncHook(settingsFilePath) {
+    await this.editSettings(settingsFilePath, (cur) => mergeWorktreeSyncHook(cur, null));
+  }
+  async editSettings(settingsFilePath, transform) {
+    try {
+      const current = await readJsonObject(settingsFilePath);
+      const next = transform(current);
+      if (JSON.stringify(next) === JSON.stringify(current))
+        return;
+      await mkdir5(dirname6(settingsFilePath), { recursive: true });
+      await writeFile4(settingsFilePath, `${JSON.stringify(next, null, 2)}
+`);
+    } catch {}
+  }
+}
+var EVENT_MAP, KOBE_HOOK_EVENTS, ACTIVITY_MARKERS, 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);
+  ACTIVITY_MARKERS = EVENT_MAP.map((e) => shellQuoteArgv(["hook", e.verb]));
+});
+
+// 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 installActivityHooks() {}
+  async removeActivityHooks() {}
+  supportsWorktreeSync() {
+    return false;
+  }
+  async removeWorktreeSyncHook() {}
+}
+var init_hook_adapter2 = __esm(() => {
+  init_hook_adapter();
+});
+
 // src/cli/hook-cmd.ts
 var exports_hook_cmd = {};
 __export(exports_hook_cmd, {
   runHookSubcommand: () => runHookSubcommand,
-  ensureDefaultWorktreeSync: () => ensureDefaultWorktreeSync
+  ensureGlobalKobeHooks: () => ensureGlobalKobeHooks
 });
 import { homedir as homedir10 } from "os";
-import { dirname as dirname7, join as join10, resolve as resolve6 } from "path";
+import { join as join9, resolve as resolve6 } from "path";
 async function readStdinPayload() {
   try {
     const text = await Promise.race([
@@ -8496,16 +8523,11 @@ async function runHookSubcommand(argv) {
     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();
+    const taskId = flagValue(rest, "--task-id");
+    const cwd = typeof payload.cwd === "string" && payload.cwd ? payload.cwd : process.cwd();
     let detail;
     if (verb === "turn-failed") {
       detail = { failure: failureFromErrorType(payload.error_type) };
@@ -8516,126 +8538,69 @@ async function runHookSubcommand(argv) {
     if (!client)
       return;
     try {
-      await client.request("engine.reportEvent", { taskId, kind: verb, ...detail ? { detail } : {} });
+      await client.request("engine.reportEvent", {
+        ...taskId ? { taskId } : { cwd },
+        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());
 }
+function activityHookAdapters() {
+  return ALL_VENDORS.map((v) => createEngineHookAdapter(v)).filter((a) => a.supportsHooks());
+}
+function globalSettingsPath() {
+  return join9(homedir10(), ".claude", "settings.json");
+}
 function persistedSyncPath(stored) {
   if (!stored || stored === "off")
     return;
   if (stored === "global")
-    return syncSettingsPath({ kind: "global" });
+    return globalSettingsPath();
   if (stored.startsWith("repo:"))
-    return syncSettingsPath({ kind: "repo", path: stored.slice(5) });
+    return join9(resolve6(stored.slice(5)), ".claude", "settings.json");
   return stored;
 }
-async function ensureDefaultWorktreeSync() {
+async function ensureGlobalKobeHooks() {
   try {
-    const stored = getPersistedString(SYNC_SETTING_KEY);
-    if (stored === "off")
-      return;
-    const adapters = worktreeSyncAdapters();
-    if (adapters.length === 0)
-      return;
-    const path6 = persistedSyncPath(stored) ?? syncSettingsPath({ kind: "global" });
-    for (const a of adapters)
-      await a.installWorktreeSyncHook(path6);
-    if (!stored)
-      setPersistedString(SYNC_SETTING_KEY, path6);
+    const globalPath = globalSettingsPath();
+    for (const a of activityHookAdapters())
+      await a.installActivityHooks(globalPath);
+    await cleanupWorktreeSyncHook();
   } catch {}
 }
-async function runHookSetup(argv) {
-  if (argv.includes("--help") || argv.includes("-h")) {
-    process.stdout.write([
-      "Usage: kobe hook setup [--global | --repo <path> | --off]",
-      "",
-      "Syncs an external `claude --worktree` into kobe as a task. This is ON",
-      "by default (installed globally into ~/.claude on launch). Use this to",
-      "move it to one repo (--repo <path>) or to turn it OFF (--off).",
-      ""
-    ].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);
-  }
+async function cleanupWorktreeSyncHook() {
   const adapters = worktreeSyncAdapters();
-  if (adapters.length === 0) {
-    process.stdout.write(`kobe hook setup: no engine supports external worktree sync \u2014 nothing to do
-`);
+  if (adapters.length === 0)
     return;
-  }
-  const prevPath = persistedSyncPath(getPersistedString(SYNC_SETTING_KEY));
-  if (off) {
-    if (prevPath) {
-      for (const a of adapters)
-        await a.removeWorktreeSyncHook(prevPath);
-    }
-    setPersistedString(SYNC_SETTING_KEY, "off");
-    process.stdout.write(`kobe hook setup: external worktree sync disabled${prevPath ? ` (removed from ${prevPath})` : ""}
-`);
-    return;
-  }
-  const scope = repoPath ? { kind: "repo", path: repoPath } : { kind: "global" };
-  const path6 = syncSettingsPath(scope);
-  if (prevPath && prevPath !== path6) {
-    for (const a of adapters)
-      await a.removeWorktreeSyncHook(prevPath);
-  }
+  const stored = getPersistedString(SYNC_SETTING_KEY);
+  const paths = new Set([globalSettingsPath()]);
+  const prev = persistedSyncPath(stored);
+  if (prev)
+    paths.add(prev);
   for (const a of adapters)
-    await a.installWorktreeSyncHook(path6);
-  setPersistedString(SYNC_SETTING_KEY, path6);
+    for (const p of paths)
+      await a.removeWorktreeSyncHook(p);
+  if (stored !== "off")
+    setPersistedString(SYNC_SETTING_KEY, "off");
+}
+async function runHookSetup(_argv) {
+  await cleanupWorktreeSyncHook();
   process.stdout.write([
-    `kobe hook setup: external worktree sync enabled (${scope.kind}) \u2014 wrote ${path6}`,
-    "New `claude --worktree` worktrees will appear as kobe tasks.",
+    "kobe hook setup is deprecated and now a no-op (cleanup only).",
+    "",
+    "The old external-worktree sync used a global WorktreeCreate hook, which is",
+    "a VCS provider hook \u2014 its presence broke `claude --worktree` / EnterWorktree",
+    "in every repo. Any hook kobe previously installed has been removed.",
+    "",
+    "Sync is now automatic: a `claude --worktree` (or any session) started in a",
+    "worktree under a repo kobe already tracks is adopted as a task on launch.",
+    "To adopt existing worktrees on demand, use the New Task dialog or `kobe adopt`.",
     ""
   ].join(`
 `));
@@ -13854,7 +13819,7 @@ var init_rename_task_dialog = __esm(() => {
 
 // src/engine/claude-code-local/binary.ts
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync8, statSync as statSync3 } from "fs";
+import { existsSync as existsSync7, statSync as statSync3 } from "fs";
 import { homedir as homedir12 } from "os";
 import path7 from "path";
 async function findClaudeBinary(deps = defaultDeps4) {
@@ -13941,7 +13906,7 @@ var init_binary = __esm(() => {
         return;
       if (first.startsWith("claude:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync8(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync7(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -13958,7 +13923,7 @@ var init_binary = __esm(() => {
 
 // src/engine/codex-local/binary.ts
 import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync9, statSync as statSync4 } from "fs";
+import { existsSync as existsSync8, statSync as statSync4 } from "fs";
 import { homedir as homedir13 } from "os";
 import path8 from "path";
 async function findCodexBinary(deps = defaultDeps5) {
@@ -14029,7 +13994,7 @@ var init_binary2 = __esm(() => {
         return;
       if (first.startsWith("codex:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync8(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -14046,7 +14011,7 @@ var init_binary2 = __esm(() => {
 
 // src/engine/copilot-local/binary.ts
 import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync10, statSync as statSync5 } from "fs";
+import { existsSync as existsSync9, statSync as statSync5 } from "fs";
 import { homedir as homedir14 } from "os";
 import path9 from "path";
 async function findCopilotBinary(deps = defaultDeps6) {
@@ -14141,7 +14106,7 @@ var init_binary3 = __esm(() => {
         return;
       if (first.startsWith("copilot:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync10(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -14530,7 +14495,7 @@ var init_dialog_confirm = __esm(() => {
 
 // src/tui/component/settings-dialog/actions.ts
 import { unlinkSync as unlinkSync2 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 function hasRestartableDaemon(orchestrator) {
   return orchestrator instanceof RemoteOrchestrator;
 }
@@ -14547,7 +14512,7 @@ async function confirmResetState(dialog, kv, renderer) {
     return;
   kv.clear();
   try {
-    unlinkSync2(join12(homeDir(), ".kobe", "tasks.json"));
+    unlinkSync2(join11(homeDir(), ".kobe", "tasks.json"));
   } catch (err) {
     if (err.code !== "ENOENT") {
       console.error("kobe: failed to delete tasks.json during reset:", err);
@@ -15984,7 +15949,7 @@ var init_focus = __esm(() => {
 
 // src/tui/context/kv.tsx
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname7 } from "path";
 function loadInitial() {
   const statePath2 = kvStatePath();
   try {
@@ -16012,7 +15977,7 @@ var init_kv = __esm(() => {
       function writeNow(label) {
         const statePath2 = kvStatePath();
         try {
-          mkdirSync4(dirname8(statePath2), {
+          mkdirSync4(dirname7(statePath2), {
             recursive: true
           });
           const tmp = `${statePath2}.tmp`;
@@ -16067,7 +16032,7 @@ var init_kv = __esm(() => {
           }
           const statePath2 = kvStatePath();
           try {
-            mkdirSync4(dirname8(statePath2), {
+            mkdirSync4(dirname7(statePath2), {
               recursive: true
             });
             const tmp = `${statePath2}.tmp`;
@@ -16103,8 +16068,8 @@ var init_persisted_ui_prefs = __esm(() => {
 
 // src/tui/lib/worktree-opener.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync11 } from "fs";
-import { basename as basename4, delimiter, isAbsolute, join as join13 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { basename as basename4, delimiter, isAbsolute, join as join12 } from "path";
 function executableOnPath(command, env, exists) {
   if (isAbsolute(command))
     return exists(command);
@@ -16112,7 +16077,7 @@ function executableOnPath(command, env, exists) {
   for (const dir of pathEnv.split(delimiter)) {
     if (!dir)
       continue;
-    if (exists(join13(dir, command)))
+    if (exists(join12(dir, command)))
       return true;
   }
   return false;
@@ -16132,7 +16097,7 @@ function labelForOverride(command) {
 function detectWorktreeOpener(deps = {}) {
   const env = deps.env ?? process.env;
   const platform = deps.platform ?? process.platform;
-  const exists = deps.exists ?? existsSync11;
+  const exists = deps.exists ?? existsSync10;
   const override = env.KOBE_OPEN_EDITOR?.trim();
   if (override) {
     return { id: "env", label: labelForOverride(override), command: override, args: [] };
@@ -17950,7 +17915,7 @@ var exports_host = {};
 __export(exports_host, {
   startTasksPane: () => startTasksPane
 });
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { TextAttributes as TextAttributes10 } from "@opentui/core";
 function TasksShell(props) {
   const themeCtx = useTheme();
@@ -18185,7 +18150,7 @@ function TasksShell(props) {
   async function openSelectedWorktree(id) {
     const task = props.tasks().find((t) => t.id === id);
     let worktree = task?.worktreePath;
-    if (!worktree || !existsSync12(worktree)) {
+    if (!worktree || !existsSync11(worktree)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         return;
@@ -18198,7 +18163,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!worktree || !existsSync12(worktree))
+    if (!worktree || !existsSync11(worktree))
       return;
     const opener = detectWorktreeOpener();
     if (!opener) {
@@ -18249,7 +18214,7 @@ function TasksShell(props) {
     const exists = await sessionExists(name);
     if (exists) {
       const cwd2 = await getSessionOption(name, "@kobe_worktree") || task?.worktreePath || "";
-      if (cwd2 && existsSync12(cwd2)) {
+      if (cwd2 && existsSync11(cwd2)) {
         await ensureSession({
           name,
           cwd: cwd2,
@@ -18263,7 +18228,7 @@ function TasksShell(props) {
       return;
     }
     let cwd = task?.worktreePath;
-    if (!cwd || !existsSync12(cwd)) {
+    if (!cwd || !existsSync11(cwd)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         return;
@@ -18276,7 +18241,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!cwd || !existsSync12(cwd))
+    if (!cwd || !existsSync11(cwd))
       return;
     const init2 = task?.repo ? resolveRepoInit(task.repo, cwd) : {};
     const ready = await ensureSession({
@@ -19727,14 +19692,14 @@ var init_keys2 = __esm(() => {
 
 // src/tui/panes/filetree/open-external.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { platform } from "os";
 function openExternally(absPath) {
   if (!absPath)
     return;
   const plat = platform();
   if (plat === "linux") {
-    if (existsSync13("/proc/sys/fs/binfmt_misc/WSLInterop") || process.env.WSL_DISTRO_NAME) {
+    if (existsSync12("/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 = "";
@@ -21175,7 +21140,7 @@ async function ensureRepos(orchestrator) {
 }
 async function startDirectTmux() {
   setClientLogContext("gui");
-  Promise.resolve().then(() => (init_hook_cmd(), exports_hook_cmd)).then((m) => m.ensureDefaultWorktreeSync());
+  Promise.resolve().then(() => (init_hook_cmd(), exports_hook_cmd)).then((m) => m.ensureGlobalKobeHooks());
   if (!await tmuxAvailable()) {
     console.error("kobe: tmux not found on PATH \u2014 install tmux to use kobe 0.6 direct mode");
     process.exitCode = 1;
@@ -21769,9 +21734,9 @@ var pulse_default = "../pulse-n3cq1btw.wav";
 var init_pulse = () => {};
 
 // src/tui/lib/sound.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename6, isAbsolute as isAbsolute2, join as join14, resolve as resolve8 } from "path";
+import { basename as basename6, isAbsolute as isAbsolute2, join as join13, resolve as resolve8 } from "path";
 function args(player, file, volume) {
   if (player === "ffplay")
     return [player, "-autoexit", "-nodisp", "-af", `volume=${volume}`, file];
@@ -21794,13 +21759,13 @@ function pickPlayer() {
     return cachedPlayer;
   const path12 = process.env.PATH ?? "";
   const segments = path12.split(":").filter(Boolean);
-  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync14(join14(dir, p)))) ?? null;
+  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync13(join13(dir, p)))) ?? null;
   return cachedPlayer;
 }
 async function ensureAsset() {
   cachedPath ??= (async () => {
     mkdirSync5(DIR, { recursive: true });
-    const dest = join14(DIR, basename6(pulseAsset));
+    const dest = join13(DIR, basename6(pulseAsset));
     const out = Bun.file(dest);
     if (await out.exists())
       return dest;
@@ -21830,7 +21795,7 @@ var pulseAsset, DIR, PLAYERS, cachedPlayer, cachedPath;
 var init_sound = __esm(() => {
   init_pulse();
   pulseAsset = isAbsolute2(pulse_default) ? pulse_default : resolve8(import.meta.dir, pulse_default);
-  DIR = join14(tmpdir2(), "kobe-sfx");
+  DIR = join13(tmpdir2(), "kobe-sfx");
   PLAYERS = [
     "ffplay",
     "mpv",

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@sma1lboy/kobe",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "TUI orchestrator for Claude Code (codename)",
   "type": "module",
   "packageManager": "bun@1.3.13",