@sma1lboy/kobe 0.5.12 → 0.5.13

package/dist/cli/index.js

@@ -4494,11 +4494,11 @@ var init_theme = __esm(() => {
 });
 
 // src/tui/panes/filetree/git.ts
-import { spawnSync as nodeSpawnSync } from "child_process";
-function runGit(args, cwd) {
+import { spawn as nodeSpawn } from "child_process";
+async function runGit(args, cwd) {
   if (!cwd)
     throw new Error("git(): cwd is required");
-  const result = gitWrapper.spawnSync(args, cwd);
+  const result = await gitWrapper.spawn(args, cwd);
   const exitCode = result.status ?? -1;
   if (exitCode !== 0) {
     const stderr = (result.stderr ?? "").trim();
@@ -4508,7 +4508,7 @@ function runGit(args, cwd) {
   return result.stdout ?? "";
 }
 async function listFiles(worktreePath) {
-  const out = runGit(["ls-files", "--cached", "--others", "--exclude-standard", "--full-name"], worktreePath);
+  const out = await runGit(["ls-files", "--cached", "--others", "--exclude-standard", "--full-name"], worktreePath);
   const lines = out.split(`
 `).map((l) => l.replace(/\r$/, ""));
   const set = new Set;
@@ -4519,11 +4519,11 @@ async function listFiles(worktreePath) {
   return Array.from(set).sort();
 }
 async function statusFiles(worktreePath) {
-  const out = runGit(["status", "--porcelain"], worktreePath);
+  const out = await runGit(["status", "--porcelain"], worktreePath);
   const entries = parsePorcelain(out);
   let stats = null;
   try {
-    const diffOut = runGit(["diff", "--no-color", "--numstat", "HEAD"], worktreePath);
+    const diffOut = await runGit(["diff", "--no-color", "--numstat", "HEAD"], worktreePath);
     stats = new Map(parseNumstat(diffOut).map((n) => [n.path, { added: n.added, deleted: n.deleted }]));
   } catch {
     stats = new Map;
@@ -4642,11 +4642,27 @@ function parsePorcelain(raw) {
 var gitWrapper;
 var init_git = __esm(() => {
   gitWrapper = {
-    spawnSync(args, cwd) {
-      return nodeSpawnSync("git", [...args], {
-        cwd,
-        encoding: "utf8",
-        shell: false
+    spawn(args, cwd) {
+      return new Promise((resolve, reject) => {
+        const child = nodeSpawn("git", [...args], {
+          cwd,
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+          stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+          stderr += chunk;
+        });
+        child.on("error", reject);
+        child.on("close", (status, signal) => {
+          resolve({ stdout, stderr, status, signal });
+        });
       });
     }
   };
@@ -5685,7 +5701,9 @@ function FileTree(props) {
   const [changes, setChanges] = createSignal(null);
   const [error, setError] = createSignal(null);
   const [expandedDirs, setExpandedDirs] = createSignal(new Set);
+  let fetchSeq = 0;
   async function refetch(currentTab, path) {
+    const seq = ++fetchSeq;
     if (path == null) {
       setAllFiles(null);
       setChanges(null);
@@ -5696,14 +5714,19 @@ function FileTree(props) {
     try {
       if (currentTab === "all") {
         const files = await listFiles(path);
+        if (seq !== fetchSeq || props.worktreePath() !== path)
+          return;
         setAllFiles(files);
       } else if (currentTab === "changes") {
         const entries = await statusFiles(path);
+        if (seq !== fetchSeq || props.worktreePath() !== path)
+          return;
         setChanges(entries);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      setError(message);
+      if (seq === fetchSeq && props.worktreePath() === path)
+        setError(message);
     }
   }
   createEffect(on(props.worktreePath, async (path) => {
@@ -5717,6 +5740,8 @@ function FileTree(props) {
   createEffect(on(props.worktreePath, (path) => {
     if (path == null)
       return;
+    if (process.env.KOBE_FILETREE_WATCH !== "1")
+      return;
     let debounceTimer = null;
     let watcher = null;
     try {
@@ -5735,7 +5760,7 @@ function FileTree(props) {
         debounceTimer = setTimeout(() => {
           debounceTimer = null;
           setRefreshTick((n) => n + 1);
-        }, 200);
+        }, 500);
       });
       watcher.on("error", () => {});
     } catch {}
@@ -6436,18 +6461,62 @@ var init_state = __esm(() => {
 });
 
 // src/tui/panes/preview/diff.ts
-import { spawnSync as spawnSync2 } from "child_process";
-function resolveGitToplevel(cwd) {
-  const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
-    cwd,
-    encoding: "utf8",
-    shell: false
-  });
+import { spawn } from "child_process";
+import { open } from "fs/promises";
+import path2 from "path";
+async function resolveGitToplevel(cwd) {
+  const r = await runProcess("git", ["rev-parse", "--show-toplevel"], cwd, 64 * 1024);
   if (r.status !== 0)
     return cwd;
-  const top = (r.stdout ?? "").trim();
+  const top = r.stdout.trim();
   return top || cwd;
 }
+function runProcess(command, args, cwd, maxBytes) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, [...args], {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let truncated = false;
+    function pushBounded(chunks, chunk, currentBytes) {
+      const remaining = Math.max(0, maxBytes + 1 - currentBytes);
+      if (remaining <= 0) {
+        truncated = true;
+        return currentBytes + chunk.length;
+      }
+      if (chunk.length > remaining) {
+        chunks.push(chunk.subarray(0, remaining));
+        truncated = true;
+      } else {
+        chunks.push(chunk);
+      }
+      return currentBytes + chunk.length;
+    }
+    child.stdout.on("data", (chunk) => {
+      stdoutBytes = pushBounded(stdoutChunks, chunk, stdoutBytes);
+      if (stdoutBytes > maxBytes)
+        child.kill("SIGTERM");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrBytes = pushBounded(stderrChunks, chunk, stderrBytes);
+    });
+    child.on("error", reject);
+    child.on("close", (status, signal) => {
+      resolve({
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8"),
+        status,
+        signal,
+        truncated
+      });
+    });
+  });
+}
 async function readFile(worktreePath, relPath) {
   if (!worktreePath)
     return { ok: false, error: "no worktree path" };
@@ -6456,21 +6525,22 @@ async function readFile(worktreePath, relPath) {
   if (relPath.split("/").includes("..")) {
     return { ok: false, error: "path escapes worktree" };
   }
-  const proc = spawnSync2("cat", ["--", relPath], {
-    cwd: resolveGitToplevel(worktreePath),
-    encoding: "utf8",
-    shell: false,
-    maxBuffer: MAX_BYTES + 4096
-  });
-  if (proc.status !== 0) {
-    const err = (proc.stderr ?? "").trim() || `cat exited ${proc.status}`;
-    return { ok: false, error: err };
-  }
-  const raw = proc.stdout ?? "";
-  if (raw.length > MAX_BYTES) {
-    return { ok: true, text: raw.slice(0, MAX_BYTES) + TRUNCATED_BANNER, truncated: true };
+  const top = await resolveGitToplevel(worktreePath);
+  const absPath = path2.join(top, relPath);
+  let handle = null;
+  try {
+    handle = await open(absPath, "r");
+    const buf = Buffer.allocUnsafe(MAX_BYTES + 1);
+    const { bytesRead } = await handle.read(buf, 0, MAX_BYTES + 1, 0);
+    const truncated = bytesRead > MAX_BYTES;
+    const raw = buf.subarray(0, Math.min(bytesRead, MAX_BYTES)).toString("utf8");
+    return { ok: true, text: truncated ? raw + TRUNCATED_BANNER : raw, truncated };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: msg };
+  } finally {
+    await handle?.close().catch(() => {});
   }
-  return { ok: true, text: raw, truncated: false };
 }
 async function readDiff(worktreePath, base, relPath) {
   if (!worktreePath)
@@ -6482,31 +6552,22 @@ async function readDiff(worktreePath, base, relPath) {
   if (relPath.split("/").includes("..")) {
     return { ok: false, error: "path escapes worktree" };
   }
-  const proc = spawnSync2("git", ["diff", "--no-color", base, "--", relPath], {
-    cwd: resolveGitToplevel(worktreePath),
-    encoding: "utf8",
-    shell: false,
-    maxBuffer: MAX_BYTES + 4096
-  });
-  if (proc.status !== 0) {
-    const err = (proc.stderr ?? "").trim() || `git diff exited ${proc.status}`;
+  const proc = await runProcess("git", ["diff", "--no-color", base, "--", relPath], await resolveGitToplevel(worktreePath), MAX_BYTES);
+  if (!proc.truncated && proc.status !== 0) {
+    const err = (proc.stderr ?? "").trim() || `git diff exited ${proc.status ?? proc.signal ?? "unknown"}`;
     return { ok: false, error: err };
   }
-  const raw = proc.stdout ?? "";
-  if (raw.length > MAX_BYTES) {
-    return { ok: true, text: raw.slice(0, MAX_BYTES) + TRUNCATED_BANNER, truncated: true };
-  }
-  return { ok: true, text: raw, truncated: false };
+  const raw = proc.stdout;
+  return {
+    ok: true,
+    text: proc.truncated ? raw.slice(0, MAX_BYTES) + TRUNCATED_BANNER : raw,
+    truncated: proc.truncated
+  };
 }
 async function isPathChanged(worktreePath, relPath) {
   if (!worktreePath || !relPath)
     return false;
-  const proc = spawnSync2("git", ["status", "--porcelain", "--", relPath], {
-    cwd: resolveGitToplevel(worktreePath),
-    encoding: "utf8",
-    shell: false,
-    maxBuffer: 64 * 1024
-  });
+  const proc = await runProcess("git", ["status", "--porcelain", "--", relPath], await resolveGitToplevel(worktreePath), 64 * 1024);
   if (proc.status !== 0)
     return false;
   return (proc.stdout ?? "").trim().length > 0;
@@ -7533,7 +7594,7 @@ var init_keys3 = __esm(() => {
 });
 
 // src/tui/panes/terminal/pty.ts
-import { spawn, spawnSync as spawnSync3 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync2 } from "child_process";
 function defaultShell() {
   return process.env.SHELL ?? "/bin/bash";
 }
@@ -7543,7 +7604,7 @@ function defaultTmuxBin() {
 function assertTmuxAvailable(tmuxBin2) {
   let result;
   try {
-    result = spawnSync3(tmuxBin2, ["-V"], { encoding: "utf8" });
+    result = spawnSync2(tmuxBin2, ["-V"], { encoding: "utf8" });
   } catch (err) {
     throw new Error(`kobe terminal pane requires tmux on PATH. Failed to spawn '${tmuxBin2}': ${err.message}.
 Install tmux (e.g. 'brew install tmux') or set KOBE_TMUX_BIN to its path.`);
@@ -7561,7 +7622,7 @@ function sessionNameFor(taskId) {
   return `${SESSION_NAME_PREFIX}${safe}`;
 }
 function tmuxSync(tmuxBin2, args) {
-  const result = spawnSync3(tmuxBin2, args, { encoding: "utf8" });
+  const result = spawnSync2(tmuxBin2, args, { encoding: "utf8" });
   if (result.error) {
     throw new Error(`${tmuxBin2} ${args.join(" ")}: ${result.error.message}`);
   }
@@ -7577,7 +7638,7 @@ class TmuxControlClient {
   buffer = "";
   _killed = false;
   constructor(tmuxBin2, sessionName) {
-    this.proc = spawn(tmuxBin2, ["-CC", "attach-session", "-t", sessionName], {
+    this.proc = spawn2(tmuxBin2, ["-CC", "attach-session", "-t", sessionName], {
       stdio: ["pipe", "pipe", "ignore"]
     });
     this.proc.stdout?.setEncoding("utf8");
@@ -7677,7 +7738,7 @@ class TmuxTaskPty {
     this.sessionName = sessionNameFor(opts.taskId);
     assertTmuxAvailable(this.tmuxBin);
     const shell = opts.shell ?? defaultShell();
-    const has = spawnSync3(this.tmuxBin, ["has-session", "-t", this.sessionName], { encoding: "utf8" });
+    const has = spawnSync2(this.tmuxBin, ["has-session", "-t", this.sessionName], { encoding: "utf8" });
     let existed = has.status === 0;
     if (existed) {
       try {
@@ -7800,7 +7861,7 @@ class TmuxTaskPty {
       for (const b of slice)
         hexArgs.push(b.toString(16).padStart(2, "0"));
       await new Promise((resolve) => {
-        const proc = spawn(this.tmuxBin, ["send-keys", "-t", this.sessionName, "-H", ...hexArgs], {
+        const proc = spawn2(this.tmuxBin, ["send-keys", "-t", this.sessionName, "-H", ...hexArgs], {
           stdio: ["ignore", "ignore", "ignore"]
         });
         proc.on("error", () => resolve());
@@ -7884,7 +7945,7 @@ class TmuxTaskPty {
       return;
     this.markDead();
     try {
-      const result = spawnSync3(this.tmuxBin, ["kill-session", "-t", this.sessionName], { encoding: "utf8" });
+      const result = spawnSync2(this.tmuxBin, ["kill-session", "-t", this.sessionName], { encoding: "utf8" });
     } catch {}
   }
   markDead() {
@@ -8901,10 +8962,10 @@ var init_terminal_host = __esm(() => {
 });
 
 // src/engine/claude-code-local/binary.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync, statSync } from "fs";
 import { homedir as homedir2 } from "os";
-import path2 from "path";
+import path3 from "path";
 async function findClaudeBinary(deps = defaultDeps) {
   const checked = [];
   const tryPath = (p2) => {
@@ -8920,19 +8981,19 @@ async function findClaudeBinary(deps = defaultDeps) {
       return whichResult;
   }
   const home = deps.home();
-  const localInstall = tryPath(path2.join(home, ".claude", "local", "claude"));
+  const localInstall = tryPath(path3.join(home, ".claude", "local", "claude"));
   if (localInstall)
     return localInstall;
   const nvmBin = deps.env("NVM_BIN");
   if (nvmBin) {
-    const candidate = tryPath(path2.join(nvmBin, "claude"));
+    const candidate = tryPath(path3.join(nvmBin, "claude"));
     if (candidate)
       return candidate;
   }
-  const nvmRoot = path2.join(home, ".nvm", "versions", "node");
+  const nvmRoot = path3.join(home, ".nvm", "versions", "node");
   const nvmVersions = deps.readdir(nvmRoot).sort().reverse();
   for (const v2 of nvmVersions) {
-    const candidate = tryPath(path2.join(nvmRoot, v2, "bin", "claude"));
+    const candidate = tryPath(path3.join(nvmRoot, v2, "bin", "claude"));
     if (candidate)
       return candidate;
   }
@@ -8948,7 +9009,7 @@ async function findClaudeBinary(deps = defaultDeps) {
     ".bun/bin/claude",
     "bin/claude"
   ]) {
-    const candidate = tryPath(path2.join(home, rel));
+    const candidate = tryPath(path3.join(home, rel));
     if (candidate)
       return candidate;
   }
@@ -8980,7 +9041,7 @@ var init_binary = __esm(() => {
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
-      const out = spawnSync4(cmd, [name], { encoding: "utf8" });
+      const out = spawnSync3(cmd, [name], { encoding: "utf8" });
       if (out.status !== 0)
         return;
       const first = out.stdout.split(`
@@ -9074,7 +9135,7 @@ var init_ulid = __esm(() => {
 });
 
 // src/orchestrator/index/store.ts
-import { mkdir, open, readFile as readFile2, rename, unlink } from "fs/promises";
+import { mkdir, open as open2, readFile as readFile2, rename, unlink } from "fs/promises";
 import { homedir as homedir3 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 
@@ -9152,7 +9213,7 @@ class TaskIndexStore {
     const payload = this.snapshot();
     const json = `${JSON.stringify(payload, null, 2)}
 `;
-    const handle = await open(this.tmpPath, "w", 420);
+    const handle = await open2(this.tmpPath, "w", 420);
     try {
       await handle.writeFile(json, "utf8");
       await handle.sync();
@@ -9392,32 +9453,32 @@ var init_store = __esm(() => {
 
 // src/orchestrator/worktree/paths.ts
 import fs2 from "fs";
-import path3 from "path";
+import path4 from "path";
 function worktreeRootFor(repo) {
-  if (!path3.isAbsolute(repo)) {
+  if (!path4.isAbsolute(repo)) {
     throw new Error(`worktreeRootFor: repo must be an absolute path, got: ${repo}`);
   }
-  return path3.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
+  return path4.join(repo, KOBE_WORKTREE_ROOT_SUBPATH);
 }
 function worktreePathFor(repo, taskId) {
   if (!taskId || /[/\\\0]/.test(taskId)) {
     throw new Error(`worktreePathFor: invalid taskId: ${JSON.stringify(taskId)}`);
   }
-  return path3.join(worktreeRootFor(repo), taskId);
+  return path4.join(worktreeRootFor(repo), taskId);
 }
 function isKobeManagedPath(repo, candidate) {
-  if (!path3.isAbsolute(repo) || !path3.isAbsolute(candidate))
+  if (!path4.isAbsolute(repo) || !path4.isAbsolute(candidate))
     return false;
   const root = canonicalize(worktreeRootFor(repo));
   const target = canonicalize(candidate);
-  const rel = path3.relative(root, target);
-  return rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(root, target);
+  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 function canonicalize(p2) {
   try {
     return fs2.realpathSync(p2);
   } catch {
-    return path3.resolve(p2);
+    return path4.resolve(p2);
   }
 }
 var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
@@ -9429,7 +9490,7 @@ var init_package = __esm(() => {
   package_default = {
     $schema: "https://json.schemastore.org/package.json",
     name: "@sma1lboy/kobe",
-    version: "0.5.12",
+    version: "0.5.13",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -9599,7 +9660,7 @@ __export(exports_diagnose, {
   formatBytes: () => formatBytes,
   buildDiagnoseReport: () => buildDiagnoseReport
 });
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { existsSync as existsSync2, readdirSync, statSync as statSync2 } from "fs";
 import { stat } from "fs/promises";
 import { homedir as homedir4, arch as osArch, platform as osPlatform, release as osRelease } from "os";
@@ -9670,12 +9731,12 @@ function reconcileWorktrees(tasks, onDiskByRepo) {
 }
 function probeVersion(bin) {
   try {
-    const out = spawnSync5(bin, ["--version"], {
+    const out = spawnSync4(bin, ["--version"], {
       encoding: "utf8",
       timeout: 3000
     });
     if (out.status !== 0) {
-      const alt = spawnSync5(bin, ["-V"], { encoding: "utf8", timeout: 3000 });
+      const alt = spawnSync4(bin, ["-V"], { encoding: "utf8", timeout: 3000 });
       if (alt.status !== 0)
         return null;
       return alt.stdout.trim() || alt.stderr.trim() || null;
@@ -9733,9 +9794,9 @@ function listWorktreeDirs(root) {
     return [];
   }
 }
-function tailLines(path4, n2) {
+function tailLines(path5, n2) {
   try {
-    const text = __require("fs").readFileSync(path4, "utf8");
+    const text = __require("fs").readFileSync(path5, "utf8");
     const lines = text.split(`
 `).filter((l2) => l2.length > 0);
     return lines.slice(-n2);
@@ -9786,7 +9847,7 @@ async function buildDiagnoseReport() {
   const tmux = tmuxBin();
   let tmuxPath = null;
   try {
-    const out = spawnSync5(process.platform === "win32" ? "where" : "which", [tmux], {
+    const out = spawnSync4(process.platform === "win32" ? "where" : "which", [tmux], {
       encoding: "utf8",
       timeout: 3000
     });
@@ -9924,7 +9985,7 @@ __export(exports_update, {
   runUpdateSubcommand: () => runUpdateSubcommand,
   parseUpdateArgs: () => parseUpdateArgs
 });
-import { spawnSync as spawnSync6 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 function fail(message) {
   process.stderr.write(`kobe update: ${message}
 `);
@@ -9975,7 +10036,7 @@ function printUsage(out) {
 }
 async function runUpdateSubcommand(args, deps) {
   const io = {
-    spawn: deps?.spawn ?? spawnSync6,
+    spawn: deps?.spawn ?? spawnSync5,
     stdout: deps?.stdout ?? process.stdout,
     stderr: deps?.stderr ?? process.stderr,
     exit: deps?.exit ?? ((code) => process.exit(code))
@@ -10072,19 +10133,19 @@ function loadUserThemes() {
   for (const file of entries) {
     if (!file.endsWith(".json"))
       continue;
-    const path4 = join4(dir, file);
+    const path5 = join4(dir, file);
     let parsed;
     try {
-      const text = readFileSync2(path4, "utf8");
+      const text = readFileSync2(path5, "utf8");
       parsed = JSON.parse(text);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.warn(`[kobe] skipping user theme ${path4}: invalid JSON \u2014 ${msg}`);
+      console.warn(`[kobe] skipping user theme ${path5}: invalid JSON \u2014 ${msg}`);
       continue;
     }
     const result = validateTheme(parsed);
     if (!result.ok) {
-      console.warn(`[kobe] skipping user theme ${path4}: ${result.reason}`);
+      console.warn(`[kobe] skipping user theme ${path5}: ${result.reason}`);
       continue;
     }
     const name = file.slice(0, -".json".length);
@@ -10127,9 +10188,9 @@ function listThemes2() {
   } else {
     for (const f2 of userFiles) {
       const name = f2.slice(0, -".json".length);
-      const path4 = join5(dir, f2);
+      const path5 = join5(dir, f2);
       const overridesBundled = BUNDLED_NAMES.includes(name) ? " (overrides built-in)" : "";
-      lines.push(`  ${name}${overridesBundled}  ${path4}`);
+      lines.push(`  ${name}${overridesBundled}  ${path5}`);
     }
   }
   process.stdout.write(`${lines.join(`
@@ -10312,8 +10373,8 @@ class SocketClient {
   nextId = 1;
   pending = new Map;
   connected;
-  constructor(path4) {
-    this.socket = connect(path4);
+  constructor(path5) {
+    this.socket = connect(path5);
     this.connected = new Promise((resolve2, reject) => {
       this.socket.once("connect", resolve2);
       this.socket.once("error", reject);
@@ -10611,30 +10672,36 @@ class KobeDaemonClient {
   nextId = 1;
   pending = new Map;
   handlers = new Map;
+  lifecycleHandlers = new Map;
+  connecting = null;
+  disposed = false;
   constructor(socketPath) {
     this.socketPath = socketPath;
   }
   connect() {
     if (this.socket)
       return Promise.resolve();
-    return new Promise((resolve2, reject) => {
-      const socket = connect2(this.socketPath);
-      this.socket = socket;
-      socket.once("connect", resolve2);
-      socket.once("error", reject);
-      socket.on("data", (chunk) => this.onData(chunk.toString("utf8")));
-      socket.on("close", () => {
-        this.socket = null;
-        for (const pending of this.pending.values())
-          pending.reject(new Error("daemon connection closed"));
-        this.pending.clear();
-      });
-    });
+    if (this.disposed)
+      return Promise.reject(new Error("daemon client disposed"));
+    if (this.connecting)
+      return this.connecting;
+    const p2 = this.openSocket();
+    this.connecting = p2;
+    const cleanup = () => {
+      if (this.connecting === p2)
+        this.connecting = null;
+    };
+    p2.then(cleanup, cleanup);
+    return p2;
   }
   close() {
+    this.disposed = true;
     this.socket?.end();
     this.socket = null;
   }
+  forceDisconnect() {
+    this.socket?.destroy();
+  }
   on(name, handler) {
     let set = this.handlers.get(name);
     if (!set) {
@@ -10648,6 +10715,19 @@ class KobeDaemonClient {
         this.handlers.delete(name);
     };
   }
+  onLifecycle(name, handler) {
+    let set = this.lifecycleHandlers.get(name);
+    if (!set) {
+      set = new Set;
+      this.lifecycleHandlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+      if (set?.size === 0)
+        this.lifecycleHandlers.delete(name);
+    };
+  }
   async request(name, payload) {
     await this.connect();
     const socket = this.socket;
@@ -10660,6 +10740,44 @@ class KobeDaemonClient {
     socket.write(frameToLine({ type: "request", id, name, payload }));
     return promise;
   }
+  openSocket() {
+    return new Promise((resolve2, reject) => {
+      const socket = connect2(this.socketPath);
+      this.socket = socket;
+      const onConnect = () => {
+        socket.off("error", onError);
+        resolve2();
+      };
+      const onError = (err) => {
+        socket.off("connect", onConnect);
+        if (this.socket === socket)
+          this.socket = null;
+        reject(err);
+      };
+      socket.once("connect", onConnect);
+      socket.once("error", onError);
+      socket.on("data", (chunk) => this.onData(chunk.toString("utf8")));
+      socket.on("close", () => this.onSocketClose(socket));
+    });
+  }
+  onSocketClose(which) {
+    if (this.socket !== which && this.socket !== null)
+      return;
+    this.socket = null;
+    for (const pending of this.pending.values())
+      pending.reject(new Error("daemon connection closed"));
+    this.pending.clear();
+    this.emitLifecycle("close");
+  }
+  emitLifecycle(name) {
+    for (const handler of this.lifecycleHandlers.get(name) ?? []) {
+      try {
+        handler();
+      } catch (err) {
+        console.error(`[kobe] lifecycle handler for "${name}" threw:`, err);
+      }
+    }
+  }
   onData(chunk) {
     this.buffer += chunk;
     let nl = this.buffer.indexOf(`
@@ -10700,21 +10818,20 @@ class KobeDaemonClient {
 var init_client = () => {};
 
 // src/client/daemon-process.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { dirname as dirname3, join as join7, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
-async function connectOrStartDaemon() {
+async function ensureDaemonReachable() {
   const socketPath = defaultDaemonSocketPath();
-  const client = new KobeDaemonClient(socketPath);
-  if (await canConnect(client))
-    return client;
+  if (await testCanConnect(socketPath))
+    return socketPath;
   const { entry, runWithBun } = resolveKobedEntry();
-  const child = runWithBun ? spawn2(process.execPath, [entry, "start"], {
+  const child = runWithBun ? spawn3(process.execPath, [entry, "start"], {
     detached: true,
     stdio: "ignore",
     env: process.env
-  }) : spawn2(entry, ["start"], {
+  }) : spawn3(entry, ["start"], {
     detached: true,
     stdio: "ignore",
     env: process.env
@@ -10723,24 +10840,26 @@ async function connectOrStartDaemon() {
   const deadline = Date.now() + 5000;
   let lastErr;
   while (Date.now() < deadline) {
-    const next = new KobeDaemonClient(socketPath);
-    try {
-      await next.connect();
-      return next;
-    } catch (err) {
-      lastErr = err;
-      next.close();
-      await new Promise((resolve3) => setTimeout(resolve3, 100));
-    }
+    if (await testCanConnect(socketPath))
+      return socketPath;
+    await new Promise((resolveTimer) => setTimeout(resolveTimer, 100));
   }
-  throw new Error(`kobe: daemon did not start at ${socketPath}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+  throw new Error(`kobe: daemon did not start at ${socketPath}: ${lastErr instanceof Error ? lastErr.message : "timeout"}`);
 }
-async function canConnect(client) {
+async function connectOrStartDaemon() {
+  const socketPath = await ensureDaemonReachable();
+  const client = new KobeDaemonClient(socketPath);
+  await client.connect();
+  return client;
+}
+async function testCanConnect(socketPath) {
+  const probe = new KobeDaemonClient(socketPath);
   try {
-    await client.connect();
+    await probe.connect();
+    probe.close();
     return true;
   } catch {
-    client.close();
+    probe.close();
     return false;
   }
 }
@@ -10884,7 +11003,7 @@ function withTotalSpeedForTurn(usage, startedAtIso, endedAtIso) {
 }
 
 // src/orchestrator/metadata-suggester.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 
 class MetadataSuggester {
   binaryPromise = null;
@@ -10913,7 +11032,7 @@ class MetadataSuggester {
     return new Promise((resolve3) => {
       let proc;
       try {
-        proc = spawn3(binary, ["-p", builder(trimmed)], {
+        proc = spawn4(binary, ["-p", builder(trimmed)], {
           stdio: ["ignore", "pipe", "ignore"],
           env: process.env
         });
@@ -11062,10 +11181,10 @@ class InMemoryPendingInputBroker {
 }
 
 // src/orchestrator/pr/build.ts
-import { spawnSync as spawnSync7 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 function git(cwd, args) {
   try {
-    const out = spawnSync7("git", args.slice(), {
+    const out = spawnSync6("git", args.slice(), {
       cwd,
       encoding: "utf8",
       timeout: GIT_TIMEOUT_MS
@@ -11115,7 +11234,7 @@ var init_build = () => {};
 
 // src/orchestrator/pr/instructions.ts
 import { promises as fs3 } from "fs";
-import path4 from "path";
+import path5 from "path";
 function dirtyCountSentence(n2) {
   if (n2 <= 0)
     return "There are no uncommitted changes.";
@@ -11143,7 +11262,7 @@ function renderPRInstructions(template, state) {
 async function loadPRInstructionsTemplate(worktreePath) {
   if (!worktreePath)
     return DEFAULT_PR_INSTRUCTIONS_TEMPLATE;
-  const file = path4.join(worktreePath, ".kobe", "pr-instructions.md");
+  const file = path5.join(worktreePath, ".kobe", "pr-instructions.md");
   try {
     const text = await fs3.readFile(file, "utf8");
     if (text.length === 0)
@@ -12092,6 +12211,8 @@ class RemoteOrchestrator {
   setRunState;
   planUsageAcc;
   setPlanUsage;
+  connectionStateAcc;
+  setConnectionState;
   rcBridgeAcc;
   setRcBridge;
   subscribers = new Map;
@@ -12101,6 +12222,7 @@ class RemoteOrchestrator {
     const [tasks, setTasks] = createSignal([]);
     const [runState, setRunState] = createSignal(new Map);
     const [planUsage, setPlanUsage] = createSignal(null);
+    const [connectionState, setConnectionState] = createSignal("online");
     const [rcBridge, setRcBridge] = createSignal({ state: "off" });
     this.tasksAcc = tasks;
     this.setTasks = (next) => setTasks(() => next);
@@ -12108,9 +12230,12 @@ class RemoteOrchestrator {
     this.setRunState = (next) => setRunState(() => next);
     this.planUsageAcc = planUsage;
     this.setPlanUsage = (next) => setPlanUsage(() => next);
+    this.connectionStateAcc = connectionState;
+    this.setConnectionState = (next) => setConnectionState(() => next);
     this.rcBridgeAcc = rcBridge;
     this.setRcBridge = (next) => setRcBridge(() => next);
     this.client.on("*", (frame) => this.handleEvent(frame.name, frame.payload));
+    this.client.onLifecycle("close", () => this.setConnectionState("disconnected"));
   }
   async init() {
     const hello = await this.client.request("hello", { clientId: `tui-${process.pid}`, version: "1" });
@@ -12153,6 +12278,17 @@ class RemoteOrchestrator {
       } catch {}
     }));
   }
+  async manualReconnect() {
+    this.client.forceDisconnect();
+    await ensureDaemonReachable();
+    for (const task of this.tasksAcc())
+      this.pendingInputBroker.clearForTask(task.id);
+    await this.init();
+    this.setConnectionState("online");
+  }
+  connectionStateSignal() {
+    return this.connectionStateAcc;
+  }
   dispose() {
     this.client.close();
   }
@@ -12405,15 +12541,16 @@ class RemoteOrchestrator {
 var init_remote_orchestrator = __esm(() => {
   init_dev();
   init_core();
+  init_daemon_process();
 });
 
 // src/orchestrator/worktree/git.ts
-import { spawnSync as spawnSync8 } from "child_process";
+import { spawnSync as spawnSync7 } from "child_process";
 function git2(args, opts) {
   if (!opts.cwd) {
     throw new Error("git(): cwd is required; refusing to inherit from process.cwd()");
   }
-  const proc = spawnSync8("git", [...args], {
+  const proc = spawnSync7("git", [...args], {
     cwd: opts.cwd,
     env: opts.env ? { ...process.env, ...opts.env } : process.env,
     encoding: "utf8",
@@ -12451,7 +12588,7 @@ var init_git2 = __esm(() => {
 
 // src/orchestrator/worktree/manager.ts
 import fs4 from "fs";
-import path5 from "path";
+import path6 from "path";
 
 class GitWorktreeManager {
   async create(repo, branch, worktreePath, baseRef) {
@@ -12469,7 +12606,7 @@ class GitWorktreeManager {
       }
       throw new Error(`create(): ${worktreePath} exists but is not a registered git worktree`);
     }
-    fs4.mkdirSync(path5.dirname(worktreePath), { recursive: true });
+    fs4.mkdirSync(path6.dirname(worktreePath), { recursive: true });
     const branchExists = this.branchExists(repo, branch);
     const args = branchExists ? ["worktree", "add", worktreePath, branch] : baseRef ? ["worktree", "add", "-b", branch, worktreePath, baseRef] : ["worktree", "add", "-b", branch, worktreePath];
     git2(args, { cwd: repo });
@@ -12524,8 +12661,8 @@ class GitWorktreeManager {
       if (!entry.branch || entry.detached)
         continue;
       const canonEntry = canonicalize2(entry.path);
-      const rel = path5.relative(canonRoot, canonEntry);
-      const callerPath = path5.join(callerRoot, rel);
+      const rel = path6.relative(canonRoot, canonEntry);
+      const callerPath = path6.join(callerRoot, rel);
       const dirty = await this.isDirty(entry.path);
       infos.push({
         path: callerPath,
@@ -12586,9 +12723,9 @@ class GitWorktreeManager {
       const gitDir = out.stdout.trim();
       if (!gitDir)
         return null;
-      const absolute = path5.isAbsolute(gitDir) ? gitDir : path5.resolve(worktreePath, gitDir);
-      const base = path5.basename(absolute);
-      return base === ".git" ? path5.dirname(absolute) : absolute;
+      const absolute = path6.isAbsolute(gitDir) ? gitDir : path6.resolve(worktreePath, gitDir);
+      const base = path6.basename(absolute);
+      return base === ".git" ? path6.dirname(absolute) : absolute;
     } catch (err) {
       if (err instanceof GitCommandError)
         return null;
@@ -12628,7 +12765,7 @@ function parsePorcelain2(out) {
   return records;
 }
 function requireAbsolute(name, value) {
-  if (!value || !path5.isAbsolute(value)) {
+  if (!value || !path6.isAbsolute(value)) {
     throw new Error(`${name} must be an absolute path, got: ${JSON.stringify(value)}`);
   }
 }
@@ -12636,7 +12773,7 @@ function canonicalize2(p2) {
   try {
     return fs4.realpathSync(p2);
   } catch {
-    return path5.resolve(p2);
+    return path6.resolve(p2);
   }
 }
 var init_manager = __esm(() => {
@@ -12711,7 +12848,7 @@ function DialogConfirm(props) {
             props.onCancel?.();
           dialog.clear();
         });
-        insert(_el$9, () => titlecase(key === "cancel" ? props.label ?? key : key));
+        insert(_el$9, () => titlecase(key === "cancel" ? props.label ?? key : props.confirmLabel ?? key));
         effect((_p$) => {
           var _v$5 = key === store2.active ? theme.primary : undefined, _v$6 = key === store2.active ? theme.selectedListItemText : theme.textMuted;
           _v$5 !== _p$.e && (_p$.e = setProp(_el$8, "backgroundColor", _v$5, _p$.e));
@@ -12753,14 +12890,15 @@ var init_dialog_confirm = __esm(() => {
   init_theme();
   init_keymap();
   init_dialog();
-  DialogConfirm.show = (dialog, title, message, label) => {
+  DialogConfirm.show = (dialog, title, message, label, confirmLabel) => {
     return new Promise((resolve3) => {
       dialog.replace(() => createComponent2(DialogConfirm, {
         title,
         message,
         onConfirm: () => resolve3(true),
         onCancel: () => resolve3(false),
-        label
+        label,
+        confirmLabel
       }), () => resolve3(undefined));
       dialog.setSize("small");
     });
@@ -13545,8 +13683,8 @@ function args(player, file, volume) {
 function pickPlayer() {
   if (cachedPlayer !== undefined)
     return cachedPlayer;
-  const path6 = process.env.PATH ?? "";
-  const segments = path6.split(":").filter(Boolean);
+  const path7 = process.env.PATH ?? "";
+  const segments = path7.split(":").filter(Boolean);
   cachedPlayer = PLAYERS.find((p2) => segments.some((dir) => existsSync5(join10(dir, p2)))) ?? null;
   return cachedPlayer;
 }
@@ -13566,9 +13704,9 @@ function pulse(volume = 0.4) {
   const player = pickPlayer();
   if (!player)
     return;
-  ensureAsset().then((path6) => {
+  ensureAsset().then((path7) => {
     try {
-      const proc = Bun.spawn(args(player, path6, volume), {
+      const proc = Bun.spawn(args(player, path7, volume), {
         stdin: "ignore",
         stdout: "ignore",
         stderr: "ignore"
@@ -15194,7 +15332,7 @@ var init_create_pr_button = __esm(() => {
 });
 
 // src/tui/lib/worktree-opener.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
 import { basename as basename4, delimiter, isAbsolute as isAbsolute2, join as join12 } from "path";
 function executableOnPath(command, env, exists) {
@@ -15236,7 +15374,7 @@ function detectWorktreeOpener(deps = {}) {
   }
   if (platform === "darwin" && executableOnPath("open", env, exists)) {
     for (const app of MAC_APP_CANDIDATES) {
-      if (app.paths.some((path6) => exists(path6))) {
+      if (app.paths.some((path7) => exists(path7))) {
         return { id: app.id, label: app.label, command: "open", args: ["-a", app.appName] };
       }
     }
@@ -15253,7 +15391,7 @@ function buildOpenWorktreeCommand(worktreePath, opener) {
 function openWorktree(worktreePath, opener, deps = {}) {
   if (!worktreePath)
     return false;
-  const spawnFn = deps.spawn ?? spawn4;
+  const spawnFn = deps.spawn ?? spawn5;
   const [command, args2] = buildOpenWorktreeCommand(worktreePath, opener);
   try {
     const child = spawnFn(command, args2, { detached: true, stdio: "ignore" });
@@ -16304,6 +16442,10 @@ function TopBar(props) {
     theme
   } = useTheme();
   const dialog = useDialog();
+  const connectionState = createMemo(() => {
+    const orch = props.orchestrator;
+    return orch instanceof RemoteOrchestrator ? orch.connectionStateSignal()() : "online";
+  });
   const remoteOrch = props.orchestrator instanceof RemoteOrchestrator ? props.orchestrator : null;
   const rcBridge = props.orchestrator.rcBridgeSignal();
   const isBridgeOn = () => rcBridge().state === "running" || rcBridge().state === "starting";
@@ -16389,22 +16531,46 @@ function TopBar(props) {
     setProp(_el$11, "justifyContent", "center");
     insert(_el$11, createComponent2(Show, {
       get when() {
-        return props.activeTask() !== undefined;
+        return connectionState() === "online";
+      },
+      get fallback() {
+        return (() => {
+          var _el$14 = createElement("text");
+          insertNode(_el$14, createTextNode(`daemon disconnected`));
+          setProp(_el$14, "wrapMode", "none");
+          effect((_p$) => {
+            var _v$0 = theme.error, _v$1 = TextAttributes18.BOLD;
+            _v$0 !== _p$.e && (_p$.e = setProp(_el$14, "fg", _v$0, _p$.e));
+            _v$1 !== _p$.t && (_p$.t = setProp(_el$14, "attributes", _v$1, _p$.t));
+            return _p$;
+          }, {
+            e: undefined,
+            t: undefined
+          });
+          return _el$14;
+        })();
       },
       get children() {
-        var _el$12 = createElement("text");
-        setProp(_el$12, "wrapMode", "none");
-        insert(_el$12, () => props.activeTask()?.branch);
-        effect((_p$) => {
-          var _v$5 = theme.text, _v$6 = TextAttributes18.BOLD;
-          _v$5 !== _p$.e && (_p$.e = setProp(_el$12, "fg", _v$5, _p$.e));
-          _v$6 !== _p$.t && (_p$.t = setProp(_el$12, "attributes", _v$6, _p$.t));
-          return _p$;
-        }, {
-          e: undefined,
-          t: undefined
+        return createComponent2(Show, {
+          get when() {
+            return props.activeTask() !== undefined;
+          },
+          get children() {
+            var _el$12 = createElement("text");
+            setProp(_el$12, "wrapMode", "none");
+            insert(_el$12, () => props.activeTask()?.branch);
+            effect((_p$) => {
+              var _v$5 = theme.text, _v$6 = TextAttributes18.BOLD;
+              _v$5 !== _p$.e && (_p$.e = setProp(_el$12, "fg", _v$5, _p$.e));
+              _v$6 !== _p$.t && (_p$.t = setProp(_el$12, "attributes", _v$6, _p$.t));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined
+            });
+            return _el$12;
+          }
         });
-        return _el$12;
       }
     }));
     setProp(_el$13, "flexDirection", "row");
@@ -16511,7 +16677,7 @@ var init_sync = __esm(() => {
 import { randomUUID } from "crypto";
 import { appendFile, mkdir as mkdir2, readFile as readFile3, readdir, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import path6 from "path";
+import path7 from "path";
 function encodeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
 }
@@ -16519,7 +16685,7 @@ async function readHistory(sessionId, deps = defaultDeps2) {
   const root = deps.projectsDir();
   const projectDirs = await deps.readdir(root);
   for (const dir of projectDirs) {
-    const candidate = path6.join(root, dir, `${sessionId}.jsonl`);
+    const candidate = path7.join(root, dir, `${sessionId}.jsonl`);
     let raw;
     try {
       raw = await deps.readFile(candidate);
@@ -16534,7 +16700,7 @@ async function deleteHistory(sessionId, deps = defaultDeps2) {
   const root = deps.projectsDir();
   const projectDirs = await deps.readdir(root);
   for (const dir of projectDirs) {
-    const candidate = path6.join(root, dir, `${sessionId}.jsonl`);
+    const candidate = path7.join(root, dir, `${sessionId}.jsonl`);
     try {
       await unlink2(candidate);
     } catch (err) {
@@ -16609,8 +16775,8 @@ function isObject(v2) {
 async function appendInterruptedUserPrompt(sessionId, cwd, prompt, deps = defaultDeps2) {
   if (!prompt || prompt.trim().length === 0)
     return;
-  const projectDir = path6.join(deps.projectsDir(), encodeCwd(cwd));
-  const filePath = path6.join(projectDir, `${sessionId}.jsonl`);
+  const projectDir = path7.join(deps.projectsDir(), encodeCwd(cwd));
+  const filePath = path7.join(projectDir, `${sessionId}.jsonl`);
   let lines = [];
   try {
     const raw = await readFile3(filePath, "utf8");
@@ -16680,7 +16846,7 @@ var defaultDeps2;
 var init_history = __esm(() => {
   defaultDeps2 = {
     projectsDir() {
-      return path6.join(homedir8(), ".claude", "projects");
+      return path7.join(homedir8(), ".claude", "projects");
     },
     async readdir(p2) {
       try {
@@ -16765,15 +16931,15 @@ function delay(ms) {
 // src/engine/claude-code-local/sessions.ts
 import { readFile as readFile4, readdir as readdir2, stat as stat2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import path7 from "path";
+import path8 from "path";
 async function listSessionsForCwd(cwd, deps = defaultDeps3) {
-  const projectDir = path7.join(deps.projectsDir(), encodeCwd(cwd));
+  const projectDir = path8.join(deps.projectsDir(), encodeCwd(cwd));
   const entries = await deps.readdir(projectDir);
   const jsonlNames = entries.filter((n2) => n2.endsWith(".jsonl"));
   const out = [];
   for (const name of jsonlNames) {
     const sessionId = name.slice(0, -".jsonl".length);
-    const filePath = path7.join(projectDir, name);
+    const filePath = path8.join(projectDir, name);
     try {
       const [meta, raw] = await Promise.all([deps.stat(filePath), deps.readFile(filePath)]);
       const lines = raw.split(`
@@ -16838,7 +17004,7 @@ var init_sessions = __esm(() => {
   init_history();
   defaultDeps3 = {
     projectsDir() {
-      return path7.join(homedir9(), ".claude", "projects");
+      return path8.join(homedir9(), ".claude", "projects");
     },
     async readdir(p2) {
       try {
@@ -16858,10 +17024,10 @@ var init_sessions = __esm(() => {
 });
 
 // src/engine/claude-code-local/spawn.ts
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 function spawnClaudeProcess(opts) {
   const args2 = buildArgs(opts);
-  const proc = spawn5(opts.binaryPath, args2, {
+  const proc = spawn6(opts.binaryPath, args2, {
     cwd: opts.cwd,
     env: { ...process.env, ...opts.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -17811,8 +17977,8 @@ function validateRepoPath(repo) {
   if (!stat3.isDirectory())
     return `not a directory: ${trimmed}`;
   try {
-    const { spawnSync: spawnSync9 } = __require("child_process");
-    const out = spawnSync9("git", ["rev-parse", "--git-dir"], {
+    const { spawnSync: spawnSync8 } = __require("child_process");
+    const out = spawnSync8("git", ["rev-parse", "--git-dir"], {
       cwd: trimmed,
       encoding: "utf-8",
       timeout: 2000,
@@ -17829,8 +17995,8 @@ function getCurrentBranch(repo) {
   if (!repo)
     return null;
   try {
-    const { spawnSync: spawnSync9 } = __require("child_process");
-    const out = spawnSync9("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+    const { spawnSync: spawnSync8 } = __require("child_process");
+    const out = spawnSync8("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: repo,
       encoding: "utf-8",
       timeout: 2000,
@@ -17850,8 +18016,8 @@ function listLocalBranches(repo) {
   if (!repo)
     return [];
   try {
-    const { spawnSync: spawnSync9 } = __require("child_process");
-    const out = spawnSync9("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads/"], {
+    const { spawnSync: spawnSync8 } = __require("child_process");
+    const out = spawnSync8("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads/"], {
       cwd: repo,
       encoding: "utf-8",
       timeout: 2000
@@ -18970,7 +19136,7 @@ var init_resume_dialog = __esm(() => {
 });
 
 // src/tui/panes/chat/composer/clipboard-image.ts
-import { spawnSync as spawnSync9 } from "child_process";
+import { spawnSync as spawnSync8 } from "child_process";
 import { statSync as statSync4 } from "fs";
 function clipboardImageSupported() {
   return process.platform === "darwin";
@@ -18995,7 +19161,7 @@ function readClipboardImageMacOS(destPath) {
     "end try"
   ].join(`
 `);
-  const result = spawnSync9("osascript", ["-e", script], {
+  const result = spawnSync8("osascript", ["-e", script], {
     timeout: 5000,
     stdio: ["ignore", "ignore", "ignore"]
   });
@@ -19183,25 +19349,25 @@ function findMentionContext(text, cursor) {
   }
   return { atPos, query: text.slice(atPos + 1, cursor) };
 }
-function formatDisplayPath(path8) {
-  if (path8.startsWith("packages/"))
-    return path8.slice("packages/".length);
-  return path8;
+function formatDisplayPath(path9) {
+  if (path9.startsWith("packages/"))
+    return path9.slice("packages/".length);
+  return path9;
 }
 function filterMentionMatches(files, query, limit) {
   if (files.length === 0 || limit <= 0)
     return [];
   const q2 = query.toLowerCase();
   if (q2.length === 0) {
-    return files.slice(0, limit).map((path8) => ({
-      path: path8,
-      displayPath: formatDisplayPath(path8),
+    return files.slice(0, limit).map((path9) => ({
+      path: path9,
+      displayPath: formatDisplayPath(path9),
       score: 0
     }));
   }
   const matches = [];
-  for (const path8 of files) {
-    const lower = path8.toLowerCase();
+  for (const path9 of files) {
+    const lower = path9.toLowerCase();
     const slash = lower.lastIndexOf("/");
     const filename = slash >= 0 ? lower.slice(slash + 1) : lower;
     let score = 0;
@@ -19215,8 +19381,8 @@ function filterMentionMatches(files, query, limit) {
       score = 40;
     else
       continue;
-    score -= path8.length * 0.5;
-    matches.push({ path: path8, displayPath: formatDisplayPath(path8), score });
+    score -= path9.length * 0.5;
+    matches.push({ path: path9, displayPath: formatDisplayPath(path9), score });
   }
   matches.sort((a2, b2) => b2.score - a2.score);
   return matches.slice(0, limit);
@@ -19363,7 +19529,7 @@ function Composer(props) {
       total
     };
   });
-  function insertMentionSelection(path8) {
+  function insertMentionSelection(path9) {
     const ref = textareaRef;
     const ctx4 = mentionContext();
     if (!ref || !ctx4)
@@ -19371,7 +19537,7 @@ function Composer(props) {
     const cursor = ref.cursorOffset;
     ref.setSelection(ctx4.atPos, cursor);
     ref.deleteSelection();
-    const inserted = `@${path8} `;
+    const inserted = `@${path9} `;
     ref.insertText(inserted);
     setMentionDismissedAt(null);
     setMentionCursor(0);
@@ -20731,7 +20897,7 @@ function readWriteInput(input) {
   };
 }
 function makeHeader(filePath, verb, adds, removes) {
-  const path8 = filePath || "(unknown file)";
+  const path9 = filePath || "(unknown file)";
   const parts = [];
   if (adds > 0) {
     parts.push(`Added ${adds} ${adds === 1 ? "line" : "lines"}`);
@@ -20741,11 +20907,11 @@ function makeHeader(filePath, verb, adds, removes) {
     parts.push(`${word} ${removes} ${removes === 1 ? "line" : "lines"}`);
   }
   if (parts.length === 0)
-    return `${verb} ${path8}`;
-  return `${verb} ${path8} \xB7 ${parts.join(", ")}`;
+    return `${verb} ${path9}`;
+  return `${verb} ${path9} \xB7 ${parts.join(", ")}`;
 }
 function makeMultiEditHeader(filePath, count, adds, removes) {
-  const path8 = filePath || "(unknown file)";
+  const path9 = filePath || "(unknown file)";
   const segments = [];
   if (count > 0) {
     segments.push(`${count} ${count === 1 ? "edit" : "edits"}`);
@@ -20761,8 +20927,8 @@ function makeMultiEditHeader(filePath, count, adds, removes) {
   if (lineParts.length > 0)
     segments.push(lineParts.join(", "));
   if (segments.length === 0)
-    return `Edited ${path8}`;
-  return `Edited ${path8} \xB7 ${segments.join(" \xB7 ")}`;
+    return `Edited ${path9}`;
+  return `Edited ${path9} \xB7 ${segments.join(" \xB7 ")}`;
 }
 var COLLAPSED_LINE_CAP = 10;
 
@@ -22742,24 +22908,24 @@ import { join as join14 } from "path";
 function resolveHome() {
   return process.env.HOME ?? homedir11();
 }
-async function safeReaddir(path8) {
+async function safeReaddir(path9) {
   try {
-    return await readdir3(path8);
+    return await readdir3(path9);
   } catch {
     return [];
   }
 }
-async function isFile(path8) {
+async function isFile(path9) {
   try {
-    const s2 = await stat3(path8);
+    const s2 = await stat3(path9);
     return s2.isFile();
   } catch {
     return false;
   }
 }
-async function isDir(path8) {
+async function isDir(path9) {
   try {
-    const s2 = await stat3(path8);
+    const s2 = await stat3(path9);
     return s2.isDirectory();
   } catch {
     return false;
@@ -22830,9 +22996,9 @@ function extractDescription(content) {
   }
   return null;
 }
-async function tryReadDescription(path8) {
+async function tryReadDescription(path9) {
   try {
-    const content = await readFile5(path8, "utf-8");
+    const content = await readFile5(path9, "utf-8");
     return extractDescription(content);
   } catch {
     return null;
@@ -24265,12 +24431,12 @@ var init_sidebar = __esm(() => {
 });
 
 // src/tui/panes/sidebar/git-head.ts
-import { spawnSync as spawnSync10 } from "child_process";
+import { spawnSync as spawnSync9 } from "child_process";
 function readCurrentBranch(repo) {
   if (!repo)
     return "";
   try {
-    const out = spawnSync10("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = spawnSync9("git", ["symbolic-ref", "--short", "HEAD"], {
       cwd: repo,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -24280,7 +24446,7 @@ function readCurrentBranch(repo) {
       if (name && name !== "HEAD")
         return name;
     }
-    const head = spawnSync10("git", ["rev-parse", "--verify", "HEAD"], {
+    const head = spawnSync9("git", ["rev-parse", "--verify", "HEAD"], {
       cwd: repo,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"]
@@ -24941,8 +25107,8 @@ function Shell(props) {
     return pp.prompt;
   });
   const worktreePathAcc = createMemo(() => {
-    const path8 = activeTask()?.worktreePath;
-    return path8 ? path8 : null;
+    const path9 = activeTask()?.worktreePath;
+    return path9 ? path9 : null;
   });
   const taskIdNullAcc = createMemo(() => selectedId());
   const diffBaseAcc = createMemo(() => worktreePathAcc() ? "HEAD" : null);
@@ -24969,6 +25135,44 @@ function Shell(props) {
     const baseAcc = focus.is(pane);
     return () => baseAcc() && dialog.stack.length === 0;
   };
+  let showingDisconnectDialog = false;
+  async function showDisconnectDialog() {
+    const orch = props.orchestrator;
+    if (!(orch instanceof RemoteOrchestrator))
+      return;
+    let message = "kobed is no longer reachable. Restart it and reconnect, or quit kobe?";
+    while (true) {
+      const choice = await DialogConfirm.show(dialog, "daemon disconnected", message, "Quit", "Restart");
+      if (choice !== true) {
+        try {
+          renderer?.destroy();
+        } catch {}
+        process.exit(0);
+      }
+      try {
+        await orch.manualReconnect();
+        return;
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        message = `Restart failed: ${errMsg}
+
+Try again or quit?`;
+      }
+    }
+  }
+  createEffect(() => {
+    const orch = props.orchestrator;
+    if (!(orch instanceof RemoteOrchestrator))
+      return;
+    if (orch.connectionStateSignal()() !== "disconnected")
+      return;
+    if (showingDisconnectDialog)
+      return;
+    showingDisconnectDialog = true;
+    showDisconnectDialog().finally(() => {
+      showingDisconnectDialog = false;
+    });
+  });
   const FOCUS_HJKL_TARGETS = {
     h: "sidebar",
     j: "workspace",
@@ -25467,6 +25671,7 @@ var init_app = __esm(() => {
   init_Sidebar();
   init_terminal();
   init_dialog();
+  init_dialog_confirm();
 });
 
 // src/tui/index.tsx