@sma1lboy/kobe 0.5.7 → 0.5.8

package/dist/bin/kobed.js

@@ -17,6 +17,20 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// src/daemon/paths.ts
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+function defaultDaemonSocketPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
+  const runtimeDir = process.env.XDG_RUNTIME_DIR;
+  if (runtimeDir && runtimeDir.length > 0)
+    return join(runtimeDir, "kobe.sock");
+  return join(homeDir, ".kobe", "daemon.sock");
+}
+function defaultDaemonPidPath(homeDir = process.env.KOBE_HOME_DIR ?? homedir()) {
+  return join(homeDir, ".kobe", "daemon.pid");
+}
+var init_paths = () => {};
+
 // src/daemon/protocol.ts
 function serializeTask(task) {
   return {
@@ -173,10 +187,80 @@ class KobeDaemonClient {
 }
 var init_client = () => {};
 
+// src/client/daemon-process.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+async function connectOrStartDaemon() {
+  const socketPath = defaultDaemonSocketPath();
+  const client = new KobeDaemonClient(socketPath);
+  if (await canConnect(client))
+    return client;
+  const { entry, runWithBun } = resolveKobedEntry();
+  const child = runWithBun ? spawn(process.execPath, [entry, "start"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  }) : spawn(entry, ["start"], {
+    detached: true,
+    stdio: "ignore",
+    env: process.env
+  });
+  child.unref();
+  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((resolve2) => setTimeout(resolve2, 100));
+    }
+  }
+  throw new Error(`kobe: daemon did not start at ${socketPath}: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+}
+async function canConnect(client) {
+  try {
+    await client.connect();
+    return true;
+  } catch {
+    client.close();
+    return false;
+  }
+}
+function resolveKobedEntry() {
+  const here = fileURLToPath(import.meta.url);
+  if (here.startsWith("/$bunfs") || here.startsWith("B:\\~BUN")) {
+    const exeDir = dirname(process.execPath);
+    const ext = process.platform === "win32" ? ".exe" : "";
+    const sibling = join2(exeDir, `kobed${ext}`);
+    if (!existsSync(sibling)) {
+      throw new Error(`kobe: standalone build expected sibling kobed binary at ${sibling}; extract the full release tarball.`);
+    }
+    return { entry: sibling, runWithBun: false };
+  }
+  const dir = dirname(here);
+  const sourceEntry = resolve(dir, "../bin/kobed.ts");
+  if (existsSync(sourceEntry))
+    return { entry: sourceEntry, runWithBun: true };
+  const distEntry = resolve(dir, "../bin/kobed.js");
+  if (existsSync(distEntry))
+    return { entry: distEntry, runWithBun: true };
+  throw new Error(`kobe: could not locate kobed entry near ${dir}; expected ../bin/kobed.{ts,js}`);
+}
+var init_daemon_process = __esm(() => {
+  init_paths();
+  init_client();
+});
+
 // src/engine/claude-code-local/binary.ts
 import { spawnSync } from "child_process";
-import { existsSync, statSync } from "fs";
-import { homedir } from "os";
+import { existsSync as existsSync2, statSync } from "fs";
+import { homedir as homedir2 } from "os";
 import path from "path";
 async function findClaudeBinary(deps = defaultDeps) {
   const checked = [];
@@ -249,7 +333,7 @@ var init_binary = __esm(() => {
       return process.env[name];
     },
     home() {
-      return homedir();
+      return homedir2();
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
@@ -262,7 +346,7 @@ var init_binary = __esm(() => {
         return;
       if (first.startsWith("claude:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync2(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -279,7 +363,7 @@ var init_binary = __esm(() => {
 
 // src/engine/claude-code-local/history.ts
 import { readFile, readdir, unlink } from "fs/promises";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import path2 from "path";
 function encodeCwd(cwd) {
   return cwd.replace(/[/.]/g, "-");
@@ -379,7 +463,7 @@ var defaultDeps2;
 var init_history = __esm(() => {
   defaultDeps2 = {
     projectsDir() {
-      return path2.join(homedir2(), ".claude", "projects");
+      return path2.join(homedir3(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -448,22 +532,22 @@ class SessionRegistry {
   }
 }
 function waitForExit(proc) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     if (proc.exitCode !== null || proc.signalCode !== null) {
-      resolve();
+      resolve2();
       return;
     }
-    proc.once("close", () => resolve());
-    proc.once("exit", () => resolve());
+    proc.once("close", () => resolve2());
+    proc.once("exit", () => resolve2());
   });
 }
 function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // src/engine/claude-code-local/sessions.ts
 import { readFile as readFile2, readdir as readdir2, stat } from "fs/promises";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir4 } from "os";
 import path3 from "path";
 async function listSessionsForCwd(cwd, deps = defaultDeps3) {
   const projectDir = path3.join(deps.projectsDir(), encodeCwd(cwd));
@@ -537,7 +621,7 @@ var init_sessions = __esm(() => {
   init_history();
   defaultDeps3 = {
     projectsDir() {
-      return path3.join(homedir3(), ".claude", "projects");
+      return path3.join(homedir4(), ".claude", "projects");
     },
     async readdir(p) {
       try {
@@ -557,10 +641,10 @@ var init_sessions = __esm(() => {
 });
 
 // src/engine/claude-code-local/spawn.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function spawnClaudeProcess(opts) {
   const args = buildArgs(opts);
-  const proc = spawn(opts.binaryPath, args, {
+  const proc = spawn2(opts.binaryPath, args, {
     cwd: opts.cwd,
     env: { ...process.env, ...opts.env ?? {} },
     stdio: ["pipe", "pipe", "pipe"]
@@ -766,7 +850,7 @@ class ClaudeCodeLocal {
           }
           if (session.closed)
             return;
-          await new Promise((resolve) => session.waiters.push(resolve));
+          await new Promise((resolve2) => session.waiters.push(resolve2));
         }
       }
     };
@@ -906,11 +990,14 @@ var init_claude_code_local = __esm(() => {
 // src/orchestrator/bridge/server.ts
 import { mkdir, unlink as unlink2 } from "fs/promises";
 import { createServer } from "net";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 async function startBridgeServer(orch, socketPath) {
-  await mkdir(dirname(socketPath), { recursive: true });
+  await mkdir(dirname2(socketPath), { recursive: true });
   await unlink2(socketPath).catch(() => {});
+  const conns = new Set;
   const server = createServer((conn) => {
+    conns.add(conn);
+    conn.on("close", () => conns.delete(conn));
     let buffer = "";
     conn.on("data", (chunk) => {
       buffer += chunk.toString("utf8");
@@ -933,17 +1020,20 @@ async function startBridgeServer(orch, socketPath) {
     });
     conn.on("error", () => {});
   });
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once("error", reject);
     server.listen(socketPath, () => {
       server.removeListener("error", reject);
-      resolve();
+      resolve2();
     });
   });
   return {
     socketPath,
     async close() {
-      await new Promise((resolve) => server.close(() => resolve()));
+      for (const conn of conns)
+        conn.destroy();
+      conns.clear();
+      await new Promise((resolve2) => server.close(() => resolve2()));
       await unlink2(socketPath).catch(() => {});
     }
   };
@@ -1036,17 +1126,17 @@ __export(exports_bridge, {
   startBridge: () => startBridge
 });
 import { writeFile } from "fs/promises";
-import { homedir as homedir4 } from "os";
-import { join } from "path";
-import { fileURLToPath } from "url";
+import { homedir as homedir5 } from "os";
+import { join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 async function startBridge(orch, opts = {}) {
-  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir4();
-  const runDir = join(home, ".kobe", "run");
-  const socketPath = join(runDir, `bridge-${process.pid}.sock`);
-  const mcpConfigPath = join(runDir, `mcp-${process.pid}.json`);
+  const home = opts.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir5();
+  const runDir = join3(home, ".kobe", "run");
+  const socketPath = join3(runDir, `bridge-${process.pid}.sock`);
+  const mcpConfigPath = join3(runDir, `mcp-${process.pid}.json`);
   const server = await startBridgeServer(orch, socketPath);
   const moduleExt = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
-  const entry = fileURLToPath(new URL(`../../cli/index${moduleExt}`, import.meta.url));
+  const entry = fileURLToPath2(new URL(`../../cli/index${moduleExt}`, import.meta.url));
   const mcpConfig = {
     mcpServers: {
       kobe: {
@@ -2299,8 +2389,8 @@ var init_dev = __esm(() => {
 
 // src/engine/claude-settings.ts
 import { readFileSync } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir6 } from "os";
+import { join as join4 } from "path";
 function readClaudeSettings() {
   if (cached !== undefined)
     return cached;
@@ -2328,23 +2418,23 @@ function resolveDefaultModelId() {
 }
 var SETTINGS_PATH, cached, FALLBACK_DEFAULT_MODEL_ID = "claude-opus-4-7[1m]";
 var init_claude_settings = __esm(() => {
-  SETTINGS_PATH = join2(homedir5(), ".claude", "settings.json");
+  SETTINGS_PATH = join4(homedir6(), ".claude", "settings.json");
 });
 
 // src/env.ts
-import { homedir as homedir6 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join5 } from "path";
 function isDev() {
   return process.env.KOBE_DEV === "1";
 }
 function homeDir() {
-  return process.env.KOBE_HOME_DIR ?? homedir6();
+  return process.env.KOBE_HOME_DIR ?? homedir7();
 }
 function kobeStateDir() {
-  return join3(homeDir(), ".kobe");
+  return join5(homeDir(), ".kobe");
 }
 function kvStatePath() {
-  return join3(homeDir(), ".config", "kobe", "state.json");
+  return join5(homeDir(), ".config", "kobe", "state.json");
 }
 function tmuxBin() {
   return process.env.KOBE_TMUX_BIN ?? "tmux";
@@ -2364,7 +2454,7 @@ __export(exports_repos, {
 });
 import { spawnSync as spawnSync2 } from "child_process";
 import { mkdirSync, readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync } from "fs";
-import { dirname as dirname2 } from "path";
+import { dirname as dirname3 } from "path";
 function resolveRepoRoot(absPath) {
   const r = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
     cwd: absPath,
@@ -2410,7 +2500,7 @@ function load() {
 }
 function save(state) {
   const path4 = statePath();
-  mkdirSync(dirname2(path4), { recursive: true });
+  mkdirSync(dirname3(path4), { recursive: true });
   const tmp = `${path4}.tmp`;
   writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
   renameSync(tmp, path4);
@@ -2539,7 +2629,7 @@ var init_ulid = __esm(() => {
 });
 
 // src/orchestrator/metadata-suggester.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 
 class MetadataSuggester {
   binaryPromise = null;
@@ -2565,15 +2655,15 @@ class MetadataSuggester {
     const binary = await this.resolveBinary();
     if (!binary)
       return null;
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       let proc;
       try {
-        proc = spawn2(binary, ["-p", builder(trimmed)], {
+        proc = spawn3(binary, ["-p", builder(trimmed)], {
           stdio: ["ignore", "pipe", "ignore"],
           env: process.env
         });
       } catch {
-        resolve(null);
+        resolve2(null);
         return;
       }
       let buf = "";
@@ -2585,7 +2675,7 @@ class MetadataSuggester {
         try {
           proc.kill();
         } catch {}
-        resolve(v);
+        resolve2(v);
       };
       const timer = setTimeout(() => settle(null), SUGGESTION_TIMEOUT_MS);
       proc.stdout?.on("data", (chunk) => {
@@ -2997,6 +3087,9 @@ class Orchestrator {
   planUsageSignal() {
     return () => null;
   }
+  rcBridgeSignal() {
+    return () => ({ state: "off" });
+  }
   subscribeTasks(listener) {
     return this.store.subscribe(listener);
   }
@@ -3704,8 +3797,8 @@ var init_core = __esm(() => {
 
 // src/orchestrator/index/store.ts
 import { mkdir as mkdir2, open, readFile as readFile3, rename, unlink as unlink3 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname4, join as join6 } from "path";
 
 class TaskIndexStore {
   homeDir;
@@ -3717,9 +3810,9 @@ class TaskIndexStore {
   listeners = new Set;
   saveChain = Promise.resolve();
   constructor(options = {}) {
-    this.homeDir = options.homeDir ?? homedir7();
-    this.kobeDir = join4(this.homeDir, ".kobe");
-    this.path = join4(this.kobeDir, "tasks.json");
+    this.homeDir = options.homeDir ?? homedir8();
+    this.kobeDir = join6(this.homeDir, ".kobe");
+    this.path = join6(this.kobeDir, "tasks.json");
     this.tmpPath = `${this.path}.tmp`;
   }
   subscribe(listener) {
@@ -3777,7 +3870,7 @@ class TaskIndexStore {
     return next;
   }
   async doSave() {
-    await mkdir2(dirname3(this.path), { recursive: true });
+    await mkdir2(dirname4(this.path), { recursive: true });
     const payload = this.snapshot();
     const json = `${JSON.stringify(payload, null, 2)}
 `;
@@ -4092,7 +4185,7 @@ function canonicalize(p) {
   }
 }
 var KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees";
-var init_paths = () => {};
+var init_paths2 = () => {};
 
 // src/orchestrator/worktree/manager.ts
 import fs3 from "fs";
@@ -4286,25 +4379,13 @@ function canonicalize2(p) {
 }
 var init_manager = __esm(() => {
   init_git();
-  init_paths();
+  init_paths2();
 });
 
-// src/daemon/paths.ts
-import { homedir as homedir9, tmpdir } from "os";
-import { join as join5 } from "path";
-function defaultDaemonSocketPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir9()) {
-  const runtimeDir = process.env.XDG_RUNTIME_DIR;
-  if (runtimeDir && runtimeDir.length > 0)
-    return join5(runtimeDir, "kobe.sock");
-  return join5(homeDir2, ".kobe", "daemon.sock");
-}
-function defaultDaemonPidPath(homeDir2 = process.env.KOBE_HOME_DIR ?? homedir9()) {
-  return join5(homeDir2, ".kobe", "daemon.pid");
-}
-var init_paths2 = () => {};
-
 // src/bin/kobed.ts
+init_daemon_process();
 init_client();
+import { unlink as unlink5 } from "fs/promises";
 
 // src/core/index.ts
 init_claude_code_local();
@@ -4312,9 +4393,9 @@ init_bridge();
 init_core();
 init_store();
 init_manager();
-import { homedir as homedir8 } from "os";
+import { homedir as homedir9 } from "os";
 async function createKobeCore(options = {}) {
-  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir8();
+  const homeDir2 = options.homeDir ?? process.env.KOBE_HOME_DIR ?? homedir9();
   const store = new TaskIndexStore({ homeDir: homeDir2 });
   await store.load();
   const worktrees = new GitWorktreeManager;
@@ -4335,20 +4416,21 @@ async function createKobeCore(options = {}) {
 }
 
 // src/bin/kobed.ts
-init_paths2();
+init_paths();
 
 // src/daemon/server.ts
-init_paths2();
+init_repos();
+init_paths();
 import { mkdir as mkdir3, readFile as readFile5, unlink as unlink4, writeFile as writeFile3 } from "fs/promises";
 import { createServer as createServer2 } from "net";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 
 // src/engine/claude-code-local/plan-usage.ts
 import { execFile } from "child_process";
 import { createHash } from "crypto";
 import { readFile as readFile4 } from "fs/promises";
 import { homedir as homedir10, userInfo } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
@@ -4383,8 +4465,8 @@ async function readKeychainToken() {
   }
 }
 async function readPlainTextToken() {
-  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join6(homedir10(), ".claude");
-  const path7 = join6(configDir, ".credentials.json");
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? join7(homedir10(), ".claude");
+  const path7 = join7(configDir, ".credentials.json");
   try {
     const raw = await readFile4(path7, "utf8");
     return parseStoredOAuth(raw);
@@ -4497,6 +4579,180 @@ function createPlanUsagePoller(options) {
     }
   };
 }
+// src/daemon/rc-bridge.ts
+init_binary();
+import { spawn as spawn4 } from "child_process";
+var ENV_ID_RE = /Environment ID:\s*(env_[A-Za-z0-9]+)/;
+var DEEPLINK_RE = /https:\/\/claude\.ai\/code\?environment=([A-Za-z0-9_]+)/;
+var ANSI_RE = /\x1b\[[0-9;?]*[A-Za-z]/g;
+function createRcBridge(options = {}) {
+  const stopGraceMs = options.stopGraceMs ?? 5000;
+  const readyTimeoutMs = options.readyTimeoutMs ?? 30000;
+  const binaryPathResolver = options.binaryPathResolver ?? findClaudeBinary;
+  const spawner = options.spawner ?? ((cmd, args, cwd) => spawn4(cmd, [...args], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env }
+  }));
+  const subscribers = new Set;
+  let snapshot = { state: "off" };
+  let proc = null;
+  let stdoutBuffer = "";
+  let stderrBuffer = "";
+  let readyResolve = null;
+  let readyReject = null;
+  let readyTimer = null;
+  function update(next) {
+    snapshot = next;
+    for (const cb of subscribers) {
+      try {
+        cb(snapshot);
+      } catch {}
+    }
+    return snapshot;
+  }
+  function clearReadyTimer() {
+    if (readyTimer) {
+      clearTimeout(readyTimer);
+      readyTimer = null;
+    }
+  }
+  function settleReady(status) {
+    clearReadyTimer();
+    const resolve2 = readyResolve;
+    readyResolve = null;
+    readyReject = null;
+    if (resolve2)
+      resolve2(status);
+  }
+  function failReady(err) {
+    clearReadyTimer();
+    const reject = readyReject;
+    readyResolve = null;
+    readyReject = null;
+    if (reject)
+      reject(err);
+  }
+  function onStdout(chunk) {
+    const text = chunk.toString("utf8").replace(ANSI_RE, "");
+    stdoutBuffer = (stdoutBuffer + text).slice(-4096);
+    if (snapshot.state !== "starting" && snapshot.state !== "running")
+      return;
+    const envMatch = stdoutBuffer.match(ENV_ID_RE);
+    const linkMatch = stdoutBuffer.match(DEEPLINK_RE);
+    if (envMatch && snapshot.envId !== envMatch[1]) {
+      const envId = envMatch[1];
+      const deeplink = linkMatch ? `https://claude.ai/code?environment=${linkMatch[1]}` : `https://claude.ai/code?environment=${envId}`;
+      const ready = update({
+        ...snapshot,
+        state: "running",
+        envId,
+        deeplink
+      });
+      settleReady(ready);
+    }
+  }
+  function onStderr(chunk) {
+    stderrBuffer = (stderrBuffer + chunk.toString("utf8")).slice(-4096);
+  }
+  function onExit(code, signal) {
+    proc = null;
+    const wasStopping = snapshot.state === "stopping";
+    if (wasStopping) {
+      update({ state: "off" });
+      settleReady(snapshot);
+      return;
+    }
+    const tail = (text) => text.trim().split(`
+`).slice(-3).join(`
+`);
+    const msg = tail(stderrBuffer) || tail(stdoutBuffer) || `claude remote-control exited (code=${code}, signal=${signal})`;
+    const errored = update({ state: "error", errorMessage: msg });
+    failReady(new Error(errored.errorMessage ?? "claude remote-control exited"));
+  }
+  return {
+    status() {
+      return snapshot;
+    },
+    onChange(cb) {
+      subscribers.add(cb);
+      return () => subscribers.delete(cb);
+    },
+    async start(opts) {
+      if (snapshot.state === "running" || snapshot.state === "starting")
+        return snapshot;
+      const binary = await binaryPathResolver();
+      stdoutBuffer = "";
+      stderrBuffer = "";
+      update({
+        state: "starting",
+        cwd: opts.cwd,
+        startedAt: new Date().toISOString(),
+        bound: opts.bound
+      });
+      const args = ["remote-control", "--verbose", "--remote-control-session-name-prefix", "kobe"];
+      let child;
+      try {
+        child = spawner(binary, args, opts.cwd);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        update({ state: "error", errorMessage: `failed to spawn: ${msg}` });
+        throw err;
+      }
+      proc = child;
+      update({ ...snapshot, pid: child.pid ?? undefined });
+      child.stdout.on("data", onStdout);
+      child.stderr.on("data", onStderr);
+      child.once("exit", onExit);
+      child.once("error", (err) => {
+        proc = null;
+        update({ state: "error", errorMessage: err.message });
+        failReady(err);
+      });
+      return new Promise((resolve2, reject) => {
+        readyResolve = resolve2;
+        readyReject = reject;
+        readyTimer = setTimeout(() => {
+          if (proc) {
+            try {
+              proc.kill("SIGTERM");
+            } catch {}
+          }
+          update({ state: "error", errorMessage: `timed out waiting for environment id (${readyTimeoutMs}ms)` });
+          failReady(new Error(`claude remote-control did not become ready within ${readyTimeoutMs}ms`));
+        }, readyTimeoutMs);
+        readyTimer.unref?.();
+      });
+    },
+    async stop() {
+      const child = proc;
+      if (!child || snapshot.state !== "running" && snapshot.state !== "starting") {
+        if (snapshot.state !== "off")
+          update({ state: "off" });
+        return snapshot;
+      }
+      update({ ...snapshot, state: "stopping" });
+      const onExitPromise = new Promise((resolve2) => {
+        const onceExit = () => resolve2();
+        child.once("exit", onceExit);
+      });
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+      const killTimer = setTimeout(() => {
+        if (proc === child) {
+          try {
+            child.kill("SIGKILL");
+          } catch {}
+        }
+      }, stopGraceMs);
+      killTimer.unref?.();
+      await onExitPromise;
+      clearTimeout(killTimer);
+      return snapshot;
+    }
+  };
+}
 
 // src/daemon/server.ts
 async function startDaemonServer(orch, options = {}) {
@@ -4505,8 +4761,8 @@ async function startDaemonServer(orch, options = {}) {
   const startedAt = options.startedAt ?? new Date;
   const clients = new Set;
   let nextClientId = 1;
-  await mkdir3(dirname4(socketPath), { recursive: true });
-  await mkdir3(dirname4(pidPath), { recursive: true });
+  await mkdir3(dirname5(socketPath), { recursive: true });
+  await mkdir3(dirname5(pidPath), { recursive: true });
   await unlink4(socketPath).catch(() => {});
   const server = createServer2((socket) => {
     const client = {
@@ -4532,6 +4788,8 @@ async function startDaemonServer(orch, options = {}) {
   const planUsagePoller = options.planUsagePoller ?? createPlanUsagePoller({
     onUpdate: (usage) => broadcast(clients, { type: "event", name: "plan.usage", payload: { usage } })
   });
+  const rcBridge = options.rcBridge ?? createRcBridge();
+  rcBridge.onChange((status) => broadcast(clients, { type: "event", name: "rcBridge.changed", payload: { status } }));
   const serverApi = {
     socketPath,
     pidPath,
@@ -4539,24 +4797,27 @@ async function startDaemonServer(orch, options = {}) {
     clients,
     async close() {
       planUsagePoller.stop();
+      try {
+        await rcBridge.stop();
+      } catch {}
       broadcast(clients, { type: "event", name: "daemon.stopping", payload: {} });
-      await new Promise((resolve) => server.close(() => resolve()));
       for (const client of Array.from(clients)) {
         for (const unsub of client.subscriptions.values())
           unsub();
         client.subscriptions.clear();
-        client.socket.end();
+        client.socket.destroy();
       }
+      await new Promise((resolve2) => server.close(() => resolve2()));
       await unlink4(socketPath).catch(() => {});
       await unlink4(pidPath).catch(() => {});
     }
   };
   planUsagePoller.start();
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     server.once("error", reject);
     server.listen(socketPath, () => {
       server.removeListener("error", reject);
-      resolve();
+      resolve2();
     });
   });
   await writeFile3(pidPath, `${process.pid}
@@ -4588,7 +4849,8 @@ async function startDaemonServer(orch, options = {}) {
           tasks: tasks.map(serializeTask),
           pending,
           runState,
-          planUsage: planUsagePoller.current()
+          planUsage: planUsagePoller.current(),
+          rcBridge: rcBridge.status()
         };
       }
       case "daemon.status":
@@ -4772,6 +5034,41 @@ async function startDaemonServer(orch, options = {}) {
           subscribeClientToTask(orch, client, task);
         return {};
       }
+      case "rcBridge.start": {
+        const taskId = optionalString2(payload, "taskId");
+        const tabId = optionalString2(payload, "tabId");
+        let cwd;
+        let bound;
+        if (taskId) {
+          const task = orch.getTask(taskId);
+          if (!task)
+            throw new Error(`rcBridge.start: unknown taskId ${taskId}`);
+          const resolvedTabId = tabId ?? task.activeTabId;
+          const tab = task.tabs.find((t) => t.id === resolvedTabId);
+          if (!tab)
+            throw new Error(`rcBridge.start: unknown tabId ${resolvedTabId} on task ${taskId}`);
+          cwd = task.worktreePath;
+          bound = {
+            taskId: task.id,
+            tabId: tab.id,
+            sessionId: tab.sessionId,
+            taskTitle: task.title
+          };
+        } else {
+          cwd = optionalString2(payload, "cwd") ?? resolveRepoRoot(process.cwd());
+        }
+        if (!cwd)
+          throw new Error("rcBridge.start requires a non-empty cwd");
+        const status = await rcBridge.start({ cwd, bound });
+        return { status };
+      }
+      case "rcBridge.stop": {
+        const status = await rcBridge.stop();
+        return { status };
+      }
+      case "rcBridge.status": {
+        return { status: rcBridge.status() };
+      }
       default:
         throw new Error(`unknown daemon request: ${req.name}`);
     }
@@ -4975,23 +5272,42 @@ async function main() {
   if (command === "restart") {
     const oldPid = await readPidFile(pidPath);
     const client = new KobeDaemonClient(socketPath);
-    try {
-      await client.request("daemon.stop");
-    } catch {} finally {
-      client.close();
-    }
+    const stopRequest = client.request("daemon.stop").catch(() => {
+      return;
+    });
+    const stopTimeout = new Promise((resolve2) => setTimeout(resolve2, 2000));
+    await Promise.race([stopRequest, stopTimeout]);
+    client.close();
     if (oldPid && oldPid !== process.pid) {
       const deadline = Date.now() + 5000;
+      let escalated = false;
       while (Date.now() < deadline) {
         try {
           process.kill(oldPid, 0);
-          await new Promise((resolve) => setTimeout(resolve, 25));
         } catch {
           break;
         }
+        if (!escalated && Date.now() - (deadline - 5000) > 2000) {
+          try {
+            process.kill(oldPid, "SIGTERM");
+          } catch {}
+          escalated = true;
+        }
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
       }
+      try {
+        process.kill(oldPid, 0);
+        process.kill(oldPid, "SIGKILL");
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
+      } catch {}
     }
-  } else if (command !== "start") {
+    await unlink5(socketPath).catch(() => {});
+    const next = await connectOrStartDaemon();
+    next.close();
+    console.log(`kobed: restarted, listening on ${socketPath}`);
+    return;
+  }
+  if (command !== "start") {
     console.error("usage: kobed start|stop|status|restart");
     process.exit(2);
   }