@sma1lboy/rove 0.9.238 → 0.9.240

package/dist/cli/pty-host-node.mjs

@@ -1,7 +1,20 @@
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// ../kobe-daemon/src/daemon/log-rotate.ts
+// ../rove-daemon/src/daemon/pty-host-node-entry.ts
+import { join as join9 } from "node:path";
+
+// ../rove-daemon/src/compat-env.ts
+var ROVE_ENV_PREFIX = "ROVE_";
+var ROVE_STATE_DIR_BASENAME = ".rove";
+function readRoveEnv(suffix, env = process.env) {
+  return env[`${ROVE_ENV_PREFIX}${suffix}`]?.trim() || undefined;
+}
+function readRoveHomeDirEnv(env = process.env) {
+  return readRoveEnv("HOME_DIR", env);
+}
+
+// ../rove-daemon/src/daemon/log-rotate.ts
 import { existsSync, renameSync, statSync } from "node:fs";
 var DEFAULT_LOG_ROTATE_CAP_BYTES = 10 * 1024 * 1024;
 function shouldRotateLog(sizeBytes, capBytes = DEFAULT_LOG_ROTATE_CAP_BYTES) {
@@ -18,32 +31,35 @@ function rotateLogIfNeeded(path, capBytes = DEFAULT_LOG_ROTATE_CAP_BYTES) {
   } catch {}
 }
 
-// ../kobe-daemon/src/daemon/paths.ts
+// ../rove-daemon/src/daemon/paths.ts
 import { createHash } from "node:crypto";
 import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 
-// ../kobe-daemon/src/compat-env.ts
-var ROVE_ENV_PREFIX = "ROVE_";
-var LEGACY_KOBE_ENV_PREFIX = "KOBE_";
-var ROVE_STATE_DIR_BASENAME = ".rove";
-var COMPAT_STATE_DIR_BASENAME = ".kobe";
-function readRoveEnv(suffix, env = process.env) {
-  for (const key of [`${ROVE_ENV_PREFIX}${suffix}`, `${LEGACY_KOBE_ENV_PREFIX}${suffix}`]) {
-    const value = env[key]?.trim();
-    if (value)
-      return value;
-  }
-  return;
+// ../rove-daemon/src/daemon/pre-rename-runtime.ts
+import { basename, dirname, join } from "node:path";
+var LEGACY_PRE_RENAME_RUNTIME_NAME = "kobe";
+function preRenameStateDir(home) {
+  return join(home, `.${LEGACY_PRE_RENAME_RUNTIME_NAME}`);
 }
-function readRoveHomeDirEnv(env = process.env) {
-  return readRoveEnv("HOME_DIR", env);
+function preRenameRuntimePaths(canonical) {
+  const name = basename(canonical);
+  if (canonical.startsWith("\\\\.\\pipe\\rove-") && canonical.endsWith("-pty")) {
+    return [canonical.replace("\\pipe\\rove-", `\\pipe\\${LEGACY_PRE_RENAME_RUNTIME_NAME}-`)];
+  }
+  if (/^rove(?:-[a-f0-9]{8})?-(?:pty|daemon)(?:-\d+)?\.sock$/.test(name) || name === "rove.sock") {
+    return [join(dirname(canonical), name.replace(/^rove/, LEGACY_PRE_RENAME_RUNTIME_NAME))];
+  }
+  if (["pty.sock", "pty.pid", "daemon.sock", "daemon.pid"].includes(name) && basename(dirname(canonical)) === ".rove") {
+    return [join(preRenameStateDir(dirname(dirname(canonical))), name)];
+  }
+  return [];
 }
 
-// ../kobe-daemon/src/daemon/paths.ts
+// ../rove-daemon/src/daemon/paths.ts
 function stateDirs(homeDir) {
-  return { canonical: join(homeDir, ROVE_STATE_DIR_BASENAME), legacy: join(homeDir, COMPAT_STATE_DIR_BASENAME) };
+  return { canonical: join2(homeDir, ROVE_STATE_DIR_BASENAME), legacy: preRenameStateDir(homeDir) };
 }
 function pidIsLive(pidPath) {
   try {
@@ -58,25 +74,16 @@ function pidIsLive(pidPath) {
 }
 function runtimePath(homeDir, name, pidName) {
   const { canonical, legacy } = stateDirs(homeDir);
-  const canonicalPath = join(canonical, name);
-  if (existsSync2(canonicalPath))
+  const canonicalPath = join2(canonical, name);
+  if (pidIsLive(join2(canonical, pidName)))
     return canonicalPath;
-  const legacyPath = join(legacy, name);
-  if (existsSync2(legacyPath) && pidIsLive(join(legacy, pidName)))
+  const legacyPath = join2(legacy, name);
+  if (existsSync2(legacyPath) && pidIsLive(join2(legacy, pidName)))
     return legacyPath;
   return canonicalPath;
 }
-function legacyRuntimePath(homeDir, name) {
-  return join(homeDir, COMPAT_STATE_DIR_BASENAME, name);
-}
-function legacyPtyHostSocketPath(homeDir) {
-  return legacyRuntimePath(homeDir, "pty.sock");
-}
-function legacyPtyHostPidPath(homeDir) {
-  return legacyRuntimePath(homeDir, "pty.pid");
-}
 function runtimeDataPath(homeDir, name) {
-  return join(stateDirs(homeDir).canonical, name);
+  return join2(stateDirs(homeDir).canonical, name);
 }
 var SOCKET_PATH_SAFETY_LIMIT = 100;
 function shortHomeTag(homeDir) {
@@ -87,20 +94,38 @@ function fitSocketPath(naturalPath, homeDir, role, pidTag) {
     return naturalPath;
   const tag = shortHomeTag(homeDir);
   const suffix = pidTag === undefined ? "" : `-${pidTag}`;
-  const fallback = join(tmpdir(), `kobe-${tag}-${role}${suffix}.sock`);
+  const fallback = join2(tmpdir(), `rove-${tag}-${role}${suffix}.sock`);
   if (Buffer.byteLength(fallback, "utf8") <= SOCKET_PATH_SAFETY_LIMIT)
     return fallback;
   throw new Error(`daemon socket path exceeds ${SOCKET_PATH_SAFETY_LIMIT} bytes even after fallback: ${fallback}`);
 }
+function defaultDaemonSocketPath(homeDir) {
+  const override = readRoveEnv("DAEMON_SOCKET_PATH");
+  if (override)
+    return override;
+  const explicit = homeDir ?? readRoveHomeDirEnv();
+  if (explicit && explicit.length > 0) {
+    return fitSocketPath(join2(explicit, ROVE_STATE_DIR_BASENAME, "daemon.sock"), explicit, "daemon");
+  }
+  const runtimeDir = process.env.XDG_RUNTIME_DIR;
+  if (runtimeDir && runtimeDir.length > 0) {
+    return fitSocketPath(join2(runtimeDir, "rove.sock"), runtimeDir, "daemon");
+  }
+  const home = homedir();
+  return fitSocketPath(join2(home, ROVE_STATE_DIR_BASENAME, "daemon.sock"), home, "daemon");
+}
 function resolveDaemonHomeDir(homeDir) {
   const explicit = homeDir ?? readRoveHomeDirEnv();
   return explicit && explicit.length > 0 ? explicit : homedir();
 }
+function defaultClientLogPath(homeDir = readRoveHomeDirEnv() ?? homedir()) {
+  return join2(homeDir, ROVE_STATE_DIR_BASENAME, "client.log");
+}
 function isWindowsPipePath(path) {
   return path.startsWith("\\\\.\\pipe\\") || path.startsWith("//./pipe/");
 }
 function windowsPipePath(homeDir, role) {
-  return `\\\\.\\pipe\\kobe-${shortHomeTag(homeDir)}-${role}`;
+  return `\\\\.\\pipe\\rove-${shortHomeTag(homeDir)}-${role}`;
 }
 function defaultPtyHostSocketPath(homeDir, platform = process.platform) {
   const override = readRoveEnv("PTY_SOCKET_PATH");
@@ -110,14 +135,14 @@ function defaultPtyHostSocketPath(homeDir, platform = process.platform) {
   if (platform === "win32")
     return windowsPipePath(explicit || homedir(), "pty");
   if (explicit && explicit.length > 0) {
-    return fitSocketPath(runtimePath(explicit, "pty.sock", "pty.pid"), explicit, "pty");
+    return fitSocketPath(join2(explicit, ROVE_STATE_DIR_BASENAME, "pty.sock"), explicit, "pty");
   }
   const runtimeDir = process.env.XDG_RUNTIME_DIR;
   if (runtimeDir && runtimeDir.length > 0) {
-    return fitSocketPath(join(runtimeDir, "kobe-pty.sock"), runtimeDir, "pty");
+    return fitSocketPath(join2(runtimeDir, "rove-pty.sock"), runtimeDir, "pty");
   }
   const home = homedir();
-  return fitSocketPath(runtimePath(home, "pty.sock", "pty.pid"), home, "pty");
+  return fitSocketPath(join2(home, ROVE_STATE_DIR_BASENAME, "pty.sock"), home, "pty");
 }
 function defaultPtyHostPidPath(homeDir = readRoveHomeDirEnv() ?? homedir()) {
   const override = readRoveEnv("PTY_PID_PATH");
@@ -126,7 +151,7 @@ function defaultPtyHostPidPath(homeDir = readRoveHomeDirEnv() ?? homedir()) {
   return runtimePath(homeDir, "pty.pid", "pty.pid");
 }
 function defaultPtyHostLogPath(homeDir = readRoveHomeDirEnv() ?? homedir()) {
-  return join(homeDir, ROVE_STATE_DIR_BASENAME, "pty.log");
+  return join2(homeDir, ROVE_STATE_DIR_BASENAME, "pty.log");
 }
 function defaultPtyExitsPath(homeDir = readRoveHomeDirEnv() ?? homedir()) {
   return runtimeDataPath(homeDir, "pty-exits.json");
@@ -135,10 +160,10 @@ function defaultPtyFreezeDir(homeDir = readRoveHomeDirEnv() ?? homedir()) {
   return runtimeDataPath(homeDir, "pty-sessions");
 }
 
-// ../kobe-daemon/src/daemon/process-tree.ts
+// ../rove-daemon/src/daemon/process-tree.ts
 import { execFile } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 var TASKKILL_TIMEOUT_MS = 5000;
 var MSYS_PS_TIMEOUT_MS = 5000;
 function parseMsysPs(output) {
@@ -183,8 +208,8 @@ function msysDescendantWinpids(rows, rootWinpid) {
 function msysPsFor(shellFile) {
   if (!shellFile || !/bash(\.exe)?$/i.test(shellFile))
     return null;
-  const dir = dirname(shellFile);
-  for (const candidate of [join2(dir, "ps.exe"), join2(dir, "..", "usr", "bin", "ps.exe")]) {
+  const dir = dirname2(shellFile);
+  for (const candidate of [join3(dir, "ps.exe"), join3(dir, "..", "usr", "bin", "ps.exe")]) {
     if (existsSync3(candidate))
       return candidate;
   }
@@ -210,7 +235,174 @@ async function taskkillProcessTree(pid, shellFile) {
   });
 }
 
-// ../kobe-daemon/src/daemon/pty-driver.ts
+// ../rove-daemon/src/daemon/win-pty-job.ts
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { existsSync as existsSync4, mkdirSync, renameSync as renameSync2, rmSync, writeFileSync } from "node:fs";
+import { join as join4, resolve } from "node:path";
+var PTY_JOB_ENV = "ROVE_PTY_JOB";
+var PTY_JOB_OWNER_ENV = "ROVE_PTY_JOB_OWNER";
+var PTY_JOB_LAUNCHER_CS = `
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+static class RovePtyJob {
+  [StructLayout(LayoutKind.Sequential)] struct BASIC { public long PerProcessUserTimeLimit, PerJobUserTimeLimit; public uint LimitFlags; public UIntPtr MinimumWorkingSetSize, MaximumWorkingSetSize; public uint ActiveProcessLimit; public UIntPtr Affinity; public uint PriorityClass, SchedulingClass; }
+  [StructLayout(LayoutKind.Sequential)] struct IO { public ulong R, W, O, RB, WB, OB; }
+  [StructLayout(LayoutKind.Sequential)] struct EXT { public BASIC Basic; public IO Io; public UIntPtr ProcessMemoryLimit, JobMemoryLimit, PeakProcessMemoryUsed, PeakJobMemoryUsed; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct SI { public int cb; public string lpReserved, lpDesktop, lpTitle; public int dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags; public short wShowWindow, cbReserved2; public IntPtr lpReserved2, hStdInput, hStdOutput, hStdError; }
+  [StructLayout(LayoutKind.Sequential)] struct PI { public IntPtr hProcess, hThread; public int dwProcessId, dwThreadId; }
+  delegate bool CtrlHandler(uint type);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateJobObject(IntPtr sa, string name);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool SetInformationJobObject(IntPtr job, int cls, ref EXT info, int len);
+  [DllImport("kernel32.dll", SetLastError=true)] static extern bool AssignProcessToJobObject(IntPtr job, IntPtr proc);
+  [DllImport("kernel32.dll")] static extern IntPtr GetCurrentProcess();
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode)] static extern IntPtr GetCommandLine();
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcess(string app, StringBuilder cmd, IntPtr pa, IntPtr ta, bool inherit, uint flags, IntPtr env, string cwd, ref SI si, out PI pi);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr h, uint ms);
+  [DllImport("kernel32.dll")] static extern bool GetExitCodeProcess(IntPtr h, out uint code);
+  [DllImport("kernel32.dll")] static extern bool SetConsoleCtrlHandler(CtrlHandler h, bool add);
+  [DllImport("kernel32.dll")] static extern bool SetProcessWorkingSetSize(IntPtr p, IntPtr min, IntPtr max);
+  static CtrlHandler keep;
+  static int SkipToken(string s, int i) {
+    if (i < s.Length && s[i] == '"') { int end = s.IndexOf('"', i + 1); return end < 0 ? s.Length : end + 1; }
+    while (i < s.Length && s[i] != ' ' && s[i] != '\\t') i++;
+    return i;
+  }
+  static int SkipSpace(string s, int i) { while (i < s.Length && (s[i] == ' ' || s[i] == '\\t')) i++; return i; }
+  static int Main() {
+    string raw = Marshal.PtrToStringUni(GetCommandLine());
+    string rest = raw.Substring(SkipSpace(raw, SkipToken(raw, 0)));
+    if (rest.Length == 0) { Console.Error.WriteLine("rove-pty-job: usage: <command line> (job name in ${PTY_JOB_ENV})"); return 2; }
+    string name = Environment.GetEnvironmentVariable("${PTY_JOB_ENV}");
+    IntPtr job = String.IsNullOrEmpty(name) ? IntPtr.Zero : CreateJobObject(IntPtr.Zero, name);
+    if (job != IntPtr.Zero) {
+      EXT info = new EXT();
+      info.Basic.LimitFlags = 0x2000; // KILL_ON_JOB_CLOSE; no BREAKAWAY_OK (see module doc)
+      SetInformationJobObject(job, 9, ref info, Marshal.SizeOf(typeof(EXT)));
+      AssignProcessToJobObject(job, GetCurrentProcess());
+    }
+    keep = delegate (uint type) { return type <= 1; }; // CTRL_C, CTRL_BREAK: the shell's to handle
+    SetConsoleCtrlHandler(keep, true);
+    SI si = new SI(); si.cb = Marshal.SizeOf(typeof(SI));
+    PI pi;
+    if (!CreateProcess(null, new StringBuilder(rest), IntPtr.Zero, IntPtr.Zero, false, 0, IntPtr.Zero, null, ref si, out pi)) {
+      Console.Error.WriteLine("rove-pty-job: could not start " + rest + " (error " + Marshal.GetLastWin32Error() + ")");
+      return 1;
+    }
+    // From here it only waits: hand its pages back (14 MB resident → 2 MB per tab, measured).
+    SetProcessWorkingSetSize(GetCurrentProcess(), (IntPtr)(-1), (IntPtr)(-1));
+    WaitForSingleObject(pi.hProcess, 0xFFFFFFFF);
+    uint code;
+    GetExitCodeProcess(pi.hProcess, out code);
+    GC.KeepAlive(keep);
+    return (int)code;
+  }
+}
+`;
+var COMPILE_TIMEOUT_MS = 30000;
+var SELF_TEST_TIMEOUT_MS = 1e4;
+var SELF_TEST_EXIT_CODE = 7;
+function run(file, args, timeout, env) {
+  return new Promise((done) => {
+    try {
+      const child = execFile2(file, [...args], { windowsHide: true, timeout, env }, (err, stdout, stderr) => {
+        const output = `${stdout}${stderr}`.trim() || err?.message || "";
+        done({ code: child.exitCode, output });
+      });
+    } catch (err) {
+      done({ code: null, output: err.message });
+    }
+  });
+}
+function findCsc(env = process.env) {
+  const root = env.SystemRoot || env.windir || "C:\\Windows";
+  for (const framework of ["Framework64", "Framework"]) {
+    const csc = join4(root, "Microsoft.NET", framework, "v4.0.30319", "csc.exe");
+    if (existsSync4(csc))
+      return csc;
+  }
+  return null;
+}
+function launcherFileName(source = PTY_JOB_LAUNCHER_CS) {
+  return `rove-pty-job-${createHash2("sha256").update(source).digest("hex").slice(0, 12)}.exe`;
+}
+function newPtyJobName() {
+  return `Local\\rove-pty-${randomUUID()}`;
+}
+async function compileLauncher(binDir, exe) {
+  const csc = findCsc();
+  if (!csc)
+    return "no .NET Framework csc.exe";
+  mkdirSync(binDir, { recursive: true });
+  const tag = `${process.pid}-${randomUUID().slice(0, 8)}`;
+  const src = join4(binDir, `rove-pty-job-${tag}.cs`);
+  const tmp = join4(binDir, `rove-pty-job-${tag}.exe`);
+  try {
+    writeFileSync(src, PTY_JOB_LAUNCHER_CS);
+    const built = await run(csc, ["/nologo", "/target:exe", "/optimize+", `/out:${tmp}`, src], COMPILE_TIMEOUT_MS);
+    if (built.code !== 0 || !existsSync4(tmp))
+      return `csc failed: ${built.output}`;
+    try {
+      renameSync2(tmp, exe);
+    } catch (err) {
+      if (!existsSync4(exe))
+        return `could not place ${exe}: ${err.message}`;
+    }
+    return null;
+  } finally {
+    rmSync(src, { force: true });
+    rmSync(tmp, { force: true });
+  }
+}
+async function selfTest(exe) {
+  const comspec = process.env.ComSpec || "cmd.exe";
+  const probe = await run(exe, [comspec, "/d", "/c", `exit ${SELF_TEST_EXIT_CODE}`], SELF_TEST_TIMEOUT_MS, {
+    ...process.env,
+    [PTY_JOB_ENV]: newPtyJobName()
+  });
+  return probe.code === SELF_TEST_EXIT_CODE ? null : `self-test exited ${probe.code}: ${probe.output}`;
+}
+async function ensurePtyJobLauncher(binDir) {
+  try {
+    const exe = join4(binDir, launcherFileName());
+    let cachedFailure = null;
+    if (existsSync4(exe)) {
+      cachedFailure = await selfTest(exe);
+      if (cachedFailure === null)
+        return { path: exe };
+      rmSync(exe, { force: true });
+    }
+    const compileFailure = await compileLauncher(binDir, exe);
+    if (compileFailure)
+      return { path: null, reason: compileFailure };
+    const failure = await selfTest(exe);
+    if (failure === null)
+      return { path: exe };
+    return { path: null, reason: cachedFailure ? `${failure} (rebuilt after: ${cachedFailure})` : failure };
+  } catch (err) {
+    return { path: null, reason: `launcher setup failed: ${err.message}` };
+  }
+}
+function sameSocket(a, b) {
+  const norm = (p) => resolve(p.replace(/\//g, "\\")).toLowerCase();
+  return norm(a) === norm(b);
+}
+function withoutPtyJob(env) {
+  const out = { ...env };
+  delete out[PTY_JOB_ENV];
+  delete out[PTY_JOB_OWNER_ENV];
+  return out;
+}
+function ptyJobLaunch(env, ownDaemonSocket) {
+  const job = env[PTY_JOB_ENV];
+  const owner = env[PTY_JOB_OWNER_ENV];
+  if (!job || !owner)
+    return null;
+  return { job, mode: sameSocket(owner, ownDaemonSocket) ? "escape" : "join" };
+}
+
+// ../rove-daemon/src/daemon/pty-driver.ts
 var TERMINAL_NAME = "xterm-256color";
 function bunTerminalDriver(spawn) {
   const spawnTerminal = spawn ?? ((argv, options) => Bun.spawn(argv, options));
@@ -235,20 +427,26 @@ function bunTerminalDriver(spawn) {
     };
   };
 }
-async function nodePtyDriver(spawn, endTree = taskkillProcessTree) {
+async function nodePtyDriver(spawn, endTree = taskkillProcessTree, job) {
   const spawnPty = spawn ?? (await import("node-pty")).spawn;
   return (request) => {
     const [file, ...args] = request.argv;
-    const child = spawnPty(file ?? "", args, {
+    const env = Object.fromEntries(Object.entries(request.env).filter((entry) => entry[1] !== undefined));
+    const [spawnFile, spawnArgs, spawnEnv] = job ? [
+      job.launcher,
+      [file ?? "", ...args],
+      { ...env, [PTY_JOB_ENV]: newPtyJobName(), [PTY_JOB_OWNER_ENV]: job.owner }
+    ] : [file ?? "", args, env];
+    const child = spawnPty(spawnFile, spawnArgs, {
       name: TERMINAL_NAME,
       cols: request.cols,
       rows: request.rows,
       cwd: request.cwd,
-      env: Object.fromEntries(Object.entries(request.env).filter((entry) => entry[1] !== undefined))
+      env: spawnEnv
     });
     let settle = () => {};
-    const exited = new Promise((resolve) => {
-      settle = resolve;
+    const exited = new Promise((resolve2) => {
+      settle = resolve2;
     });
     child.onData((data) => request.onData(data));
     child.onExit(({ exitCode }) => settle({ code: exitCode, signal: null }));
@@ -264,18 +462,18 @@ async function nodePtyDriver(spawn, endTree = taskkillProcessTree) {
   };
 }
 
-// ../kobe-daemon/src/daemon/pty-host-log.ts
+// ../rove-daemon/src/daemon/pty-host-log.ts
 function formatPtyHostLine(event, message, now = new Date) {
   return `[${now.toISOString()}] pty-host [${event}]: ${message}`;
 }
 
-// ../kobe-daemon/src/daemon/pty-server.ts
+// ../rove-daemon/src/daemon/pty-server.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { mkdir as mkdir3, unlink as unlink2 } from "node:fs/promises";
+import { mkdir as mkdir4, unlink } from "node:fs/promises";
 import { createServer } from "node:net";
-import { dirname as dirname5 } from "node:path";
+import { dirname as dirname7 } from "node:path";
 
-// ../kobe-daemon/src/daemon/client-writer.ts
+// ../rove-daemon/src/daemon/client-writer.ts
 var DEFAULT_WRITE_HIGH_WATER_MARK = 8 * 1024 * 1024;
 
 class ClientWriter {
@@ -368,28 +566,7 @@ class ClientWriter {
   }
 }
 
-// ../kobe-daemon/src/daemon/compat-link.ts
-import { lstat, symlink, unlink } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
-async function linkLegacyRuntimePath(canonical, legacy) {
-  if (canonical === legacy)
-    return false;
-  try {
-    if (!await lstat(dirname2(legacy)).catch(() => null))
-      return false;
-    const existing = await lstat(legacy).catch(() => null);
-    if (existing && !existing.isSymbolicLink())
-      return false;
-    if (existing)
-      await unlink(legacy).catch(() => {});
-    await symlink(canonical, legacy);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// ../kobe-daemon/src/daemon/crash-log.ts
+// ../rove-daemon/src/daemon/crash-log.ts
 function toError(err) {
   if (err instanceof Error)
     return err;
@@ -410,19 +587,19 @@ function logDaemonError(subsystem, err) {
   process.stderr.write(formatDaemonError(subsystem, err));
 }
 
-// ../kobe-daemon/src/daemon/json-file.ts
-import { randomUUID } from "node:crypto";
+// ../rove-daemon/src/daemon/json-file.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir, rename, writeFile } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 async function writeTextAtomic(path, text, mode) {
   await mkdir(dirname3(path), { recursive: true });
-  const tmp = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  const tmp = `${path}.tmp-${process.pid}-${randomUUID2()}`;
   await writeFile(tmp, text, { encoding: "utf8", mode });
   await rename(tmp, path);
 }
 var locks = new Map;
 
-// ../kobe-daemon/src/daemon/line-receiver.ts
+// ../rove-daemon/src/daemon/line-receiver.ts
 var MAX_REQUEST_FRAME_BYTES = 8 * 1024 * 1024;
 
 class LineReceiver {
@@ -469,10 +646,10 @@ class LineReceiver {
   }
 }
 
-// ../kobe-daemon/src/daemon/owner-only.ts
+// ../rove-daemon/src/daemon/owner-only.ts
 import { chmodSync } from "node:fs";
 import { chmod, mkdir as mkdir2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 var OWNER_ONLY_DIR_MODE = 448;
 var OWNER_ONLY_FILE_MODE = 384;
 async function tighten(path, mode) {
@@ -501,12 +678,12 @@ async function ensureOwnerOnlyDir(dir) {
   await tightenDirPermissions(dir);
 }
 function ensureOwnerOnlyStateDir(homeDir) {
-  return ensureOwnerOnlyDir(join3(homeDir, ROVE_STATE_DIR_BASENAME));
+  return ensureOwnerOnlyDir(join5(homeDir, ROVE_STATE_DIR_BASENAME));
 }
 
-// ../kobe-daemon/src/daemon/automation-contracts.ts
+// ../rove-daemon/src/daemon/automation-contracts.ts
 var ROUTINE_RESPONSE_WINDOW_MS = 2 * 60 * 60000;
-// ../kobe-plugin-sdk/dist/contract.js
+// ../rove-plugin-sdk/dist/contract.js
 var DAEMON_CHANNELS = [
   "task.snapshot",
   "issue.snapshot",
@@ -532,13 +709,13 @@ var DAEMON_CHANNELS = [
   "graphics.write"
 ];
 
-// ../kobe-daemon/src/daemon/channels.ts
+// ../rove-daemon/src/daemon/channels.ts
 var CHANNEL_NAMES = DAEMON_CHANNELS;
 var CHANNEL_NAME_SET = new Set(CHANNEL_NAMES);
-// ../kobe-daemon/src/daemon/protocol-compat.ts
+// ../rove-daemon/src/daemon/protocol-compat.ts
 var DAEMON_PROTOCOL_VERSION = 5;
 
-// ../kobe-daemon/src/daemon/protocol.ts
+// ../rove-daemon/src/daemon/protocol.ts
 var BLOCKING_RPCS = new Set([
   "ui.prompt",
   "task.land",
@@ -556,10 +733,10 @@ function frameToLine(frame) {
 `;
 }
 
-// ../kobe-daemon/src/daemon/pty-data-migration.ts
-import { existsSync as existsSync4, lstatSync, mkdirSync, renameSync as renameSync2, symlinkSync } from "node:fs";
+// ../rove-daemon/src/daemon/pty-data-migration.ts
+import { existsSync as existsSync5, lstatSync, mkdirSync as mkdirSync2, renameSync as renameSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 var PTY_HOST_DATA_ENTRIES = ["pty-exits.json", "pty-sessions"];
 function lstatIfExists(path) {
   try {
@@ -569,37 +746,34 @@ function lstatIfExists(path) {
   }
 }
 function migrateLegacyPtyHostData(homeDir = readRoveHomeDirEnv() ?? homedir2()) {
-  const canonicalDir = join4(homeDir, ROVE_STATE_DIR_BASENAME);
-  const legacyDir = join4(homeDir, COMPAT_STATE_DIR_BASENAME);
+  const canonicalDir = join6(homeDir, ROVE_STATE_DIR_BASENAME);
+  const legacyDir = preRenameStateDir(homeDir);
   if (canonicalDir === legacyDir)
     return [];
   const moved = [];
   for (const name of PTY_HOST_DATA_ENTRIES) {
-    const canonical = join4(canonicalDir, name);
-    const legacy = join4(legacyDir, name);
+    const canonical = join6(canonicalDir, name);
+    const legacy = join6(legacyDir, name);
     try {
-      if (existsSync4(canonical))
+      if (existsSync5(canonical))
         continue;
       const stat = lstatIfExists(legacy);
       if (!stat || stat.isSymbolicLink())
         continue;
-      mkdirSync(canonicalDir, { recursive: true });
-      renameSync2(legacy, canonical);
+      mkdirSync2(canonicalDir, { recursive: true });
+      renameSync3(legacy, canonical);
       moved.push(name);
-      try {
-        symlinkSync(canonical, legacy);
-      } catch {}
     } catch {}
   }
   return moved;
 }
 
-// ../kobe-daemon/src/daemon/pty-exit-store.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync3, writeFileSync } from "node:fs";
+// ../rove-daemon/src/daemon/pty-exit-store.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync4, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 
-// ../kobe-daemon/src/daemon/terminal-rows.ts
+// ../rove-daemon/src/daemon/terminal-rows.ts
 var CURSOR_DOWN_RE = /\x1b\[(\d*)[BE]/g;
 var CURSOR_POSITION_RE = /\x1b\[[\d;]*[Hf]/g;
 var MAX_ROWS_PER_ESCAPE = 200;
@@ -623,7 +797,7 @@ function terminalRows(raw, maxLineChars) {
   });
 }
 
-// ../kobe-daemon/src/daemon/pty-exit-store.ts
+// ../rove-daemon/src/daemon/pty-exit-store.ts
 var MAX_RECORDS = 50;
 var TAIL_LINES = 40;
 var TAIL_LINE_CHARS = 500;
@@ -650,6 +824,11 @@ function healTails(records) {
   }
   return out;
 }
+function compareByExitAtDesc(a, b) {
+  if (a.at === b.at)
+    return 0;
+  return a.at < b.at ? 1 : -1;
+}
 function readPtyExitStore(path = defaultPtyExitsPath()) {
   const read = (status, records = {}) => ({
     records,
@@ -693,23 +872,23 @@ function writeRecord(storeKey, record, path) {
     throw new Error(`pty-exits store is unreadable (${path}) — refusing to overwrite it`);
   const records = store.records;
   records[storeKey] = record;
-  const newest = Object.entries(records).sort(([, a], [, b]) => a.at < b.at ? 1 : -1).slice(0, MAX_RECORDS);
-  mkdirSync2(dirname4(path), { recursive: true });
-  const tmp = `${path}.tmp-${process.pid}-${randomUUID2()}`;
-  writeFileSync(tmp, JSON.stringify(Object.fromEntries(newest), null, 2), {
+  const newest = Object.entries(records).sort(([, a], [, b]) => compareByExitAtDesc(a, b)).slice(0, MAX_RECORDS);
+  mkdirSync3(dirname4(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}-${randomUUID3()}`;
+  writeFileSync2(tmp, JSON.stringify(Object.fromEntries(newest), null, 2), {
     encoding: "utf8",
     mode: OWNER_ONLY_FILE_MODE
   });
-  renameSync3(tmp, path);
+  renameSync4(tmp, path);
 }
 
-// ../kobe-daemon/src/daemon/pty-freeze-store.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, readdirSync, renameSync as renameSync4, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+// ../rove-daemon/src/daemon/pty-freeze-store.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, readdirSync, renameSync as renameSync5, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
-// ../kobe-daemon/src/daemon/terminal-colors.ts
+// ../rove-daemon/src/daemon/terminal-colors.ts
 var DEFAULT_TERMINAL_COLORS = {
   foreground: "#eae7df",
   background: "#141413"
@@ -758,7 +937,7 @@ function foldDefaultColorQueries(previousCarry, chunkText) {
   return { slots, carry: trailingQueryPrefix(text.slice(end)) };
 }
 
-// ../kobe-daemon/src/daemon/terminal-modes.ts
+// ../rove-daemon/src/daemon/terminal-modes.ts
 var DEFAULT_MODES = {
   applicationCursorKeys: false,
   applicationKeypad: false,
@@ -1030,7 +1209,7 @@ function ansiModeValue(modes, mode) {
   }
 }
 
-// ../kobe-daemon/src/daemon/pty-freeze-store.ts
+// ../rove-daemon/src/daemon/pty-freeze-store.ts
 var FREEZE_VERSION = 1;
 function freezeSession(session, now = new Date) {
   return {
@@ -1071,7 +1250,7 @@ function thawSession(record, cap) {
     scanTerminalModes(modes, chunk.toString("latin1"));
   return {
     key: record.key,
-    generation: randomUUID3(),
+    generation: randomUUID4(),
     cwd: record.cwd,
     proc: null,
     alive: false,
@@ -1098,7 +1277,7 @@ function thawSession(record, cap) {
   };
 }
 function recordFile(dir, key) {
-  return join5(dir, `${encodeURIComponent(key)}.json`);
+  return join7(dir, `${encodeURIComponent(key)}.json`);
 }
 function parseRecord(raw) {
   try {
@@ -1136,7 +1315,7 @@ function loadFrozenSessions(dir = defaultPtyFreezeDir(), now = Date.now(), repor
     if (!name.endsWith(".json"))
       continue;
     try {
-      const st = statSync2(join5(dir, name));
+      const st = statSync2(join7(dir, name));
       entries.push({ name, size: st.size, mtimeMs: st.mtimeMs });
     } catch {}
   }
@@ -1157,7 +1336,7 @@ function loadFrozenSessions(dir = defaultPtyFreezeDir(), now = Date.now(), repor
     }
     let record = null;
     try {
-      record = parseRecord(readFileSync3(join5(dir, entry.name), "utf8"));
+      record = parseRecord(readFileSync3(join7(dir, entry.name), "utf8"));
     } catch {}
     bytesRead += entry.size;
     if (!record) {
@@ -1171,7 +1350,7 @@ function loadFrozenSessions(dir = defaultPtyFreezeDir(), now = Date.now(), repor
   }
   for (const name of stale) {
     try {
-      rmSync(join5(dir, name), { force: true });
+      rmSync2(join7(dir, name), { force: true });
     } catch {}
   }
   kept.sort((a, b) => updatedAtMs(b) - updatedAtMs(a));
@@ -1188,7 +1367,7 @@ function tightenExistingPermissions(dir) {
   }
   for (const name of names) {
     if (name.endsWith(".json"))
-      tightenFilePermissionsSync(join5(dir, name));
+      tightenFilePermissionsSync(join7(dir, name));
   }
 }
 function fileFreezeSink(dir = defaultPtyFreezeDir()) {
@@ -1196,31 +1375,31 @@ function fileFreezeSink(dir = defaultPtyFreezeDir()) {
   return {
     save(record) {
       try {
-        mkdirSync3(dir, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
+        mkdirSync4(dir, { recursive: true, mode: OWNER_ONLY_DIR_MODE });
         const target = recordFile(dir, record.key);
         const staging = `${target}.${process.pid}.tmp`;
-        writeFileSync2(staging, JSON.stringify(record), { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
-        renameSync4(staging, target);
+        writeFileSync3(staging, JSON.stringify(record), { encoding: "utf8", mode: OWNER_ONLY_FILE_MODE });
+        renameSync5(staging, target);
       } catch {}
     },
     drop(key) {
       try {
-        rmSync(recordFile(dir, key), { force: true });
+        rmSync2(recordFile(dir, key), { force: true });
       } catch {}
     }
   };
 }
 function clearFrozenSessions(dir = defaultPtyFreezeDir()) {
   try {
-    rmSync(dir, { recursive: true, force: true });
+    rmSync2(dir, { recursive: true, force: true });
   } catch {}
 }
 
-// ../kobe-daemon/src/daemon/pty-child-controller.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+// ../rove-daemon/src/daemon/pty-child-controller.ts
+import { randomUUID as randomUUID6 } from "node:crypto";
 
-// ../kobe-daemon/src/daemon/platform-shell.js
-import { existsSync as existsSync5 } from "node:fs";
+// ../rove-daemon/src/daemon/platform-shell.js
+import { existsSync as existsSync6 } from "node:fs";
 function windowsBashCandidates(env) {
   const roots = [env.ProgramFiles, env["ProgramFiles(x86)"], env.LOCALAPPDATA && `${env.LOCALAPPDATA}\\Programs`];
   return roots.filter(Boolean).map((root) => `${root}\\Git\\bin\\bash.exe`);
@@ -1239,7 +1418,7 @@ function resolveLoginShell(options = {}) {
   const fallback = options.fallback ?? "/bin/bash";
   const platform = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const exists = options.exists ?? existsSync5;
+  const exists = options.exists ?? existsSync6;
   const cacheable = platform === process.platform && env === process.env && options.exists === undefined;
   if (cacheable) {
     const hit = cache.get(fallback);
@@ -1264,7 +1443,7 @@ function resolveUncached(fallback, platform, env, exists) {
   return WINDOWS_BASH_FALLBACK;
 }
 
-// ../kobe-daemon/src/daemon/pty-env.js
+// ../rove-daemon/src/daemon/pty-env.js
 var IDENTITY_VARS = new Set([
   "TERM_PROGRAM",
   "TERM_PROGRAM_VERSION",
@@ -1295,13 +1474,13 @@ function embeddedTerminalEnv(base, overrides = {}) {
   return { ...env, ...overrides };
 }
 
-// ../kobe-daemon/src/daemon/pty-host-types.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+// ../rove-daemon/src/daemon/pty-host-types.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { StringDecoder as StringDecoder2 } from "node:string_decoder";
 function freshSessionState(key, spec, argv) {
   return {
     key,
-    generation: randomUUID4(),
+    generation: randomUUID5(),
     cwd: spec.cwd,
     proc: null,
     alive: true,
@@ -1329,7 +1508,7 @@ function freshSessionState(key, spec, argv) {
   };
 }
 
-// ../kobe-daemon/src/daemon/pty-observability.ts
+// ../rove-daemon/src/daemon/pty-observability.ts
 function sessionInfo(s) {
   return {
     key: s.key,
@@ -1432,13 +1611,13 @@ function peekRing(session, sinceOffset) {
   };
 }
 
-// ../kobe-daemon/src/daemon/pty-termination.ts
+// ../rove-daemon/src/daemon/pty-termination.ts
 async function settledWithin(exited, ms) {
   let timer;
   const settled = await Promise.race([
     exited.then(() => true, () => true),
-    new Promise((resolve) => {
-      timer = setTimeout(() => resolve(false), ms);
+    new Promise((resolve2) => {
+      timer = setTimeout(() => resolve2(false), ms);
     })
   ]);
   if (timer)
@@ -1475,7 +1654,7 @@ async function terminatePtyChild(proc, onSettled, onSignal) {
   onSettled();
 }
 
-// ../kobe-daemon/src/daemon/pty-child-controller.ts
+// ../rove-daemon/src/daemon/pty-child-controller.ts
 class PtyChildController {
   deps;
   constructor(deps) {
@@ -1492,7 +1671,7 @@ class PtyChildController {
     return session;
   }
   startChild(session) {
-    session.generation = randomUUID5();
+    session.generation = randomUUID6();
     try {
       session.proc = (this.deps.driver ?? bunTerminalDriver())({
         argv: [...session.command],
@@ -1502,7 +1681,7 @@ class PtyChildController {
           COLUMNS: String(session.cols),
           LINES: String(session.rows),
           BASH_SILENCE_DEPRECATION_WARNING: "1",
-          KOBE_TERMINAL_PTY: "1"
+          ROVE_TERMINAL_PTY: "1"
         }),
         cols: session.cols,
         rows: session.rows,
@@ -1569,7 +1748,7 @@ class PtyChildController {
   }
 }
 
-// ../kobe-daemon/src/daemon/pty-freeze-policy.ts
+// ../rove-daemon/src/daemon/pty-freeze-policy.ts
 var FREEZE_INTERVAL_MS = 5000;
 var FREEZE_MIN_APPENDED_BYTES = 64 * 1024;
 var FREEZE_STALE_MS = 60000;
@@ -1583,7 +1762,7 @@ function shouldFreeze(session, now) {
   return appended >= FREEZE_MIN_APPENDED_BYTES || since >= FREEZE_STALE_MS;
 }
 
-// ../kobe-daemon/src/daemon/pty-warm.ts
+// ../rove-daemon/src/daemon/pty-warm.ts
 class WarmSpare {
   deps;
   spare = null;
@@ -1636,7 +1815,7 @@ class WarmSpare {
   }
 }
 
-// ../kobe-daemon/src/daemon/pty-host.ts
+// ../rove-daemon/src/daemon/pty-host.ts
 var LOGGED_WRITE_BYTES = 1024;
 var DEFAULT_SCROLLBACK_CAP = 512 * 1024;
 var EXIT_TAIL_BYTES = 16 * 1024;
@@ -1907,7 +2086,533 @@ class PtyHost {
   }
 }
 
-// ../kobe-daemon/src/daemon/handler-validators.ts
+// ../rove-daemon/src/client/detached-spawn.ts
+import { spawn as spawn2 } from "node:child_process";
+import { appendFileSync, closeSync, mkdirSync as mkdirSync5, openSync } from "node:fs";
+import { dirname as dirname6 } from "node:path";
+
+// ../rove-daemon/src/client/index.ts
+import { connect } from "node:net";
+import { StringDecoder as StringDecoder3 } from "node:string_decoder";
+
+// ../rove-daemon/src/client/client-log.ts
+import { appendFile, mkdir as mkdir3, rename as rename2, stat } from "node:fs/promises";
+import { dirname as dirname5 } from "node:path";
+var context = "client";
+function coerceError(err) {
+  if (err instanceof Error)
+    return { message: err.message, stack: err.stack };
+  let text;
+  try {
+    text = typeof err === "string" ? err : JSON.stringify(err);
+  } catch {
+    text = String(err);
+  }
+  return { message: text };
+}
+function formatClientEntry(subsystem, message, now = new Date) {
+  return `[${now.toISOString()}] client ${context} [${subsystem}] pid=${process.pid}: ${message}
+`;
+}
+var warnedOnce = false;
+function warnOnce() {
+  if (warnedOnce)
+    return;
+  warnedOnce = true;
+  try {
+    process.stderr.write(`[rove] client log write failed; continuing without it
+`);
+  } catch {}
+}
+var writeChain = Promise.resolve();
+async function rotateClientLogIfNeeded(path) {
+  try {
+    const { size } = await stat(path);
+    if (!shouldRotateLog(size, DEFAULT_LOG_ROTATE_CAP_BYTES))
+      return;
+    await rename2(path, `${path}.old`);
+  } catch {}
+}
+function append(line, logPath) {
+  const path = logPath ?? defaultClientLogPath();
+  writeChain = writeChain.then(async () => {
+    await rotateClientLogIfNeeded(path);
+    try {
+      await appendFile(path, line);
+    } catch (err) {
+      if (err?.code === "ENOENT") {
+        await mkdir3(dirname5(path), { recursive: true });
+        await appendFile(path, line);
+      } else {
+        throw err;
+      }
+    }
+  }).catch(() => warnOnce());
+}
+function logClientError(subsystem, err) {
+  const e = coerceError(err);
+  append(formatClientEntry(subsystem, e.stack ?? e.message));
+}
+
+// ../rove-daemon/src/client/index.ts
+class RpcTimeoutError extends Error {
+  constructor(name, timeoutMs) {
+    super(`daemon rpc "${name}" timed out after ${timeoutMs}ms (daemon wedged?)`);
+    this.name = "RpcTimeoutError";
+  }
+}
+function rpcTimeoutMs() {
+  const raw = readRoveEnv("RPC_TIMEOUT_MS")?.trim();
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 20000;
+}
+
+class ConnectTimeoutError extends Error {
+  constructor(socketPath, timeoutMs) {
+    super(`connecting to ${socketPath} timed out after ${timeoutMs}ms — nothing accepted the connection (daemon or PTY host not listening at that address)`);
+    this.name = "ConnectTimeoutError";
+  }
+}
+function connectTimeoutMs() {
+  const raw = readRoveEnv("CONNECT_TIMEOUT_MS")?.trim();
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return 5000;
+}
+
+class RoveDaemonClient {
+  socketPath;
+  socket = null;
+  buffer = "";
+  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();
+    if (this.disposed)
+      return Promise.reject(new Error("daemon client disposed"));
+    if (this.connecting)
+      return this.connecting;
+    const p = this.openSocketWithFallback();
+    this.connecting = p;
+    const cleanup = () => {
+      if (this.connecting === p)
+        this.connecting = null;
+    };
+    p.then(cleanup, cleanup);
+    return p;
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  close() {
+    this.disposed = true;
+    this.socket?.end();
+    this.socket = null;
+    this.failPending();
+  }
+  forceDisconnect() {
+    const socket = this.socket;
+    if (!socket)
+      return;
+    this.socket = null;
+    socket.destroy();
+    this.failPending();
+  }
+  failPending() {
+    if (this.pending.size === 0)
+      return;
+    const err = new Error("daemon connection closed");
+    for (const pending of this.pending.values()) {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+  on(name, handler) {
+    let set = this.handlers.get(name);
+    if (!set) {
+      set = new Set;
+      this.handlers.set(name, set);
+    }
+    set.add(handler);
+    return () => {
+      set?.delete(handler);
+      if (set?.size === 0)
+        this.handlers.delete(name);
+    };
+  }
+  onChannel(channel, handler) {
+    return this.on(channel, (frame) => handler(frame.payload));
+  }
+  subscribe(opts = {}) {
+    const payload = {};
+    if (opts.channels)
+      payload.channels = opts.channels;
+    if (opts.role)
+      payload.role = opts.role;
+    if (opts.cellPixelSize) {
+      payload.cellPixelWidth = opts.cellPixelSize.width;
+      payload.cellPixelHeight = opts.cellPixelSize.height;
+    }
+    return this.request("subscribe", payload);
+  }
+  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;
+    if (!socket)
+      throw new Error("daemon connection is not open");
+    const id = String(this.nextId++);
+    const promise = new Promise((resolve2, reject) => {
+      const entry = { resolve: (value) => resolve2(value), reject };
+      const timeoutMs = rpcTimeoutMs();
+      if (timeoutMs > 0 && !BLOCKING_RPCS.has(name)) {
+        entry.timer = setTimeout(() => this.onRequestTimeout(id, name, timeoutMs), timeoutMs);
+      }
+      this.pending.set(id, entry);
+    });
+    socket.write(frameToLine({ type: "request", id, name, payload }));
+    return promise;
+  }
+  onRequestTimeout(id, name, timeoutMs) {
+    const pending = this.pending.get(id);
+    if (!pending)
+      return;
+    this.pending.delete(id);
+    pending.reject(new RpcTimeoutError(name, timeoutMs));
+    this.forceDisconnect();
+    this.emitLifecycle("close");
+  }
+  async openSocketWithFallback() {
+    try {
+      await this.openSocket(this.socketPath);
+      return;
+    } catch (err) {
+      if (!(err instanceof Error) || !("code" in err) || !["ENOENT", "ECONNREFUSED"].includes(String(err.code)))
+        throw err;
+      for (const path of preRenameRuntimePaths(this.socketPath)) {
+        if (this.disposed)
+          throw err;
+        try {
+          await this.openSocket(path);
+          return;
+        } catch {}
+      }
+      throw err;
+    }
+  }
+  openSocket(path) {
+    return new Promise((resolve2, reject) => {
+      const socket = connect(path);
+      this.socket = socket;
+      const timeoutMs = connectTimeoutMs();
+      let timer;
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          socket.off("connect", onConnect);
+          socket.off("error", onError);
+          socket.destroy();
+          if (this.socket === socket)
+            this.socket = null;
+          reject(new ConnectTimeoutError(this.socketPath, timeoutMs));
+        }, timeoutMs);
+      }
+      const onConnect = () => {
+        if (timer)
+          clearTimeout(timer);
+        socket.off("error", onError);
+        socket.on("error", () => socket.destroy());
+        resolve2();
+      };
+      const onError = (err) => {
+        if (timer)
+          clearTimeout(timer);
+        socket.off("connect", onConnect);
+        if (this.socket === socket)
+          this.socket = null;
+        reject(err);
+      };
+      socket.once("connect", onConnect);
+      socket.once("error", onError);
+      const decoder = new StringDecoder3("utf8");
+      this.buffer = "";
+      socket.on("data", (chunk) => this.onData(decoder.write(chunk)));
+      socket.on("close", () => this.onSocketClose(socket));
+    });
+  }
+  onSocketClose(which) {
+    if (this.socket !== which)
+      return;
+    this.socket = null;
+    this.failPending();
+    this.emitLifecycle("close");
+  }
+  emitLifecycle(name) {
+    for (const handler of this.lifecycleHandlers.get(name) ?? []) {
+      try {
+        handler();
+      } catch (err) {
+        console.error(`[rove] lifecycle handler for "${name}" threw:`, err);
+      }
+    }
+  }
+  onData(chunk) {
+    this.buffer += chunk;
+    let nl = this.buffer.indexOf(`
+`);
+    while (nl !== -1) {
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(nl + 1);
+      if (line.trim().length > 0)
+        this.onLine(line);
+      nl = this.buffer.indexOf(`
+`);
+    }
+  }
+  onLine(line) {
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch (err) {
+      logClientError("client-frame", err);
+      return;
+    }
+    if (frame.type === "event") {
+      this.emit(frame);
+      return;
+    }
+    if (frame.type !== "response")
+      return;
+    const pending = this.pending.get(frame.id);
+    if (!pending)
+      return;
+    this.pending.delete(frame.id);
+    if (pending.timer)
+      clearTimeout(pending.timer);
+    if (frame.error) {
+      const err = new Error(frame.error.message);
+      if (frame.error.name)
+        err.name = frame.error.name;
+      pending.reject(err);
+    } else
+      pending.resolve(frame.payload);
+  }
+  emit(frame) {
+    for (const handler of this.handlers.get(frame.name) ?? []) {
+      try {
+        handler(frame);
+      } catch (err) {
+        logClientError("client-event", err);
+      }
+    }
+    for (const handler of this.handlers.get("*") ?? []) {
+      try {
+        handler(frame);
+      } catch (err) {
+        logClientError("client-event", err);
+      }
+    }
+  }
+}
+
+// ../rove-daemon/src/client/win-detached-launch.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync7 } from "node:fs";
+import { join as join8 } from "node:path";
+var LAUNCH_CMD_ENV = "ROVE_LAUNCH_CMD";
+var LAUNCH_LOG_ENV = "ROVE_LAUNCH_LOG";
+var WIN_DETACHED_LAUNCHER_PS = `
+$ErrorActionPreference = 'Stop'
+$cmd = $env:${LAUNCH_CMD_ENV}
+$log = $env:${LAUNCH_LOG_ENV}
+if (-not $cmd -or -not $log) { [Console]::Error.WriteLine('rove launcher: ${LAUNCH_CMD_ENV}/${LAUNCH_LOG_ENV} not set'); exit 1 }
+Remove-Item Env:${LAUNCH_CMD_ENV}, Env:${LAUNCH_LOG_ENV}
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class RoveDetachedLaunch {
+  [StructLayout(LayoutKind.Sequential)] public struct SA { public int nLength; public IntPtr lpSecurityDescriptor; public bool bInheritHandle; }
+  [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] public struct SI { public int cb; public string lpReserved; public string lpDesktop; public string lpTitle; public int dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags; public short wShowWindow, cbReserved2; public IntPtr lpReserved2, hStdInput, hStdOutput, hStdError; }
+  [StructLayout(LayoutKind.Sequential)] public struct PI { public IntPtr hProcess, hThread; public int dwProcessId, dwThreadId; }
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern IntPtr CreateFile(string name, uint access, uint share, ref SA sa, uint disposition, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", CharSet=CharSet.Unicode, SetLastError=true)] static extern bool CreateProcess(string app, string cmd, IntPtr pa, IntPtr ta, bool inherit, uint flags, IntPtr env, string cwd, ref SI si, out PI pi);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr h);
+  public static int Launch(string cmd, string log) {
+    SA sa = new SA(); sa.nLength = Marshal.SizeOf(sa); sa.bInheritHandle = true;
+    // FILE_APPEND_DATA | GENERIC_READ, shared read/write, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL
+    IntPtr h = CreateFile(log, 0x0004 | 0x80000000, 0x1 | 0x2, ref sa, 4, 0x80, IntPtr.Zero);
+    if (h == (IntPtr)(-1)) throw new Exception("CreateFile(" + log + ") failed: " + Marshal.GetLastWin32Error());
+    IntPtr nul = CreateFile("NUL", 0x80000000, 0x1 | 0x2, ref sa, 3, 0x80, IntPtr.Zero);
+    SI si = new SI(); si.cb = Marshal.SizeOf(si);
+    si.dwFlags = 0x100 | 0x1; // STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW
+    si.wShowWindow = 0;       // SW_HIDE
+    si.hStdInput = nul; si.hStdOutput = h; si.hStdError = h;
+    PI pi;
+    uint flags = 0x00000010 | 0x01000000 | 0x00000200; // CREATE_NEW_CONSOLE | CREATE_BREAKAWAY_FROM_JOB | CREATE_NEW_PROCESS_GROUP
+    if (!CreateProcess(null, cmd, IntPtr.Zero, IntPtr.Zero, true, flags, IntPtr.Zero, null, ref si, out pi)) throw new Exception("CreateProcess failed: " + Marshal.GetLastWin32Error());
+    CloseHandle(h); CloseHandle(nul); CloseHandle(pi.hThread); CloseHandle(pi.hProcess);
+    return pi.dwProcessId;
+  }
+}
+'@
+[RoveDetachedLaunch]::Launch($cmd, $log) | Out-Null
+`;
+function windowsCommandLine(argv) {
+  return argv.map(quoteWindowsArg).join(" ");
+}
+function quoteWindowsArg(arg) {
+  if (arg !== "" && !/[\s"]/.test(arg))
+    return arg;
+  let out = '"';
+  let backslashes = 0;
+  for (const ch of arg) {
+    if (ch === "\\") {
+      backslashes++;
+      continue;
+    }
+    if (ch === '"') {
+      out += `${"\\".repeat(backslashes * 2 + 1)}"`;
+      backslashes = 0;
+      continue;
+    }
+    out += "\\".repeat(backslashes) + ch;
+    backslashes = 0;
+  }
+  return `${out}${"\\".repeat(backslashes * 2)}"`;
+}
+function windowsPowershellPath(env = process.env, exists = existsSync7) {
+  const root = env.SystemRoot || env.windir || "C:\\Windows";
+  const absolute = join8(root, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+  return exists(absolute) ? absolute : "powershell.exe";
+}
+function encodePowershellCommand(script) {
+  return Buffer.from(script, "utf16le").toString("base64");
+}
+function windowsDetachedLauncherArgs() {
+  return [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    encodePowershellCommand(WIN_DETACHED_LAUNCHER_PS)
+  ];
+}
+function spawnWindowsDetached(command, args, env, logPath, spawnImpl = spawn) {
+  const child = spawnImpl(windowsPowershellPath(env), windowsDetachedLauncherArgs(), {
+    windowsHide: true,
+    stdio: "ignore",
+    env: { ...env, [LAUNCH_CMD_ENV]: windowsCommandLine([command, ...args]), [LAUNCH_LOG_ENV]: logPath }
+  });
+  child.unref();
+  return child;
+}
+
+// ../rove-daemon/src/client/detached-spawn.ts
+var ESCAPE_REQUEST_TIMEOUT_MS = 5000;
+function appendLaunchLog(logPath, line) {
+  try {
+    appendFileSync(logPath, `[${new Date().toISOString()}] rove: ${line}
+`);
+  } catch {}
+}
+async function launchViaPtyHost(command, args, env, logPath, socketPath) {
+  const client = new RoveDaemonClient(socketPath);
+  let timer;
+  try {
+    await Promise.race([
+      client.request("spawn.detached", { command, args: [...args], env, logPath }),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("timed out")), ESCAPE_REQUEST_TIMEOUT_MS);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    client.close();
+  }
+}
+function detachOptions(platform = process.platform) {
+  return platform === "win32" ? { windowsHide: true } : { detached: true };
+}
+function spawnDetachedDaemon(command, args, env, logPath, platform = process.platform) {
+  try {
+    mkdirSync5(dirname6(logPath), { recursive: true });
+  } catch {}
+  if (platform === "win32") {
+    if (ptyJobLaunch(env, defaultDaemonSocketPath())?.mode === "escape") {
+      const free = withoutPtyJob(env);
+      launchViaPtyHost(command, args, free, logPath, defaultPtyHostSocketPath()).catch((err) => {
+        appendLaunchLog(logPath, `PTY host could not launch outside the tab (${err.message}) — it ends with the tab`);
+        launchWindowsDetached(command, args, free, logPath, platform);
+      });
+      return;
+    }
+    launchWindowsDetached(command, args, env, logPath, platform);
+    return;
+  }
+  spawnDirect(command, args, env, logPath, platform);
+}
+function launchWindowsDetached(command, args, env, logPath, platform) {
+  const launcher = spawnWindowsDetached(command, args, env, logPath);
+  const fallback = (reason) => {
+    appendLaunchLog(logPath, `detached launcher ${reason} — spawning directly; this process will not outlive its parent`);
+    spawnDirect(command, args, env, logPath, platform);
+  };
+  launcher.once("error", (err) => fallback(`could not start (${err.message})`));
+  launcher.once("exit", (code, signal) => {
+    if (code !== 0)
+      fallback(`exited ${code ?? signal}`);
+  });
+}
+function spawnDirect(command, args, env, logPath, platform) {
+  let stdio = "ignore";
+  let logFd;
+  try {
+    mkdirSync5(dirname6(logPath), { recursive: true });
+    logFd = openSync(logPath, "a");
+    stdio = ["ignore", logFd, logFd];
+  } catch {
+    stdio = "ignore";
+  }
+  const child = spawn2(command, [...args], { ...detachOptions(platform), stdio, env });
+  child.unref();
+  if (logFd !== undefined) {
+    try {
+      closeSync(logFd);
+    } catch {}
+  }
+}
+
+// ../rove-daemon/src/daemon/handler-validators.ts
 function objectPayload(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return {};
@@ -1928,7 +2633,7 @@ function optionalBoolean(payload, key) {
   return value;
 }
 
-// ../kobe-daemon/src/daemon/pty-server-verbs.ts
+// ../rove-daemon/src/daemon/pty-server-verbs.ts
 function dispatchPtyRequest(req, client, deps) {
   const { ptys } = deps;
   switch (req.name) {
@@ -1996,6 +2701,14 @@ function dispatchPtyRequest(req, client, deps) {
       ptys.warm(requireString(payload, "cwd"), typeof payload.shell === "string" ? payload.shell : undefined, typeof payload.cols === "number" ? payload.cols : undefined, typeof payload.rows === "number" ? payload.rows : undefined);
       return {};
     }
+    case "spawn.detached": {
+      if (process.platform !== "win32")
+        throw new Error("spawn.detached is Windows-only");
+      const payload = objectPayload(req.payload);
+      const env = objectPayload(payload.env);
+      spawnDetachedDaemon(requireString(payload, "command"), Array.isArray(payload.args) ? payload.args.filter((a) => typeof a === "string") : [], withoutPtyJob(Object.fromEntries(Object.entries(env).filter((e) => typeof e[1] === "string"))), requireString(payload, "logPath"));
+      return {};
+    }
     case "daemon.stop":
       deps.requestStop();
       return {};
@@ -2004,32 +2717,32 @@ function dispatchPtyRequest(req, client, deps) {
   }
 }
 
-// ../kobe-daemon/src/daemon/socket-guard.ts
+// ../rove-daemon/src/daemon/socket-guard.ts
 async function listenOnUnixSocket(server, socketPath) {
-  await new Promise((resolve, reject) => {
+  await new Promise((resolve2, reject) => {
     const evented = server;
     evented.once("error", reject);
     server.listen(socketPath, () => {
       evented.removeListener("error", reject);
-      resolve();
+      resolve2();
     });
   });
   if (!isWindowsPipePath(socketPath))
     await tightenFilePermissions(socketPath);
 }
 
-// ../kobe-daemon/src/daemon/pty-server.ts
+// ../rove-daemon/src/daemon/pty-server.ts
 var DEFAULT_IDLE_EXIT_MS = 60000;
 var DEFAULT_ORPHAN_CHECK_MS = 30000;
 function resolveMaxLifetimeMs() {
-  const raw = process.env.KOBE_PTY_MAX_LIFETIME_MS;
+  const raw = process.env.ROVE_PTY_MAX_LIFETIME_MS;
   if (raw === undefined)
     return null;
   const n = Number(raw);
   return Number.isFinite(n) && n > 0 ? n : null;
 }
 function resolveIdleExitMs() {
-  const raw = process.env.KOBE_PTY_IDLE_EXIT_MS;
+  const raw = process.env.ROVE_PTY_IDLE_EXIT_MS;
   if (raw === undefined)
     return DEFAULT_IDLE_EXIT_MS;
   const n = Number(raw);
@@ -2121,8 +2834,8 @@ async function startPtyHostServer(options = {}) {
   const pipeSocket = isWindowsPipePath(socketPath);
   await ensureOwnerOnlyStateDir(resolveDaemonHomeDir());
   if (!pipeSocket)
-    await mkdir3(dirname5(socketPath), { recursive: true });
-  await mkdir3(dirname5(pidPath), { recursive: true });
+    await mkdir4(dirname7(socketPath), { recursive: true });
+  await mkdir4(dirname7(pidPath), { recursive: true });
   const server = createServer((socket) => {
     const client = {
       socket,
@@ -2161,10 +2874,10 @@ async function startPtyHostServer(options = {}) {
         clearFrozenSessions(freezeDir);
       for (const client of Array.from(clients))
         client.socket.destroy();
-      await new Promise((resolve) => server.close(() => resolve()));
+      await new Promise((resolve2) => server.close(() => resolve2()));
       if (!pipeSocket)
-        await unlink2(socketPath).catch(() => {});
-      await unlink2(pidPath).catch(() => {});
+        await unlink(socketPath).catch(() => {});
+      await unlink(pidPath).catch(() => {});
     }
   };
   async function stop() {
@@ -2216,11 +2929,6 @@ async function startPtyHostServer(options = {}) {
   await listenOnUnixSocket(server, socketPath);
   await writeTextAtomic(pidPath, `${process.pid}
 `);
-  if (!pipeSocket) {
-    const home = resolveDaemonHomeDir();
-    await linkLegacyRuntimePath(socketPath, legacyPtyHostSocketPath(home));
-    await linkLegacyRuntimePath(pidPath, legacyPtyHostPidPath(home));
-  }
   armIdle();
   log("boot", `pty host listening on ${socketPath}`);
   return api;
@@ -2229,15 +2937,18 @@ function writeFrame(client, frame) {
   client.writer.write(frameToLine(frame));
 }
 
-// ../kobe-daemon/src/daemon/pty-host-node-entry.ts
+// ../rove-daemon/src/daemon/pty-host-node-entry.ts
 async function main() {
   rotateLogIfNeeded(defaultPtyHostLogPath());
   process.on("uncaughtException", (err) => console.error(formatPtyHostLine("crash", err?.stack ?? String(err))));
   process.on("unhandledRejection", (err) => console.error(formatPtyHostLine("reject", String(err))));
-  const driver = await nodePtyDriver();
+  const log = (event, message) => console.log(formatPtyHostLine(event, message));
+  const launcher = await ensurePtyJobLauncher(join9(resolveDaemonHomeDir(), ROVE_STATE_DIR_BASENAME, "bin")).catch((err) => ({ path: null, reason: String(err) }));
+  log("pty", launcher.path ? `session job launcher ${launcher.path}` : `session jobs off: ${launcher.reason}`);
+  const driver = await nodePtyDriver(undefined, undefined, launcher.path ? { launcher: launcher.path, owner: defaultDaemonSocketPath() } : undefined);
   const server = await startPtyHostServer({
     driver,
-    log: (event, message) => console.log(formatPtyHostLine(event, message)),
+    log,
     version: process.env.ROVE_PTY_HOST_VERSION,
     onStop: () => process.exit(0)
   });