@sma1lboy/kobe 0.7.15 → 0.7.16

package/dist/cli/index.js

@@ -90,7 +90,7 @@ var init_package = __esm(() => {
   package_default = {
     $schema: "https://json.schemastore.org/package.json",
     name: "@sma1lboy/kobe",
-    version: "0.7.15",
+    version: "0.7.16",
     description: "TUI orchestrator for Claude Code (codename)",
     type: "module",
     packageManager: "bun@1.3.13",
@@ -167,6 +167,10 @@ function kobeStateDir() {
 function kvStatePath() {
   return join(homeDir(), ".config", "kobe", "state.json");
 }
+function remoteControlSocketPath(host, user, port) {
+  const hash = createHash("sha1").update(`${user}@${host}:${port ?? 22}`).digest("hex").slice(0, 16);
+  return join(kobeStateDir(), "ssh", `${hash}.sock`);
+}
 function worktreeInitMarkerPath(worktreePath) {
   const hash = createHash("sha1").update(worktreePath).digest("hex").slice(0, 16);
   return join(kobeStateDir(), "worktree-init", hash);
@@ -332,6 +336,202 @@ var init_version = __esm(() => {
   UPDATE_COMMAND = `curl -fsSL ${UPDATE_SCRIPT_URL} | sh`;
 });
 
+// src/exec/exec-host.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "fs";
+function shQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function shJoin(argv) {
+  return argv.map(shQuote).join(" ");
+}
+function remoteShellCommand(argv, cwd) {
+  const cmd = shJoin(argv);
+  return cwd ? `cd ${shQuote(cwd)} && ${cmd}` : cmd;
+}
+function sshConnectArgs(spec, opts = {}) {
+  const argv = ["ssh"];
+  if (opts.tty)
+    argv.push("-tt");
+  if (opts.batch)
+    argv.push("-o", "BatchMode=yes");
+  argv.push("-o", "ControlMaster=auto", "-o", `ControlPath=${spec.controlPath}`, "-o", "ControlPersist=300");
+  argv.push("-o", "StrictHostKeyChecking=accept-new");
+  if (spec.port)
+    argv.push("-p", String(spec.port));
+  if (spec.auth.kind === "key" && spec.auth.keyPath)
+    argv.push("-i", spec.auth.keyPath);
+  argv.push(`${spec.user}@${spec.host}`);
+  return argv;
+}
+
+class LocalExecHost {
+  isRemote = false;
+  run(argv, opts = {}) {
+    const [cmd, ...rest] = argv;
+    const proc = spawnSync(cmd ?? "", rest, {
+      cwd: opts.cwd,
+      env: opts.env ? { ...process.env, ...opts.env } : process.env,
+      encoding: "utf8",
+      shell: false
+    });
+    return toResult(proc);
+  }
+  async runAsync(argv, opts = {}) {
+    return this.run(argv, opts);
+  }
+  exists(path) {
+    return existsSync(path);
+  }
+  mkdirp(path) {
+    mkdirSync(path, { recursive: true });
+  }
+  readFile(path) {
+    try {
+      return readFileSync(path, "utf8");
+    } catch {
+      return null;
+    }
+  }
+  readdir(path) {
+    try {
+      return readdirSync(path);
+    } catch {
+      return [];
+    }
+  }
+  wrapCommand(command) {
+    return command;
+  }
+  ensureReady() {}
+}
+
+class RemoteExecHost {
+  spec;
+  spawn;
+  isRemote = true;
+  masterUp = false;
+  constructor(spec, spawn = defaultSpawner) {
+    this.spec = spec;
+    this.spawn = spawn;
+  }
+  ensureReady() {
+    if (this.masterUp)
+      return;
+    const check = this.spawn([...sshConnectArgs(this.spec, { batch: true }), "-O", "check"]);
+    if (check.exitCode === 0) {
+      this.masterUp = true;
+      return;
+    }
+    const base = [...sshConnectArgs(this.spec, { batch: this.spec.auth.kind !== "password" }), "-fN"];
+    if (this.spec.auth.kind === "password") {
+      const pw = this.spec.auth.getPassword();
+      if (pw != null) {
+        this.spawn(["sshpass", "-e", ...base], { SSHPASS: pw });
+        this.masterUp = true;
+        return;
+      }
+    }
+    this.spawn(base);
+    this.masterUp = true;
+  }
+  run(argv, opts = {}) {
+    this.ensureReady();
+    return this.spawn([...sshConnectArgs(this.spec, { batch: true }), remoteShellCommand(argv, opts.cwd)]);
+  }
+  async runAsync(argv, opts = {}) {
+    return this.run(argv, opts);
+  }
+  exists(path) {
+    return this.run(["test", "-e", path]).exitCode === 0;
+  }
+  mkdirp(path) {
+    this.run(["mkdir", "-p", path]);
+  }
+  readFile(path) {
+    const r = this.run(["cat", path]);
+    return r.exitCode === 0 ? r.stdout : null;
+  }
+  readdir(path) {
+    const r = this.run(["ls", "-1A", path]);
+    if (r.exitCode !== 0)
+      return [];
+    return r.stdout.split(`
+`).filter((s) => s.length > 0);
+  }
+  wrapCommand(command, opts = {}) {
+    const remote = opts.cwd ? `cd ${shQuote(opts.cwd)} && ${command}` : command;
+    return `${sshConnectArgs(this.spec, { tty: opts.tty }).join(" ")} ${shQuote(remote)}`;
+  }
+}
+function toResult(proc) {
+  return { stdout: proc.stdout ?? "", stderr: proc.stderr ?? "", exitCode: proc.status ?? -1 };
+}
+var defaultSpawner = (argv, env) => {
+  const [cmd, ...rest] = argv;
+  return toResult(spawnSync(cmd ?? "", rest, {
+    env: env ? { ...process.env, ...env } : process.env,
+    encoding: "utf8",
+    shell: false
+  }));
+};
+var init_exec_host = () => {};
+
+// src/exec/keychain.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { platform } from "os";
+function remoteKeychainRef(host, user, port) {
+  return { service: KOBE_KEYCHAIN_SERVICE, account: port ? `${user}@${host}:${port}` : `${user}@${host}` };
+}
+function isKeychainSupported(deps = defaultDeps) {
+  return deps.platform() === "darwin";
+}
+function setKeychainPassword(ref, password, deps = defaultDeps) {
+  if (deps.platform() !== "darwin")
+    return false;
+  const { exitCode } = deps.run([
+    "security",
+    "add-generic-password",
+    "-U",
+    "-s",
+    ref.service,
+    "-a",
+    ref.account,
+    "-w",
+    password
+  ]);
+  return exitCode === 0;
+}
+function getKeychainPassword(ref, deps = defaultDeps) {
+  if (deps.platform() !== "darwin")
+    return null;
+  const { stdout, exitCode } = deps.run([
+    "security",
+    "find-generic-password",
+    "-s",
+    ref.service,
+    "-a",
+    ref.account,
+    "-w"
+  ]);
+  if (exitCode !== 0)
+    return null;
+  return stdout.replace(/\n$/, "");
+}
+var defaultDeps, KOBE_KEYCHAIN_SERVICE = "kobe-remote-ssh";
+var init_keychain = __esm(() => {
+  defaultDeps = {
+    run(argv) {
+      const [cmd, ...rest] = argv;
+      const proc = spawnSync2(cmd ?? "", rest, { encoding: "utf8", shell: false });
+      return { stdout: proc.stdout ?? "", exitCode: proc.status ?? -1 };
+    },
+    platform() {
+      return platform();
+    }
+  };
+});
+
 // src/state/repos.ts
 var exports_repos = {};
 __export(exports_repos, {
@@ -340,18 +540,26 @@ __export(exports_repos, {
   setPersistedString: () => setPersistedString,
   resolveRepoRoot: () => resolveRepoRoot,
   removeSavedRepo: () => removeSavedRepo,
+  remoteRepoKey: () => remoteRepoKey,
   normalizeSavedRepos: () => normalizeSavedRepos,
+  isRemoteRepoKey: () => isRemoteRepoKey,
+  isRemoteProjectsEnabled: () => isRemoteProjectsEnabled,
   getSavedRepos: () => getSavedRepos,
   getRepoInitOverride: () => getRepoInitOverride,
+  getRemoteRepos: () => getRemoteRepos,
+  getRemoteRepoConfig: () => getRemoteRepoConfig,
   getPersistedString: () => getPersistedString,
   getCustomEngineIds: () => getCustomEngineIds,
-  addSavedRepo: () => addSavedRepo
+  addSavedRepo: () => addSavedRepo,
+  addRemoteRepo: () => addRemoteRepo
 });
-import { spawnSync } from "child_process";
-import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync, renameSync, writeFileSync } from "fs";
 import { dirname } from "path";
 function resolveRepoRoot(absPath) {
-  const r = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+  if (isRemoteRepoKey(absPath))
+    return absPath;
+  const r = spawnSync3("git", ["rev-parse", "--show-toplevel"], {
     cwd: absPath,
     encoding: "utf8",
     shell: false
@@ -372,7 +580,7 @@ function statePath() {
 }
 function load() {
   try {
-    const text = readFileSync(statePath(), "utf8");
+    const text = readFileSync2(statePath(), "utf8");
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -382,7 +590,7 @@ function load() {
 }
 function save(state) {
   const path = statePath();
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync2(dirname(path), { recursive: true });
   const tmp = `${path}.tmp`;
   writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
   renameSync(tmp, path);
@@ -491,10 +699,197 @@ function removeSavedRepo(absPath) {
   save(state);
   return { removed: true, path: absPath, total: cur.length - 1 };
 }
+function isRemoteRepoKey(key) {
+  return key.startsWith("ssh://");
+}
+function isRemoteProjectsEnabled() {
+  return load()["experimental.remoteProjects"] === true;
+}
+function remoteRepoKey(host, user, port) {
+  return port ? `ssh://${user}@${host}:${port}` : `ssh://${user}@${host}`;
+}
+function readRemoteRepos(state) {
+  const raw = state.remoteRepos;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return {};
+  return raw;
+}
+function getRemoteRepoConfig(key) {
+  return readRemoteRepos(load())[key] ?? null;
+}
+function getRemoteRepos() {
+  return readRemoteRepos(load());
+}
+function addRemoteRepo(config) {
+  const key = remoteRepoKey(config.host, config.user, config.port);
+  const state = load();
+  const repos = { ...readRemoteRepos(state) };
+  repos[key] = config;
+  state.remoteRepos = repos;
+  const saved = getSavedRepos();
+  const added = !saved.includes(key);
+  if (added)
+    state.savedRepos = [...saved, key];
+  save(state);
+  return { key, added };
+}
 var init_repos = __esm(() => {
   init_env();
 });
 
+// src/cli/add-remote.ts
+var exports_add_remote = {};
+__export(exports_add_remote, {
+  runAddRemote: () => runAddRemote,
+  parseRemoteFlags: () => parseRemoteFlags
+});
+import { createInterface } from "readline";
+function parseRemoteFlags(args) {
+  const f = {};
+  for (let i = 0;i < args.length; i++) {
+    const a = args[i];
+    switch (a) {
+      case "--host":
+        f.host = args[++i];
+        break;
+      case "--user":
+        f.user = args[++i];
+        break;
+      case "--path":
+        f.path = args[++i];
+        break;
+      case "--port": {
+        const n = Number(args[++i]);
+        if (!Number.isInteger(n) || n <= 0)
+          fail(`invalid --port "${args[i]}"`);
+        f.port = n;
+        break;
+      }
+      case "--key": {
+        const next = args[i + 1];
+        if (next && !next.startsWith("-")) {
+          f.key = { present: true, path: next };
+          i++;
+        } else {
+          f.key = { present: true };
+        }
+        break;
+      }
+      case "--password":
+        f.password = true;
+        break;
+      case "--help":
+      case "-h":
+        process.stdout.write(USAGE);
+        process.exit(0);
+        break;
+      default:
+        fail(`unknown flag "${a}"`);
+    }
+  }
+  return f;
+}
+function fail(msg) {
+  process.stderr.write(`kobe add --remote: ${msg}
+
+${USAGE}`);
+  process.exit(2);
+}
+async function promptHidden(prompt) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const out = process.stdout;
+  let muted = false;
+  const original = out._writeToOutput?.bind(out);
+  out._writeToOutput = (s) => {
+    if (!muted || !original)
+      process.stdout.write(s);
+  };
+  process.stdout.write(prompt);
+  muted = true;
+  return new Promise((res) => {
+    rl.question("", (answer) => {
+      muted = false;
+      if (original)
+        out._writeToOutput = original;
+      process.stdout.write(`
+`);
+      rl.close();
+      res(answer);
+    });
+  });
+}
+async function runAddRemote(args) {
+  if (!isRemoteProjectsEnabled()) {
+    fail("remote projects are experimental and disabled \u2014 enable Settings \u2192 Dev \u2192 Experimental \u2192 Remote projects first");
+  }
+  const f = parseRemoteFlags(args);
+  if (!f.host)
+    fail("--host is required");
+  if (!f.user)
+    fail("--user is required");
+  if (!f.path)
+    fail("--path (remote base path) is required");
+  if (f.key && f.password)
+    fail("choose ONE of --key or --password, not both");
+  if (!f.key && !f.password)
+    fail("an auth method is required: --key [path] or --password");
+  let auth;
+  if (f.password) {
+    if (!isKeychainSupported())
+      fail("--password needs the macOS keychain (unsupported on this platform)");
+    const ref = remoteKeychainRef(f.host, f.user, f.port);
+    const pw = await promptHidden(`Password for ${f.user}@${f.host}: `);
+    if (pw.length === 0)
+      fail("empty password");
+    if (!setKeychainPassword(ref, pw))
+      fail("failed to store the password in the keychain");
+    auth = { kind: "password", keychainRef: ref };
+  } else {
+    auth = { kind: "key", keyPath: f.key?.path };
+  }
+  const { key, added } = addRemoteRepo({ host: f.host, user: f.user, port: f.port, basePath: f.path, auth });
+  console.log(added ? `added remote project ${key} (base ${f.path})` : `updated remote project ${key} (base ${f.path})`);
+  await probe(f, auth);
+}
+async function probe(f, auth) {
+  if (auth.kind === "password" && !isKeychainSupported())
+    return;
+  const runtimeAuth = auth.kind === "key" ? { kind: "key", keyPath: auth.keyPath } : { kind: "password", getPassword: () => getKeychainPassword(auth.keychainRef) };
+  const spec = {
+    host: f.host,
+    user: f.user,
+    port: f.port,
+    auth: runtimeAuth,
+    controlPath: remoteControlSocketPath(f.host, f.user, f.port)
+  };
+  process.stdout.write("checking connection\u2026 ");
+  try {
+    const host = new RemoteExecHost(spec);
+    const r = host.run(["test", "-d", f.path]);
+    if (r.exitCode === 0)
+      console.log("ok");
+    else
+      console.log(`reachable, but base path "${f.path}" is not a directory (you can create it later)`);
+  } catch (err) {
+    console.log(`could not connect (${err instanceof Error ? err.message : String(err)})`);
+    console.log("the project is saved; fix the host/credentials and it will connect on first use.");
+  }
+}
+var USAGE;
+var init_add_remote = __esm(() => {
+  init_env();
+  init_exec_host();
+  init_keychain();
+  init_repos();
+  USAGE = `Usage: kobe add --remote --host <host> --user <user> --path <basePath>
+` + `                [--port N] [--key [path] | --password]
+
+` + `Register an SSH-backed project. Worktrees + the engine run on <host> under
+` + `<basePath>. Choose ONE auth: --key [path] (ssh-agent when path omitted) or
+` + `--password (prompted, stored in the OS keychain \u2014 never in state.json).
+`;
+});
+
 // src/types/task.ts
 var toTaskId = (id) => id, DEFAULT_TASK_VENDOR = "claude";
 
@@ -866,28 +1261,40 @@ var init_store = __esm(() => {
   init_ulid();
 });
 
-// src/orchestrator/worktree/git.ts
-import { spawnSync as spawnSync2 } from "child_process";
-function git(args, opts) {
-  if (!opts.cwd) {
-    throw new Error("git(): cwd is required; refusing to inherit from process.cwd()");
-  }
-  const proc = spawnSync2("git", [...args], {
-    cwd: opts.cwd,
-    env: opts.env ? { ...process.env, ...opts.env } : process.env,
-    encoding: "utf8",
-    shell: false
-  });
-  const result = {
-    stdout: proc.stdout ?? "",
-    stderr: proc.stderr ?? "",
-    exitCode: proc.status ?? -1
+// src/exec/resolve.ts
+function remoteSpecFromConfig(config) {
+  const cfgAuth = config.auth;
+  const auth = cfgAuth.kind === "key" ? { kind: "key", keyPath: cfgAuth.keyPath } : { kind: "password", getPassword: () => getKeychainPassword(cfgAuth.keychainRef) };
+  return {
+    host: config.host,
+    user: config.user,
+    port: config.port,
+    auth,
+    controlPath: remoteControlSocketPath(config.host, config.user, config.port)
   };
-  if (result.exitCode !== 0 && !opts.allowFail) {
-    throw new GitCommandError(args, opts.cwd, result);
+}
+function execHostForRepo(repoKey) {
+  const config = getRemoteRepoConfig(repoKey);
+  if (!config)
+    return new LocalExecHost;
+  return new RemoteExecHost(remoteSpecFromConfig(config));
+}
+function execHostForWorktreePath(worktreePath) {
+  for (const config of Object.values(getRemoteRepos())) {
+    if (worktreePath === config.basePath || worktreePath.startsWith(`${config.basePath}/`)) {
+      return new RemoteExecHost(remoteSpecFromConfig(config));
+    }
   }
-  return result;
+  return new LocalExecHost;
 }
+var init_resolve = __esm(() => {
+  init_env();
+  init_repos();
+  init_exec_host();
+  init_keychain();
+});
+
+// src/orchestrator/worktree/git.ts
 var GitCommandError;
 var init_git = __esm(() => {
   GitCommandError = class GitCommandError extends Error {
@@ -934,6 +1341,12 @@ function worktreePathFor(repo, slug) {
   return path.join(worktreeRootFor(repo), slug);
 }
 function listWorktreeDirNames(repo) {
+  if (isRemoteRepoKey(repo)) {
+    const basePath = getRemoteRepoConfig(repo)?.basePath;
+    if (!basePath)
+      return [];
+    return execHostForRepo(repo).readdir(remoteWorktreeRootFor(basePath));
+  }
   const names = new Set;
   for (const root of managedWorktreeRootsFor(repo)) {
     try {
@@ -961,6 +1374,18 @@ function managedWorktreeRootForPath(repo, candidate) {
 function isKobeManagedPath(repo, candidate) {
   return managedWorktreeRootForPath(repo, candidate) !== null;
 }
+function remoteWorktreeRootFor(basePath) {
+  return `${stripTrailingSlash(basePath)}/.kobe/worktrees`;
+}
+function remoteWorktreePathFor(basePath, slug) {
+  if (!slug || /[/\\\0]/.test(slug)) {
+    throw new Error(`remoteWorktreePathFor: invalid slug: ${JSON.stringify(slug)}`);
+  }
+  return `${remoteWorktreeRootFor(basePath)}/${slug}`;
+}
+function stripTrailingSlash(p) {
+  return p.length > 1 && p.endsWith("/") ? p.replace(/\/+$/, "") : p;
+}
 function canonicalize(p) {
   try {
     return fs.realpathSync(p);
@@ -977,6 +1402,8 @@ function repoWorktreeDirName(repo) {
 var KOBE_WORKTREE_ROOT_DIR = "worktrees", REPO_LOCAL_KOBE_WORKTREE_ROOT_SUBPATH = ".kobe/worktrees", LEGACY_KOBE_WORKTREE_ROOT_SUBPATH = ".claude/worktrees", REPO_LOCAL_KOBE_MANAGED_WORKTREE_ROOT_SUBPATHS;
 var init_paths = __esm(() => {
   init_env();
+  init_resolve();
+  init_repos();
   REPO_LOCAL_KOBE_MANAGED_WORKTREE_ROOT_SUBPATHS = [
     REPO_LOCAL_KOBE_WORKTREE_ROOT_SUBPATH,
     LEGACY_KOBE_WORKTREE_ROOT_SUBPATH
@@ -992,13 +1419,33 @@ import fs2 from "fs";
 import path2 from "path";
 
 class GitWorktreeManager {
+  execDeps;
+  constructor(execDeps = defaultExecDeps) {
+    this.execDeps = execDeps;
+  }
+  ctxFor(repoKey) {
+    const basePath = this.execDeps.remoteBasePath(repoKey);
+    return basePath ? { exec: this.execDeps.execForRepo(repoKey), dir: basePath, remote: true } : { exec: this.execDeps.execForRepo(repoKey), dir: repoKey, remote: false };
+  }
+  runGit(exec, args, opts) {
+    if (!opts.cwd) {
+      throw new Error("runGit(): cwd is required; refusing to inherit from process.cwd()");
+    }
+    const r = exec.run(["git", ...args], { cwd: opts.cwd, env: opts.env });
+    const result = { stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode };
+    if (result.exitCode !== 0 && !opts.allowFail) {
+      throw new GitCommandError(args, opts.cwd, result);
+    }
+    return result;
+  }
   async create(repo, branch, worktreePath, baseRef) {
-    requireAbsolute("repo", repo);
+    const ctx = this.ctxFor(repo);
+    requireAbsolute("repo", ctx.dir);
     requireAbsolute("path", worktreePath);
     if (!branch)
       throw new Error("create(): branch must be a non-empty string");
-    if (fs2.existsSync(worktreePath)) {
-      const existing = await this.tryDescribe(repo, worktreePath);
+    if (ctx.exec.exists(worktreePath)) {
+      const existing = await this.tryDescribe(ctx, worktreePath);
       if (existing) {
         if (existing.branch !== branch) {
           throw new Error(`worktree at ${worktreePath} is on branch '${existing.branch}', refusing to hijack to '${branch}'`);
@@ -1007,11 +1454,11 @@ class GitWorktreeManager {
       }
       throw new Error(`create(): ${worktreePath} exists but is not a registered git worktree`);
     }
-    fs2.mkdirSync(path2.dirname(worktreePath), { recursive: true });
-    const branchExists = this.branchExists(repo, branch);
+    ctx.exec.mkdirp(path2.dirname(worktreePath));
+    const branchExists = this.branchExists(ctx, branch);
     const args = branchExists ? ["worktree", "add", worktreePath, branch] : baseRef ? ["worktree", "add", "-b", branch, worktreePath, baseRef] : ["worktree", "add", "-b", branch, worktreePath];
-    git(args, { cwd: repo });
-    const info = await this.tryDescribe(repo, worktreePath);
+    this.runGit(ctx.exec, args, { cwd: ctx.dir });
+    const info = await this.tryDescribe(ctx, worktreePath);
     if (!info) {
       throw new Error(`create(): git reported success but ${worktreePath} is not a worktree`);
     }
@@ -1021,19 +1468,21 @@ class GitWorktreeManager {
     return info;
   }
   async createForTask(args) {
-    const target = worktreePathFor(args.repo, args.slug);
+    const basePath = this.execDeps.remoteBasePath(args.repo);
+    const target = basePath ? remoteWorktreePathFor(basePath, args.slug) : worktreePathFor(args.repo, args.slug);
     return this.create(args.repo, args.branch, target, args.baseRef);
   }
   async remove(worktreePath, opts) {
     requireAbsolute("path", worktreePath);
+    const exec = this.execDeps.execForPath(worktreePath);
     const force = opts?.force === true;
-    if (!fs2.existsSync(worktreePath)) {
-      const repo2 = this.findRepoFor(worktreePath);
+    if (!exec.exists(worktreePath)) {
+      const repo2 = this.findRepoFor(exec, worktreePath);
       if (repo2)
-        git(["worktree", "prune"], { cwd: repo2, allowFail: true });
+        this.runGit(exec, ["worktree", "prune"], { cwd: repo2, allowFail: true });
       return;
     }
-    const repo = this.findRepoFor(worktreePath);
+    const repo = this.findRepoFor(exec, worktreePath);
     if (!repo) {
       throw new Error(`remove(): ${worktreePath} is not a git worktree`);
     }
@@ -1044,18 +1493,19 @@ class GitWorktreeManager {
       }
     }
     const args = force ? ["worktree", "remove", "--force", worktreePath] : ["worktree", "remove", worktreePath];
-    git(args, { cwd: repo });
-    git(["worktree", "prune"], { cwd: repo, allowFail: true });
+    this.runGit(exec, args, { cwd: repo });
+    this.runGit(exec, ["worktree", "prune"], { cwd: repo, allowFail: true });
   }
   async list(repo) {
-    requireAbsolute("repo", repo);
-    const out = git(["worktree", "list", "--porcelain"], { cwd: repo });
+    const ctx = this.ctxFor(repo);
+    requireAbsolute("repo", ctx.dir);
+    const out = this.runGit(ctx.exec, ["worktree", "list", "--porcelain"], { cwd: ctx.dir });
     const all = parsePorcelain(out.stdout);
     const infos = [];
     for (const entry of all) {
       if (!entry.path)
         continue;
-      const callerRoot = managedWorktreeRootForPath(repo, entry.path);
+      const callerRoot = ctx.remote ? remoteManagedRootForPath(ctx.dir, entry.path) : managedWorktreeRootForPath(repo, entry.path);
       if (!callerRoot)
         continue;
       if (!entry.branch || entry.detached)
@@ -1075,10 +1525,11 @@ class GitWorktreeManager {
     return infos;
   }
   async listAll(repo) {
-    requireAbsolute("repo", repo);
-    const out = git(["worktree", "list", "--porcelain"], { cwd: repo });
+    const ctx = this.ctxFor(repo);
+    requireAbsolute("repo", ctx.dir);
+    const out = this.runGit(ctx.exec, ["worktree", "list", "--porcelain"], { cwd: ctx.dir });
     const all = parsePorcelain(out.stdout);
-    const canonRepo = canonicalize2(repo);
+    const canonRepo = ctx.remote ? ctx.dir : canonicalize2(ctx.dir);
     const infos = [];
     for (const entry of all) {
       if (!entry.path)
@@ -1087,7 +1538,7 @@ class GitWorktreeManager {
         continue;
       if (!entry.branch || entry.detached)
         continue;
-      if (canonicalize2(entry.path) === canonRepo)
+      if ((ctx.remote ? entry.path : canonicalize2(entry.path)) === canonRepo)
         continue;
       const dirty = await this.isDirty(entry.path);
       infos.push({
@@ -1095,34 +1546,37 @@ class GitWorktreeManager {
         branch: entry.branch,
         head: entry.head ?? "",
         dirty,
-        kobeManaged: isKobeManagedPath(repo, entry.path),
-        lastActivityMs: this.lastActivityMs(entry.path)
+        kobeManaged: ctx.remote ? remoteManagedRootForPath(ctx.dir, entry.path) !== null : isKobeManagedPath(repo, entry.path),
+        lastActivityMs: this.lastActivityMs(ctx.exec, entry.path)
       });
     }
     infos.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
     return infos;
   }
-  lastActivityMs(worktreePath) {
+  lastActivityMs(exec, worktreePath) {
     try {
-      const out = git(["log", "-1", "--format=%ct"], { cwd: worktreePath });
+      const out = this.runGit(exec, ["log", "-1", "--format=%ct"], { cwd: worktreePath });
       const secs = Number.parseInt(out.stdout.trim(), 10);
       if (Number.isFinite(secs) && secs > 0)
         return secs * 1000;
     } catch {}
-    try {
-      return fs2.statSync(worktreePath).mtimeMs;
-    } catch {
-      return 0;
+    if (!exec.isRemote) {
+      try {
+        return fs2.statSync(worktreePath).mtimeMs;
+      } catch {}
     }
+    return 0;
   }
   async isDirty(worktreePath) {
     requireAbsolute("path", worktreePath);
-    const out = git(["status", "--porcelain"], { cwd: worktreePath });
+    const exec = this.execDeps.execForPath(worktreePath);
+    const out = this.runGit(exec, ["status", "--porcelain"], { cwd: worktreePath });
     return out.stdout.length > 0;
   }
   async currentBranch(worktreePath) {
     requireAbsolute("path", worktreePath);
-    const out = git(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: worktreePath });
+    const exec = this.execDeps.execForPath(worktreePath);
+    const out = this.runGit(exec, ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: worktreePath });
     const name = out.stdout.trim();
     if (!name || name === "HEAD") {
       throw new Error(`currentBranch(): ${worktreePath} is in detached-HEAD state`);
@@ -1133,16 +1587,18 @@ class GitWorktreeManager {
     requireAbsolute("path", worktreePath);
     if (from === to)
       return;
-    const repo = this.findRepoFor(worktreePath);
+    const exec = this.execDeps.execForPath(worktreePath);
+    const repo = this.findRepoFor(exec, worktreePath);
     if (!repo)
       throw new Error(`renameBranch(): ${worktreePath} is not a git worktree`);
-    git(["branch", "-m", from, to], { cwd: repo });
+    this.runGit(exec, ["branch", "-m", from, to], { cwd: repo });
   }
-  async tryDescribe(repo, worktreePath) {
-    const out = git(["worktree", "list", "--porcelain"], { cwd: repo });
+  async tryDescribe(ctx, worktreePath) {
+    const out = this.runGit(ctx.exec, ["worktree", "list", "--porcelain"], { cwd: ctx.dir });
     const entries = parsePorcelain(out.stdout);
-    const target = canonicalize2(worktreePath);
-    const match = entries.find((e) => e.path && canonicalize2(e.path) === target);
+    const norm = (p) => ctx.remote ? p : canonicalize2(p);
+    const target = norm(worktreePath);
+    const match = entries.find((e) => e.path && norm(e.path) === target);
     if (!match || !match.path || !match.branch || match.detached)
       return null;
     return {
@@ -1152,14 +1608,14 @@ class GitWorktreeManager {
       dirty: await this.isDirty(match.path)
     };
   }
-  branchExists(repo, branch) {
+  branchExists(ctx, branch) {
     const ref = `refs/heads/${branch}`;
-    const out = git(["show-ref", "--verify", "--quiet", ref], { cwd: repo, allowFail: true });
+    const out = this.runGit(ctx.exec, ["show-ref", "--verify", "--quiet", ref], { cwd: ctx.dir, allowFail: true });
     return out.exitCode === 0;
   }
-  findRepoFor(worktreePath) {
+  findRepoFor(exec, worktreePath) {
     try {
-      const out = git(["rev-parse", "--git-common-dir"], { cwd: worktreePath, allowFail: true });
+      const out = this.runGit(exec, ["rev-parse", "--git-common-dir"], { cwd: worktreePath, allowFail: true });
       if (out.exitCode !== 0)
         return null;
       const gitDir = out.stdout.trim();
@@ -1206,6 +1662,10 @@ function parsePorcelain(out) {
     records.push(current);
   return records;
 }
+function remoteManagedRootForPath(basePath, candidate) {
+  const root = `${basePath.replace(/\/+$/, "")}/.kobe/worktrees`;
+  return candidate === root || candidate.startsWith(`${root}/`) ? root : null;
+}
 function requireAbsolute(name, value) {
   if (!value || !path2.isAbsolute(value)) {
     throw new Error(`${name} must be an absolute path, got: ${JSON.stringify(value)}`);
@@ -1218,9 +1678,19 @@ function canonicalize2(p) {
     return path2.resolve(p);
   }
 }
+var defaultExecDeps;
 var init_manager = __esm(() => {
+  init_resolve();
+  init_repos();
   init_git();
   init_paths();
+  defaultExecDeps = {
+    execForRepo: execHostForRepo,
+    execForPath: execHostForWorktreePath,
+    remoteBasePath(repoKey) {
+      return getRemoteRepoConfig(repoKey)?.basePath ?? null;
+    }
+  };
 });
 
 // ../../node_modules/.bun/solid-js@1.9.12/node_modules/solid-js/dist/dev.js
@@ -2992,6 +3462,9 @@ __export(exports_core, {
 });
 import { realpathSync as realpathSync2 } from "fs";
 import { basename as basename2, resolve } from "path";
+function repoWorkingDir(repo) {
+  return getRemoteRepoConfig(repo)?.basePath ?? repo;
+}
 
 class Orchestrator {
   store;
@@ -3081,7 +3554,7 @@ class Orchestrator {
         repo,
         title: titleFromRepo(repo),
         branch: "",
-        worktreePath: repo,
+        worktreePath: repoWorkingDir(repo),
         status: "backlog",
         kind: "main",
         vendor: DEFAULT_TASK_VENDOR
@@ -3098,7 +3571,7 @@ class Orchestrator {
   async ensureWorktree(id) {
     const task = this.requireTask(id);
     if (task.kind === "main")
-      return task.repo;
+      return repoWorkingDir(task.repo);
     if (task.worktreePath)
       return task.worktreePath;
     const inflight = this.worktreeLocks.get(task.id);
@@ -3315,6 +3788,7 @@ function canonPath(p) {
 var PLACEHOLDER_TASK_TITLE = "(new task)";
 var init_core = __esm(() => {
   init_dev();
+  init_repos();
   init_errors();
   init_slug_allocator();
 });
@@ -3839,7 +4313,7 @@ async function latestTranscriptMtimeForWorktree(worktree) {
   const files = await listSessionFilesForWorktree(worktree);
   return files[0]?.mtimeMs ?? 0;
 }
-async function readHistory(sessionId, deps = defaultDeps) {
+async function readHistory(sessionId, deps = defaultDeps2) {
   const root = deps.projectsDir();
   const projectDirs = await deps.readdir(root);
   for (const dir of projectDirs) {
@@ -3916,9 +4390,9 @@ function extractUsage(v) {
 function isObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var defaultDeps;
+var defaultDeps2;
 var init_history = __esm(() => {
-  defaultDeps = {
+  defaultDeps2 = {
     projectsDir() {
       return path3.join(homedir4(), ".claude", "projects");
     },
@@ -4024,7 +4498,7 @@ function validPositive(v) {
 import { readFile as readFile3, readdir as readdir2, stat as stat2, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir5 } from "os";
 import path4 from "path";
-async function listRolloutFiles(deps = defaultDeps2) {
+async function listRolloutFiles(deps = defaultDeps3) {
   const root = deps.sessionsDir();
   const years = (await deps.readdir(root)).sort().reverse();
   const out = [];
@@ -4045,7 +4519,7 @@ async function listRolloutFiles(deps = defaultDeps2) {
   }
   return out;
 }
-async function findRolloutFile(sessionId, deps = defaultDeps2) {
+async function findRolloutFile(sessionId, deps = defaultDeps3) {
   const all = await listRolloutFiles(deps);
   for (const p of all) {
     if (path4.basename(p).endsWith(`-${sessionId}.jsonl`))
@@ -4068,7 +4542,7 @@ function rolloutCwd(raw) {
   }
   return "";
 }
-async function listSessionIdsForWorktree(worktree, deps = defaultDeps2) {
+async function listSessionIdsForWorktree(worktree, deps = defaultDeps3) {
   if (!worktree)
     return [];
   const files = await listRolloutFiles(deps);
@@ -4092,7 +4566,7 @@ async function listSessionIdsForWorktree(worktree, deps = defaultDeps2) {
   }
   return matches.reverse();
 }
-async function latestTranscriptMtimeForWorktree2(worktree, deps = defaultDeps2) {
+async function latestTranscriptMtimeForWorktree2(worktree, deps = defaultDeps3) {
   if (!worktree)
     return 0;
   const files = await listRolloutFiles(deps);
@@ -4117,10 +4591,10 @@ async function latestTranscriptMtimeForWorktree2(worktree, deps = defaultDeps2)
   }
   return 0;
 }
-async function readHistory2(sessionId, deps = defaultDeps2) {
+async function readHistory2(sessionId, deps = defaultDeps3) {
   return (await readHistoryWithMetrics(sessionId, deps)).messages;
 }
-async function readHistoryWithMetrics(sessionId, deps = defaultDeps2) {
+async function readHistoryWithMetrics(sessionId, deps = defaultDeps3) {
   const file = await findRolloutFile(sessionId, deps);
   if (!file)
     return { messages: [] };
@@ -4348,10 +4822,10 @@ function parseTimestampMs(value) {
 function isObject3(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var defaultDeps2, UUID_AT_END, MAX_WORKTREE_SCAN = 200, MAX_MTIME_SCAN = 12;
+var defaultDeps3, UUID_AT_END, MAX_WORKTREE_SCAN = 200, MAX_MTIME_SCAN = 12;
 var init_history2 = __esm(() => {
   init_synthetic();
-  defaultDeps2 = {
+  defaultDeps3 = {
     sessionsDir() {
       return path4.join(homedir5(), ".codex", "sessions");
     },
@@ -4408,12 +4882,12 @@ function numberOr2(value, fallback) {
 import { readFile as readFile4, readdir as readdir3, rm, stat as stat3 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import path5 from "path";
-async function listSessionDirs(deps = defaultDeps3) {
+async function listSessionDirs(deps = defaultDeps4) {
   const root = path5.join(deps.copilotDir(), "session-state");
   const names = await deps.readdir(root);
   return names.map((name) => path5.join(root, name));
 }
-async function listSessionIdsForWorktree2(worktree, deps = defaultDeps3) {
+async function listSessionIdsForWorktree2(worktree, deps = defaultDeps4) {
   const matches = [];
   for (const dir of await listSessionDirs(deps)) {
     const workspace = await readWorkspace(dir, deps);
@@ -4423,7 +4897,7 @@ async function listSessionIdsForWorktree2(worktree, deps = defaultDeps3) {
   }
   return matches.sort((a, b) => a.updatedAt.localeCompare(b.updatedAt)).map((m) => m.id);
 }
-async function latestTranscriptMtimeForWorktree3(worktree, deps = defaultDeps3) {
+async function latestTranscriptMtimeForWorktree3(worktree, deps = defaultDeps4) {
   if (!worktree)
     return 0;
   let newest = 0;
@@ -4439,7 +4913,7 @@ async function latestTranscriptMtimeForWorktree3(worktree, deps = defaultDeps3)
   }
   return newest;
 }
-async function readHistoryWithMetrics2(sessionId, deps = defaultDeps3) {
+async function readHistoryWithMetrics2(sessionId, deps = defaultDeps4) {
   const dir = await findSessionDir(sessionId, deps);
   if (!dir)
     return { messages: [] };
@@ -4447,10 +4921,10 @@ async function readHistoryWithMetrics2(sessionId, deps = defaultDeps3) {
   const parsed = parseEvents(raw, sessionId);
   return { messages: parsed.messages, ...parsed.usageMetrics ? { usageMetrics: parsed.usageMetrics } : {} };
 }
-async function readHistory3(sessionId, deps = defaultDeps3) {
+async function readHistory3(sessionId, deps = defaultDeps4) {
   return (await readHistoryWithMetrics2(sessionId, deps)).messages;
 }
-async function findSessionDir(sessionId, deps = defaultDeps3) {
+async function findSessionDir(sessionId, deps = defaultDeps4) {
   for (const dir of await listSessionDirs(deps)) {
     if (path5.basename(dir) === sessionId)
       return dir;
@@ -4460,7 +4934,7 @@ async function findSessionDir(sessionId, deps = defaultDeps3) {
   }
   return;
 }
-async function readWorkspace(dir, deps = defaultDeps3) {
+async function readWorkspace(dir, deps = defaultDeps4) {
   const raw = await deps.readFile(path5.join(dir, "workspace.yaml")).catch(() => "");
   return parseWorkspaceYaml(raw);
 }
@@ -4568,9 +5042,9 @@ function parseEvents(raw, fallbackSessionId) {
 function isObject5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-var defaultDeps3, PREVIEW_CHAR_CAP = 200;
+var defaultDeps4, PREVIEW_CHAR_CAP = 200;
 var init_history3 = __esm(() => {
-  defaultDeps3 = {
+  defaultDeps4 = {
     copilotDir() {
       const override = process.env.COPILOT_HOME?.trim();
       if (override)
@@ -4674,12 +5148,12 @@ function keepAlive(cmd) {
   const banner = "\\n  \u26A0 Engine exited (code %s). Check Settings \u2192 Engines, fix the launch command, then press R to relaunch.\\n\\n";
   return `${cmd}; __rc=$?; [ "$__rc" -ne 0 ] && printf '${banner}' "$__rc"; exec "\${SHELL:-/bin/sh}"`;
 }
-function shQuote(s) {
+function shQuote2(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
 function homeWelcomeCommand() {
   const msg = "\\n  No task selected\\n\\n  Press N to create a task, or pick one on the left.\\n\\n";
-  return `clear; printf ${shQuote(msg)}; exec "\${SHELL:-/bin/sh}"`;
+  return `clear; printf ${shQuote2(msg)}; exec "\${SHELL:-/bin/sh}"`;
 }
 function engineLaunchLine(engineCmd, init) {
   const tail = keepAlive(engineCmd);
@@ -4689,8 +5163,8 @@ function engineLaunchLine(engineCmd, init) {
   const group = ["{", script, "}"].join(`
 `);
   if (init?.markerPath) {
-    const marker = shQuote(init.markerPath);
-    const markerDir = shQuote(markerDirOf(init.markerPath));
+    const marker = shQuote2(init.markerPath);
+    const markerDir = shQuote2(markerDirOf(init.markerPath));
     return [
       `if [ ! -f ${marker} ]; then`,
       group,
@@ -5376,17 +5850,17 @@ var exports_repo_init = {};
 __export(exports_repo_init, {
   resolveRepoInit: () => resolveRepoInit
 });
-import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
 import { join as join4 } from "path";
 function repoFileScript(worktreePath) {
-  return existsSync(join4(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
+  return existsSync2(join4(worktreePath, INIT_SCRIPT_REL)) ? `sh ${INIT_SCRIPT_REL}` : undefined;
 }
 function repoFilePrompt(worktreePath) {
   const p = join4(worktreePath, INIT_PROMPT_REL);
-  if (!existsSync(p))
+  if (!existsSync2(p))
     return;
   try {
-    const text = readFileSync2(p, "utf8");
+    const text = readFileSync3(p, "utf8");
     return text.trim().length > 0 ? text : undefined;
   } catch {
     return;
@@ -5473,6 +5947,18 @@ __export(exports_tmux, {
   CHAT_TAB_CLOSE_BINDING: () => CHAT_TAB_CLOSE_BINDING,
   CHAT_TAB_CHOOSE_ENGINE_BINDINGS: () => CHAT_TAB_CHOOSE_ENGINE_BINDINGS
 });
+function localSpawnCwd(cwd) {
+  return execHostForWorktreePath(cwd).isRemote ? homeDir() : cwd;
+}
+function wrapEngineLaunch(engineCmd, remoteKey, remoteCwd) {
+  if (!remoteKey || !isRemoteRepoKey(remoteKey))
+    return engineCmd;
+  const host = execHostForRepo(remoteKey);
+  if (!host.isRemote)
+    return engineCmd;
+  host.ensureReady();
+  return host.wrapCommand(engineCmd, { tty: true, cwd: remoteCwd });
+}
 function tmuxInitialSizeArgs(stdout = process.stdout, env = process.env) {
   const columns = positiveInt(stdout.columns) ?? positiveInt(env.COLUMNS);
   const rows = positiveInt(stdout.rows) ?? positiveInt(env.LINES);
@@ -5508,7 +5994,7 @@ async function ensureSessionImpl(opts) {
       return true;
     }
     if (worktreeOk && !vendorOk && opts.command.length > 0) {
-      if (await relaunchEngineInAllWindows(opts.name, opts.cwd, opts.command)) {
+      if (await relaunchEngineInAllWindows(opts.name, opts.cwd, opts.command, opts.remoteKey)) {
         if (opts.vendor)
           await setSessionOption(opts.name, "@kobe_vendor", opts.vendor);
         await healTaskPaneWidths(opts.name);
@@ -5525,20 +6011,22 @@ async function ensureSessionImpl(opts) {
   }
   const inv = kobeCliInvocation();
   const launch = withClaudeSessionId(opts.command, opts.vendor);
+  const engineCmd = wrapEngineLaunch(shellQuoteArgv(launch.argv), opts.remoteKey, opts.cwd);
+  const remote = Boolean(opts.remoteKey && isRemoteRepoKey(opts.remoteKey));
   const r0 = await runTmuxCapturing([
     "new-session",
     "-d",
     "-s",
     opts.name,
     "-c",
-    opts.cwd,
+    localSpawnCwd(opts.cwd),
     ...tmuxInitialSizeArgs(),
     "-P",
     "-F",
     "#{pane_id}",
-    engineLaunchLine(shellQuoteArgv(launch.argv), {
-      initScript: opts.initScript,
-      markerPath: opts.initScript ? worktreeInitMarkerPath(opts.cwd) : undefined
+    engineLaunchLine(engineCmd, {
+      initScript: remote ? undefined : opts.initScript,
+      markerPath: !remote && opts.initScript ? worktreeInitMarkerPath(opts.cwd) : undefined
     })
   ]);
   const pane0 = r0.stdout.trim();
@@ -5551,7 +6039,8 @@ async function ensureSessionImpl(opts) {
   await runTmuxSequence([
     ...opts.taskId ? [["set-option", "-t", opts.name, "@kobe_task", opts.taskId]] : [],
     ["set-option", "-t", opts.name, "@kobe_worktree", opts.cwd],
-    ...opts.vendor ? [["set-option", "-t", opts.name, "@kobe_vendor", opts.vendor]] : []
+    ...opts.vendor ? [["set-option", "-t", opts.name, "@kobe_vendor", opts.vendor]] : [],
+    ...remote ? [["set-option", "-t", opts.name, REMOTE_KEY_OPTION, opts.remoteKey]] : []
   ]);
   await buildPanesAround(pane0, {
     cwd: opts.cwd,
@@ -5595,7 +6084,7 @@ async function ensureSessionImpl(opts) {
   }
   return true;
 }
-async function relaunchEngineInAllWindows(session, cwd, command) {
+async function relaunchEngineInAllWindows(session, cwd, command, remoteKey) {
   const { code, stdout } = await runTmuxCapturing([
     "list-panes",
     "-s",
@@ -5610,9 +6099,9 @@ async function relaunchEngineInAllWindows(session, cwd, command) {
 `).map((line) => line.split("\t")).filter(([, role]) => role?.trim() === "claude").map(([id]) => id?.trim()).filter((id) => !!id);
   if (enginePanes.length === 0)
     return false;
-  const cmd = keepAlive(shellQuoteArgv(command));
+  const cmd = keepAlive(wrapEngineLaunch(shellQuoteArgv(command), remoteKey, cwd));
   for (const pane of enginePanes) {
-    await runTmux(["respawn-pane", "-k", "-c", cwd, "-t", pane, cmd]);
+    await runTmux(["respawn-pane", "-k", "-c", localSpawnCwd(cwd), "-t", pane, cmd]);
   }
   return true;
 }
@@ -5676,7 +6165,7 @@ async function healKobePaneVersions(session, cwd, taskId, vendor) {
         "-t",
         tasksPane.paneId,
         "-c",
-        cwd,
+        localSpawnCwd(cwd),
         keepAlive(envPrefix + tasksPaneCommand(inv, { initialTaskId: taskId }))
       ], ["set-option", "-p", "-t", tasksPane.paneId, "@kobe_role", "tasks"], ["set-option", "-p", "-t", tasksPane.paneId, PANE_VERSION_OPTION, CURRENT_VERSION]);
     }
@@ -5687,7 +6176,7 @@ async function healKobePaneVersions(session, cwd, taskId, vendor) {
         "-t",
         opsPane.paneId,
         "-c",
-        cwd,
+        localSpawnCwd(cwd),
         keepAlive(envPrefix + opsPaneCommand({
           cwd,
           taskId,
@@ -5736,7 +6225,7 @@ async function refreshKobeWorkspacePanes(session) {
         "-t",
         tasksPane.paneId,
         "-c",
-        cwd,
+        localSpawnCwd(cwd),
         keepAlive(envPrefix + tasksPaneCommand(inv, { initialTaskId: taskId }))
       ], ["set-option", "-p", "-t", tasksPane.paneId, "@kobe_role", "tasks"], ["set-option", "-p", "-t", tasksPane.paneId, PANE_VERSION_OPTION, CURRENT_VERSION]);
     }
@@ -5747,7 +6236,7 @@ async function refreshKobeWorkspacePanes(session) {
         "-t",
         opsPane.paneId,
         "-c",
-        cwd,
+        localSpawnCwd(cwd),
         keepAlive(envPrefix + opsPaneCommand({
           cwd,
           taskId,
@@ -5791,7 +6280,7 @@ async function buildPanesAround(claudePane, args) {
       "-l",
       `${TASKS_PANE_WIDTH}`,
       "-c",
-      args.cwd,
+      localSpawnCwd(args.cwd),
       "-P",
       "-F",
       "tasks=#{pane_id}",
@@ -5805,13 +6294,13 @@ async function buildPanesAround(claudePane, args) {
       "-l",
       `${100 - CLAUDE_PANE_PERCENT}%`,
       "-c",
-      args.cwd,
+      localSpawnCwd(args.cwd),
       "-P",
       "-F",
       "ops=#{pane_id}",
       opsCmd
     ],
-    ["split-window", "-v", "-l", `${100 - OPS_PANE_PERCENT}%`, "-c", args.cwd],
+    ["split-window", "-v", "-l", `${100 - OPS_PANE_PERCENT}%`, "-c", localSpawnCwd(args.cwd)],
     ["select-pane", "-t", claudePane]
   ]);
   const ids = Object.fromEntries(stdout.split(`
@@ -5826,9 +6315,15 @@ async function buildPanesAround(claudePane, args) {
 async function newChatTab(session, vendorOverride) {
   if (!await sessionExists(session))
     return;
-  const sessionOptions = await getSessionOptions(session, ["@kobe_worktree", "@kobe_task", "@kobe_vendor"]);
+  const sessionOptions = await getSessionOptions(session, [
+    "@kobe_worktree",
+    "@kobe_task",
+    "@kobe_vendor",
+    REMOTE_KEY_OPTION
+  ]);
   const cwd = sessionOptions["@kobe_worktree"] || process.cwd();
   const taskId = sessionOptions["@kobe_task"] || undefined;
+  const remoteKey = sessionOptions[REMOTE_KEY_OPTION] || undefined;
   const vendor = vendorOverride ?? sessionOptions["@kobe_vendor"];
   if (vendorOverride)
     await rememberSessionVendor(session, taskId, vendorOverride);
@@ -5840,11 +6335,11 @@ async function newChatTab(session, vendorOverride) {
     "-t",
     `=${session}`,
     "-c",
-    cwd,
+    localSpawnCwd(cwd),
     "-P",
     "-F",
     "#{pane_id}",
-    keepAlive(shellQuoteArgv(launch.argv))
+    keepAlive(wrapEngineLaunch(shellQuoteArgv(launch.argv), remoteKey, cwd))
   ]);
   const claudePane = r.stdout.trim();
   if (!claudePane)
@@ -5861,7 +6356,7 @@ async function openSettingsTab(session) {
   const inv = kobeCliInvocation();
   const envPrefix = inheritedEnvPrefix();
   const command = `${envPrefix}${inv.map(shellQuote).join(" ")} settings`;
-  await newWindow(session, { cwd, command, name: "settings" });
+  await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "settings" });
 }
 async function openNewTaskTab(session, defaultRepo) {
   if (!await sessionExists(session))
@@ -5872,7 +6367,7 @@ async function openNewTaskTab(session, defaultRepo) {
   const envPrefix = inheritedEnvPrefix();
   const repoArg = defaultRepo ? ` --repo ${shellQuote(defaultRepo)}` : "";
   const command = `${envPrefix}${inv.map(shellQuote).join(" ")} new-task${repoArg}`;
-  await newWindow(session, { cwd, command, name: "new task" });
+  await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "new task" });
 }
 async function openUpdateTab(session) {
   if (!await sessionExists(session))
@@ -5882,7 +6377,7 @@ async function openUpdateTab(session) {
   const inv = kobeCliInvocation();
   const envPrefix = inheritedEnvPrefix();
   const command = `${envPrefix}${updatePageCommand({ cliInvocation: inv })}`;
-  await newWindow(session, { cwd, command, name: "update" });
+  await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "update" });
 }
 async function rememberSessionVendor(session, taskId, vendor) {
   await setSessionOption(session, "@kobe_vendor", vendor);
@@ -5917,13 +6412,15 @@ async function quickCreate(session) {
   const inv = kobeCliInvocation();
   const envPrefix = inheritedEnvPrefix();
   const command = `${envPrefix}${inv.map(shellQuote).join(" ")} quick-task --session ${shellQuote(session)}`;
-  await newWindow(session, { cwd, command, name: "quick task" });
+  await newWindow(session, { cwd: localSpawnCwd(cwd), command, name: "quick task" });
 }
-var CHAT_TAB_SWITCH_BINDINGS, CHAT_TAB_CLOSE_BINDING, CHAT_TAB_RENAME_BINDING, CHAT_TAB_ENGINE_PROMPT, CHAT_TAB_CHOOSE_ENGINE_BINDINGS, KOBE_STATUS_RIGHT = "#[fg=brightblack]^h tasks  ^q detach  ^t tab ", CHAT_TAB_STATE_OPTION = "@kobe_tab_state", PANE_VERSION_OPTION = "@kobe_pane_version", CHAT_TAB_STATUS_FORMAT = "#{?#{==:#{@kobe_tab_state},running},\u25CF,#{?#{==:#{@kobe_tab_state},done},\u2713,#{?#{==:#{@kobe_tab_state},error},!,#{?#{==:#{@kobe_tab_state},unknown},?,\u25CB}}}} #I:#W", CHAT_TAB_STATUS_CURRENT_FORMAT, ensureSessionLocks;
+var CHAT_TAB_SWITCH_BINDINGS, CHAT_TAB_CLOSE_BINDING, CHAT_TAB_RENAME_BINDING, CHAT_TAB_ENGINE_PROMPT, REMOTE_KEY_OPTION = "@kobe_remote", CHAT_TAB_CHOOSE_ENGINE_BINDINGS, KOBE_STATUS_RIGHT = "#[fg=brightblack]^h tasks  ^q detach  ^t tab ", CHAT_TAB_STATE_OPTION = "@kobe_tab_state", PANE_VERSION_OPTION = "@kobe_pane_version", CHAT_TAB_STATUS_FORMAT = "#{?#{==:#{@kobe_tab_state},running},\u25CF,#{?#{==:#{@kobe_tab_state},done},\u2713,#{?#{==:#{@kobe_tab_state},error},!,#{?#{==:#{@kobe_tab_state},unknown},?,\u25CB}}}} #I:#W", CHAT_TAB_STATUS_CURRENT_FORMAT, ensureSessionLocks;
 var init_tmux = __esm(() => {
   init_invocation();
   init_interactive_command();
   init_env();
+  init_resolve();
+  init_repos();
   init_client2();
   init_prompt_delivery();
   init_vendor();
@@ -6191,7 +6688,7 @@ var init_notes = __esm(() => {
 });
 
 // ../kobe-daemon/src/daemon/web.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { join as join6, normalize as normalize2 } from "path";
 function sseResponse(bus, snapshot) {
   let unsubscribe = null;
@@ -6321,7 +6818,7 @@ async function staticResponse(pathname, staticDir) {
   const resolved = normalize2(join6(staticDir, rel));
   if (!resolved.startsWith(staticDir))
     return new Response("forbidden", { status: 403 });
-  const file = Bun.file(existsSync2(resolved) ? resolved : join6(staticDir, "index.html"));
+  const file = Bun.file(existsSync3(resolved) ? resolved : join6(staticDir, "index.html"));
   if (!await file.exists()) {
     return new Response("kobe web assets not built \u2014 run `bun --filter kobe-web build`", { status: 503 });
   }
@@ -7018,14 +7515,14 @@ __export(exports_daemon_process, {
   connectIfRunning: () => connectIfRunning
 });
 import { spawn } from "child_process";
-import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync } from "fs";
+import { closeSync, existsSync as existsSync4, mkdirSync as mkdirSync3, openSync } from "fs";
 import { dirname as dirname5, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function spawnDetachedDaemon(command, args, env, logPath) {
   let stdio = "ignore";
   let logFd;
   try {
-    mkdirSync2(dirname5(logPath), { recursive: true });
+    mkdirSync3(dirname5(logPath), { recursive: true });
     logFd = openSync(logPath, "a");
     stdio = ["ignore", logFd, logFd];
   } catch {
@@ -7069,14 +7566,14 @@ async function connectIfRunning() {
   return client;
 }
 async function testDaemonResponds(socketPath, timeoutMs = DAEMON_HELLO_TIMEOUT_MS) {
-  const probe = new KobeDaemonClient(socketPath);
+  const probe2 = new KobeDaemonClient(socketPath);
   try {
-    await probe.connect();
+    await probe2.connect();
   } catch {
-    probe.close();
+    probe2.close();
     return false;
   }
-  const replied = probe.request("hello", { protocolVersion: DAEMON_PROTOCOL_VERSION }).then(() => true).catch(() => true);
+  const replied = probe2.request("hello", { protocolVersion: DAEMON_PROTOCOL_VERSION }).then(() => true).catch(() => true);
   let timer;
   const timedOut = new Promise((resolve3) => {
     timer = setTimeout(() => resolve3(false), timeoutMs);
@@ -7084,7 +7581,7 @@ async function testDaemonResponds(socketPath, timeoutMs = DAEMON_HELLO_TIMEOUT_M
   const alive = await Promise.race([replied, timedOut]);
   if (timer)
     clearTimeout(timer);
-  probe.close();
+  probe2.close();
   return alive;
 }
 function resolveKobeSpawn(subcommand) {
@@ -7098,7 +7595,7 @@ function resolveKobeSpawn(subcommand) {
     resolve2(dir, "../../../kobe/src/cli/index.ts"),
     resolve2(dir, "../cli/index.js")
   ];
-  const entry = candidates.find((candidate) => existsSync3(candidate));
+  const entry = candidates.find((candidate) => existsSync4(candidate));
   if (entry)
     return [process.execPath, entry, ...subcommand];
   throw new Error(`kobe: could not locate kobe entry near ${dir}; checked ${candidates.join(", ")}`);
@@ -7117,7 +7614,7 @@ var exports_repo_cmd = {};
 __export(exports_repo_cmd, {
   runRepoSubcommand: () => runRepoSubcommand
 });
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve3 } from "path";
 function usageError(message) {
   process.stderr.write(`kobe repo: ${message}
@@ -7128,7 +7625,7 @@ ${REPO_USAGE}
 }
 function readArgFile(path7) {
   try {
-    return readFileSync3(resolve3(process.cwd(), path7), "utf8");
+    return readFileSync4(resolve3(process.cwd(), path7), "utf8");
   } catch (err) {
     usageError(`cannot read ${path7}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -7190,14 +7687,14 @@ async function runRepoSubcommand(args) {
     return;
   }
   const { getRepoInitOverride: getRepoInitOverride2, setRepoInitOverride: setRepoInitOverride2, resolveRepoRoot: resolveRepoRoot2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
-  const { existsSync: existsSync4 } = await import("fs");
+  const { existsSync: existsSync5 } = await import("fs");
   const { join: join7 } = await import("path");
   if (verb === "show") {
     const [pathArg] = rest.filter((a) => !a.startsWith("-"));
     const repo = resolveRepoRoot2(resolve3(process.cwd(), pathArg ?? "."));
     const override = getRepoInitOverride2(repo);
-    const hasFileScript = existsSync4(join7(repo, ".kobe", "init.sh"));
-    const hasFilePrompt = existsSync4(join7(repo, ".kobe", "init-prompt.md"));
+    const hasFileScript = existsSync5(join7(repo, ".kobe", "init.sh"));
+    const hasFilePrompt = existsSync5(join7(repo, ".kobe", "init-prompt.md"));
     console.log(`repo: ${repo}`);
     console.log(`  .kobe/init.sh:        ${hasFileScript ? "present (wins)" : "absent"}`);
     console.log(`  .kobe/init-prompt.md: ${hasFilePrompt ? "present (wins)" : "absent"}`);
@@ -7264,7 +7761,7 @@ var init_repo_cmd = __esm(() => {
 });
 
 // src/lib/feedback.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 function parseRepoSlug(slug) {
   const [owner, name] = slug.split("/");
   if (!owner || !name)
@@ -7319,7 +7816,7 @@ function submitFeedback(input, deps = {}) {
     throw new Error("package repository is not a GitHub repository");
   const { owner, name } = parseRepoSlug(slug);
   const categorySlug = input.categorySlug?.trim() || DEFAULT_FEEDBACK_CATEGORY_SLUG;
-  const io = { spawn: deps.spawn ?? spawnSync3 };
+  const io = { spawn: deps.spawn ?? spawnSync4 };
   const categoryData = runGhGraphql(DISCUSSION_CATEGORY_QUERY, { owner, name }, io);
   const repository = categoryData.repository;
   const repositoryId = repository?.id;
@@ -7378,12 +7875,12 @@ __export(exports_worktree_changes, {
   readWorktreeChanges: () => readWorktreeChanges,
   parsePorcelain: () => parsePorcelain2
 });
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync5 } from "child_process";
 function readWorktreeChanges(worktreePath) {
   if (!worktreePath)
     return ZERO;
   try {
-    const out = spawnSync4("git", ["status", "--porcelain=v1"], {
+    const out = spawnSync5("git", ["status", "--porcelain=v1"], {
       cwd: worktreePath,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -7713,7 +8210,7 @@ function emit(value, pretty) {
   process.stdout.write(`${text}
 `);
 }
-function fail(message, code, exitCode = 1) {
+function fail2(message, code, exitCode = 1) {
   process.stderr.write(`${JSON.stringify({ error: { message, code } })}
 `);
   process.exit(exitCode);
@@ -7731,6 +8228,7 @@ async function deliverPrompt(client, target, prompt) {
   if (!existed) {
     const { ensureSession: ensureSession2 } = await Promise.resolve().then(() => (init_tmux(), exports_tmux));
     const { resolveRepoInit: resolveRepoInit2 } = await Promise.resolve().then(() => (init_repo_init(), exports_repo_init));
+    const { isRemoteRepoKey: isRemoteRepoKey2 } = await Promise.resolve().then(() => (init_repos(), exports_repos));
     const init = resolveRepoInit2(target.repo ?? "", worktree);
     const ok = await ensureSession2({
       name: session,
@@ -7738,6 +8236,7 @@ async function deliverPrompt(client, target, prompt) {
       command: interactiveEngineCommand(target.vendor),
       taskId: target.id,
       vendor: target.vendor,
+      remoteKey: target.repo && isRemoteRepoKey2(target.repo) ? target.repo : undefined,
       initScript: init.initScript
     });
     if (!ok)
@@ -7949,14 +8448,14 @@ async function runApiSubcommand(argv) {
   const [verbName, ...rest] = argv;
   if (!verbName || verbName === "--help" || verbName === "-h" || verbName === "help") {
     if (!verbName)
-      fail(apiUsage(), "MISSING_VERB", 2);
+      fail2(apiUsage(), "MISSING_VERB", 2);
     process.stdout.write(`${apiUsage()}
 `);
     return;
   }
   const verb = findVerb(verbName);
   if (!verb)
-    fail(`unknown verb: ${verbName}
+    fail2(`unknown verb: ${verbName}
 ${apiUsage()}`, "BAD_VERB", 2);
   const booleanFlags = new Set(verb.flags.filter((f) => f.type === "bool").map((f) => f.name));
   let parsed;
@@ -7964,8 +8463,8 @@ ${apiUsage()}`, "BAD_VERB", 2);
     parsed = parseFlags(rest, booleanFlags);
   } catch (err) {
     if (err instanceof ApiError)
-      fail(err.message, err.code, 2);
-    fail(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
+      fail2(err.message, err.code, 2);
+    fail2(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
   }
   if (parsed.help) {
     process.stdout.write(`${verbHelp(verb)}
@@ -7976,15 +8475,15 @@ ${apiUsage()}`, "BAD_VERB", 2);
     validateAgainstSpec(verb, parsed.flags);
   } catch (err) {
     if (err instanceof ApiError)
-      fail(err.message, err.code, 2);
-    fail(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
+      fail2(err.message, err.code, 2);
+    fail2(err instanceof Error ? err.message : String(err), "BAD_FLAG", 2);
   }
   let client = null;
   if (!verb.offline) {
     try {
       client = await connectOrStartDaemon();
     } catch (err) {
-      fail(`could not reach or start the kobe daemon: ${err instanceof Error ? err.message : String(err)}`, "BAD_DAEMON", 2);
+      fail2(`could not reach or start the kobe daemon: ${err instanceof Error ? err.message : String(err)}`, "BAD_DAEMON", 2);
     }
   }
   try {
@@ -7992,8 +8491,8 @@ ${apiUsage()}`, "BAD_VERB", 2);
     emit(result, parsed.pretty);
   } catch (err) {
     if (err instanceof ApiError)
-      fail(err.message, err.code, 1);
-    fail(err instanceof Error ? err.message : String(err), "RPC_ERROR", 1);
+      fail2(err.message, err.code, 1);
+    fail2(err instanceof Error ? err.message : String(err), "RPC_ERROR", 1);
   } finally {
     client?.close();
   }
@@ -8277,7 +8776,7 @@ __export(exports_update, {
   runUpdateSubcommand: () => runUpdateSubcommand,
   parseUpdateArgs: () => parseUpdateArgs
 });
-import { spawnSync as spawnSync5 } from "child_process";
+import { spawnSync as spawnSync6 } from "child_process";
 function updatePlan() {
   return {
     command: "sh",
@@ -8327,7 +8826,7 @@ function printUsage(out) {
 }
 async function runUpdateSubcommand(args, deps) {
   const io = {
-    spawn: deps?.spawn ?? spawnSync5,
+    spawn: deps?.spawn ?? spawnSync6,
     stdout: deps?.stdout ?? process.stdout,
     stderr: deps?.stderr ?? process.stderr,
     exit: deps?.exit ?? ((code) => process.exit(code))
@@ -8407,7 +8906,7 @@ function validateTheme(value) {
 var init_schema = () => {};
 
 // src/tui/context/theme/loader.ts
-import { readFileSync as readFileSync4, readdirSync } from "fs";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join7 } from "path";
 function userThemesDir() {
   return join7(kobeStateDir(), "themes");
@@ -8416,7 +8915,7 @@ function loadUserThemes() {
   const dir = userThemesDir();
   let entries;
   try {
-    entries = readdirSync(dir);
+    entries = readdirSync2(dir);
   } catch {
     return [];
   }
@@ -8427,7 +8926,7 @@ function loadUserThemes() {
     const path7 = join7(dir, file);
     let parsed;
     try {
-      const text = readFileSync4(path7, "utf8");
+      const text = readFileSync5(path7, "utf8");
       parsed = JSON.parse(text);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -8454,9 +8953,9 @@ var exports_theme = {};
 __export(exports_theme, {
   runThemeSubcommand: () => runThemeSubcommand
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync5, readdirSync as readdirSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { basename as basename3, join as join8, resolve as resolve5 } from "path";
-function fail2(message) {
+function fail3(message) {
   process.stderr.write(`kobe theme: ${message}
 `);
   process.exit(1);
@@ -8477,7 +8976,7 @@ function listThemes() {
   const dir = userThemesDir();
   let userFiles = [];
   try {
-    userFiles = readdirSync2(dir).filter((f) => f.endsWith(".json")).sort();
+    userFiles = readdirSync3(dir).filter((f) => f.endsWith(".json")).sort();
   } catch {}
   lines.push("");
   lines.push(`user (${dir}):`);
@@ -8501,10 +9000,10 @@ async function readSource(source) {
     try {
       res = await fetch(source);
     } catch (err) {
-      fail2(`failed to fetch ${source}: ${err instanceof Error ? err.message : String(err)}`);
+      fail3(`failed to fetch ${source}: ${err instanceof Error ? err.message : String(err)}`);
     }
     if (!res.ok) {
-      fail2(`failed to fetch ${source}: HTTP ${res.status} ${res.statusText}`);
+      fail3(`failed to fetch ${source}: HTTP ${res.status} ${res.statusText}`);
     }
     const text2 = await res.text();
     const cleanPath = source.split(/[?#]/)[0] ?? source;
@@ -8515,9 +9014,9 @@ async function readSource(source) {
   const abs = resolve5(process.cwd(), source);
   let text;
   try {
-    text = readFileSync5(abs, "utf8");
+    text = readFileSync6(abs, "utf8");
   } catch (err) {
-    fail2(`failed to read ${abs}: ${err instanceof Error ? err.message : String(err)}`);
+    fail3(`failed to read ${abs}: ${err instanceof Error ? err.message : String(err)}`);
   }
   const file = basename3(abs);
   const defaultName = file.endsWith(".json") ? file.slice(0, -".json".length) : file;
@@ -8564,21 +9063,21 @@ async function addTheme(args) {
   try {
     parsed = JSON.parse(text);
   } catch (err) {
-    fail2(`source is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
+    fail3(`source is not valid JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
   const result = validateTheme(parsed);
   if (!result.ok) {
-    fail2(`source is not a valid kobe theme: ${result.reason}`);
+    fail3(`source is not a valid kobe theme: ${result.reason}`);
   }
   const name = opts.name ?? defaultName;
   if (!name || !/^[a-zA-Z0-9._-]+$/.test(name)) {
-    fail2(`invalid theme name "${name}" (use letters, digits, '.', '_', '-')`);
+    fail3(`invalid theme name "${name}" (use letters, digits, '.', '_', '-')`);
   }
   const dir = userThemesDir();
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   const dest = join8(dir, `${name}.json`);
-  if (existsSync4(dest) && !opts.force) {
-    fail2(`${dest} already exists (pass --force to overwrite)`);
+  if (existsSync5(dest) && !opts.force) {
+    fail3(`${dest} already exists (pass --force to overwrite)`);
   }
   writeFileSync2(dest, `${JSON.stringify(result.theme, null, 2)}
 `, "utf8");
@@ -8592,11 +9091,11 @@ function removeTheme(args) {
   if (args.length > 1)
     failUsage(`unexpected extra arguments after "${name}"`);
   if (BUNDLED_NAMES.includes(name)) {
-    fail2(`"${name}" is a built-in theme and cannot be removed`);
+    fail3(`"${name}" is a built-in theme and cannot be removed`);
   }
   const dest = join8(userThemesDir(), `${name}.json`);
-  if (!existsSync4(dest)) {
-    fail2(`no user theme named "${name}" (looked for ${dest})`);
+  if (!existsSync5(dest)) {
+    fail3(`no user theme named "${name}" (looked for ${dest})`);
   }
   unlinkSync(dest);
   process.stdout.write(`removed theme "${name}" (${dest})
@@ -8664,7 +9163,7 @@ __export(exports_feedback_cmd, {
   runFeedbackSubcommand: () => runFeedbackSubcommand,
   parseFeedbackArgs: () => parseFeedbackArgs
 });
-import { readFileSync as readFileSync6 } from "fs";
+import { readFileSync as readFileSync7 } from "fs";
 function usageError2(message) {
   process.stderr.write(`kobe feedback: ${message}
 
@@ -8674,8 +9173,8 @@ ${FEEDBACK_USAGE}
 }
 function readBodyFile(path7) {
   if (path7 === "-")
-    return readFileSync6(0, "utf8");
-  return readFileSync6(path7, "utf8");
+    return readFileSync7(0, "utf8");
+  return readFileSync7(path7, "utf8");
 }
 function parseFeedbackArgs(args) {
   const parsed = { help: false };
@@ -8874,7 +9373,7 @@ var init_daemon_cmd = __esm(() => {
 });
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync8 } from "fs";
 import { homedir as homedir10 } from "os";
 import { join as join9 } from "path";
 function npxSkillsArgv(opts = {}) {
@@ -8893,13 +9392,13 @@ function parseSkillVersion(content) {
   return m ? Number.parseInt(m[1], 10) : null;
 }
 function kobeSkillState(opts) {
-  const path7 = kobeSkillPaths(opts).find((p) => existsSync5(p));
+  const path7 = kobeSkillPaths(opts).find((p) => existsSync6(p));
   if (!path7) {
     return { installed: false, installedVersion: null, currentVersion: KOBE_SKILL_VERSION, stale: false };
   }
   let installedVersion = null;
   try {
-    installedVersion = parseSkillVersion(readFileSync7(path7, "utf8"));
+    installedVersion = parseSkillVersion(readFileSync8(path7, "utf8"));
   } catch {
     installedVersion = null;
   }
@@ -8945,10 +9444,10 @@ __export(exports_maintenance, {
   runReloadSubcommand: () => runReloadSubcommand,
   runDoctorSubcommand: () => runDoctorSubcommand
 });
-import { existsSync as existsSync6, readFileSync as readFileSync8, statSync } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync9, statSync } from "fs";
 import { unlink as unlink6 } from "fs/promises";
 import { join as join10 } from "path";
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -8994,7 +9493,7 @@ function describeFile(path7) {
 }
 function taskCount(tasksPath) {
   try {
-    const parsed = JSON.parse(readFileSync8(tasksPath, "utf8"));
+    const parsed = JSON.parse(readFileSync9(tasksPath, "utf8"));
     return Array.isArray(parsed.tasks) ? parsed.tasks.length : null;
   } catch {
     return null;
@@ -9002,7 +9501,7 @@ function taskCount(tasksPath) {
 }
 function tailFile(path7, n) {
   try {
-    const lines = readFileSync8(path7, "utf8").split(`
+    const lines = readFileSync9(path7, "utf8").split(`
 `).filter((l) => l.trim().length > 0);
     return lines.slice(-n).join(`
 `);
@@ -9072,7 +9571,7 @@ async function runDoctorSubcommand(argv = []) {
     } else {
       out.push("daemon:  \u2717 not running (no pidfile)");
     }
-    if (existsSync6(socketPath))
+    if (existsSync7(socketPath))
       out.push(`         orphan socket file present: ${socketPath}`);
     const tail = tailFile(logPath, 8);
     if (tail) {
@@ -9109,7 +9608,7 @@ async function runDoctorSubcommand(argv = []) {
 `));
 }
 async function confirmTty(prompt) {
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
   try {
     const answer = await new Promise((resolve6) => rl.question(prompt, resolve6));
     return /^y(es)?$/i.test(answer.trim());
@@ -9272,7 +9771,7 @@ var exports_web_cmd = {};
 __export(exports_web_cmd, {
   runWebSubcommand: () => runWebSubcommand
 });
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { resolve as resolve6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveStaticDir() {
@@ -9282,7 +9781,7 @@ function resolveStaticDir() {
     resolve6(here, "../../web-ui")
   ];
   for (const dir of candidates) {
-    if (existsSync7(`${dir}/index.html`))
+    if (existsSync8(`${dir}/index.html`))
       return dir;
   }
   return;
@@ -9294,7 +9793,7 @@ function resolvePtyServer() {
     resolve6(here, "../../web-ui/pty-server.mjs")
   ];
   for (const file of candidates) {
-    if (existsSync7(file))
+    if (existsSync8(file))
       return file;
   }
   return;
@@ -9358,7 +9857,7 @@ async function startPtyServer(opts) {
 }
 async function runWebSubcommand(args) {
   if (args.includes("--help") || args.includes("-h")) {
-    process.stdout.write(USAGE);
+    process.stdout.write(USAGE2);
     return;
   }
   let port = 5173;
@@ -9426,7 +9925,7 @@ async function runWebSubcommand(args) {
     process.exit(1);
   }
 }
-var USAGE = `Usage: kobe web [options]
+var USAGE2 = `Usage: kobe web [options]
 
 Launch the kobe web UI on http://localhost:<port>.
 
@@ -11439,11 +11938,11 @@ var init_remote_orchestrator = __esm(() => {
 });
 
 // src/engine/claude-code-local/binary.ts
-import { spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync8, statSync as statSync2 } from "fs";
+import { spawnSync as spawnSync7 } from "child_process";
+import { existsSync as existsSync9, statSync as statSync2 } from "fs";
 import { homedir as homedir12 } from "os";
 import path7 from "path";
-async function findClaudeBinary(deps = defaultDeps4) {
+async function findClaudeBinary(deps = defaultDeps5) {
   const checked = [];
   const tryPath = (p) => {
     if (!p)
@@ -11492,7 +11991,7 @@ async function findClaudeBinary(deps = defaultDeps4) {
   }
   throw new ClaudeBinaryNotFoundError(checked);
 }
-var ClaudeBinaryNotFoundError, defaultDeps4;
+var ClaudeBinaryNotFoundError, defaultDeps5;
 var init_binary = __esm(() => {
   ClaudeBinaryNotFoundError = class ClaudeBinaryNotFoundError extends Error {
     checkedPaths;
@@ -11502,7 +12001,7 @@ var init_binary = __esm(() => {
       this.checkedPaths = checkedPaths;
     }
   };
-  defaultDeps4 = {
+  defaultDeps5 = {
     fileExists(p) {
       try {
         return statSync2(p).isFile();
@@ -11518,7 +12017,7 @@ var init_binary = __esm(() => {
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
-      const out = spawnSync6(cmd, [name], { encoding: "utf8" });
+      const out = spawnSync7(cmd, [name], { encoding: "utf8" });
       if (out.status !== 0)
         return;
       const first = out.stdout.split(`
@@ -11527,7 +12026,7 @@ var init_binary = __esm(() => {
         return;
       if (first.startsWith("claude:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync8(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -11543,11 +12042,11 @@ var init_binary = __esm(() => {
 });
 
 // src/engine/codex-local/binary.ts
-import { spawnSync as spawnSync7 } from "child_process";
-import { existsSync as existsSync9, statSync as statSync3 } from "fs";
+import { spawnSync as spawnSync8 } from "child_process";
+import { existsSync as existsSync10, statSync as statSync3 } from "fs";
 import { homedir as homedir13 } from "os";
 import path8 from "path";
-async function findCodexBinary(deps = defaultDeps5) {
+async function findCodexBinary(deps = defaultDeps6) {
   const checked = [];
   const tryPath = (p) => {
     if (!p)
@@ -11580,7 +12079,7 @@ async function findCodexBinary(deps = defaultDeps5) {
   }
   throw new CodexBinaryNotFoundError(checked);
 }
-var CodexBinaryNotFoundError, defaultDeps5;
+var CodexBinaryNotFoundError, defaultDeps6;
 var init_binary2 = __esm(() => {
   CodexBinaryNotFoundError = class CodexBinaryNotFoundError extends Error {
     checkedPaths;
@@ -11590,7 +12089,7 @@ var init_binary2 = __esm(() => {
       this.checkedPaths = checkedPaths;
     }
   };
-  defaultDeps5 = {
+  defaultDeps6 = {
     fileExists(p) {
       try {
         return statSync3(p).isFile();
@@ -11606,7 +12105,7 @@ var init_binary2 = __esm(() => {
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
-      const out = spawnSync7(cmd, [name], { encoding: "utf8" });
+      const out = spawnSync8(cmd, [name], { encoding: "utf8" });
       if (out.status !== 0)
         return;
       const first = out.stdout.split(`
@@ -11615,7 +12114,7 @@ var init_binary2 = __esm(() => {
         return;
       if (first.startsWith("codex:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync9(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync10(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -11631,11 +12130,11 @@ var init_binary2 = __esm(() => {
 });
 
 // src/engine/copilot-local/binary.ts
-import { spawnSync as spawnSync8 } from "child_process";
-import { existsSync as existsSync10, statSync as statSync4 } from "fs";
+import { spawnSync as spawnSync9 } from "child_process";
+import { existsSync as existsSync11, statSync as statSync4 } from "fs";
 import { homedir as homedir14 } from "os";
 import path9 from "path";
-async function findCopilotBinary(deps = defaultDeps6) {
+async function findCopilotBinary(deps = defaultDeps7) {
   const checked = [];
   const tryPath = (p) => {
     if (!p)
@@ -11692,7 +12191,7 @@ async function findCopilotBinary(deps = defaultDeps6) {
   }
   throw new CopilotBinaryNotFoundError(checked);
 }
-var CopilotBinaryNotFoundError, defaultDeps6;
+var CopilotBinaryNotFoundError, defaultDeps7;
 var init_binary3 = __esm(() => {
   CopilotBinaryNotFoundError = class CopilotBinaryNotFoundError extends Error {
     checkedPaths;
@@ -11702,7 +12201,7 @@ var init_binary3 = __esm(() => {
       this.checkedPaths = checkedPaths;
     }
   };
-  defaultDeps6 = {
+  defaultDeps7 = {
     fileExists(p) {
       try {
         return statSync4(p).isFile();
@@ -11718,7 +12217,7 @@ var init_binary3 = __esm(() => {
     },
     which(name) {
       const cmd = process.platform === "win32" ? "where" : "which";
-      const out = spawnSync8(cmd, [name], { encoding: "utf8" });
+      const out = spawnSync9(cmd, [name], { encoding: "utf8" });
       if (out.status !== 0)
         return;
       const first = out.stdout.split(`
@@ -11727,7 +12226,7 @@ var init_binary3 = __esm(() => {
         return;
       if (first.startsWith("copilot:") && first.includes("aliased to")) {
         const aliasTarget = first.split("aliased to")[1]?.trim();
-        return aliasTarget && existsSync10(aliasTarget) ? aliasTarget : undefined;
+        return aliasTarget && existsSync11(aliasTarget) ? aliasTarget : undefined;
       }
       return first;
     },
@@ -11738,7 +12237,7 @@ var init_binary3 = __esm(() => {
 });
 
 // src/engine/account-detect.ts
-import { readFileSync as readFileSync9, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync10, statSync as statSync5 } from "fs";
 import { homedir as homedir15 } from "os";
 import path10 from "path";
 function claudeGlobalConfigPath(env, home) {
@@ -11774,9 +12273,9 @@ function decodeJwtPayload(jwt) {
     return null;
   }
 }
-async function probeBinary(probe) {
+async function probeBinary(probe2) {
   try {
-    const p = await probe();
+    const p = await probe2();
     return { found: true, path: p };
   } catch (err) {
     if (err instanceof ClaudeBinaryNotFoundError || err instanceof CodexBinaryNotFoundError || err instanceof CopilotBinaryNotFoundError) {
@@ -11785,20 +12284,20 @@ async function probeBinary(probe) {
     return { found: false, error: err instanceof Error ? err.message : String(err) };
   }
 }
-async function detectAvailableVendors(deps = defaultDeps7) {
+async function detectAvailableVendors(deps = defaultDeps8) {
   const probes = [
     ["claude", () => deps.findClaudeBinary()],
     ["codex", () => deps.findCodexBinary()],
     ["copilot", () => deps.findCopilotBinary()]
   ];
-  const detected = await Promise.all(probes.map(async ([vendor, probe]) => (await probeBinary(probe)).found ? vendor : null));
+  const detected = await Promise.all(probes.map(async ([vendor, probe2]) => (await probeBinary(probe2)).found ? vendor : null));
   return detected.filter((v) => v !== null);
 }
-async function availableEngineIds(deps = defaultDeps7) {
+async function availableEngineIds(deps = defaultDeps8) {
   const builtins = await detectAvailableVendors(deps);
   return [...builtins, ...getCustomEngineIds()];
 }
-async function detectClaudeAccount(deps = defaultDeps7) {
+async function detectClaudeAccount(deps = defaultDeps8) {
   const binary = await probeBinary(() => deps.findClaudeBinary());
   const configPath = claudeGlobalConfigPath(deps.env, deps.home());
   let raw;
@@ -11841,7 +12340,7 @@ async function detectClaudeAccount(deps = defaultDeps7) {
     }
   };
 }
-async function detectCodexAccount(deps = defaultDeps7) {
+async function detectCodexAccount(deps = defaultDeps8) {
   const binary = await probeBinary(() => deps.findCodexBinary());
   const authPath = codexAuthPath(deps.env, deps.home());
   let raw;
@@ -11892,7 +12391,7 @@ async function detectCodexAccount(deps = defaultDeps7) {
   }
   return { binary, account: { kind: "none" } };
 }
-async function detectCopilotAccount(deps = defaultDeps7) {
+async function detectCopilotAccount(deps = defaultDeps8) {
   const binary = await probeBinary(() => deps.findCopilotBinary());
   for (const source of ["COPILOT_GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN"]) {
     if (deps.env(source)?.trim())
@@ -11950,13 +12449,13 @@ function hasStringDeep(value, interestingKeys, depth = 0) {
   }
   return false;
 }
-var defaultDeps7;
+var defaultDeps8;
 var init_account_detect = __esm(() => {
   init_repos();
   init_binary();
   init_binary2();
   init_binary3();
-  defaultDeps7 = {
+  defaultDeps8 = {
     readFile(p) {
       try {
         statSync5(p);
@@ -11965,7 +12464,7 @@ var init_account_detect = __esm(() => {
           return null;
         throw err;
       }
-      return readFileSync9(p, "utf8");
+      return readFileSync10(p, "utf8");
     },
     env(name) {
       return process.env[name];
@@ -12096,8 +12595,8 @@ function validateRepoPath(repo) {
   if (!stat4.isDirectory())
     return `not a directory: ${trimmed}`;
   try {
-    const { spawnSync: spawnSync9 } = __require("child_process");
-    const out = spawnSync9("git", ["rev-parse", "--git-dir"], {
+    const { spawnSync: spawnSync10 } = __require("child_process");
+    const out = spawnSync10("git", ["rev-parse", "--git-dir"], {
       cwd: trimmed,
       encoding: "utf-8",
       timeout: 2000,
@@ -12114,8 +12613,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: spawnSync10 } = __require("child_process");
+    const out = spawnSync10("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: repo,
       encoding: "utf-8",
       timeout: 2000,
@@ -12135,8 +12634,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: spawnSync10 } = __require("child_process");
+    const out = spawnSync10("git", ["for-each-ref", "--format=%(refname:short)", "refs/heads/"], {
       cwd: repo,
       encoding: "utf-8",
       timeout: 2000
@@ -15838,12 +16337,12 @@ var init_focus = __esm(() => {
 });
 
 // src/tui/context/kv.tsx
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
 import { dirname as dirname7 } from "path";
 function loadInitial() {
   const statePath2 = kvStatePath();
   try {
-    const text = readFileSync10(statePath2, "utf8");
+    const text = readFileSync11(statePath2, "utf8");
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -15867,7 +16366,7 @@ var init_kv = __esm(() => {
       function writeNow(label) {
         const statePath2 = kvStatePath();
         try {
-          mkdirSync4(dirname7(statePath2), {
+          mkdirSync5(dirname7(statePath2), {
             recursive: true
           });
           const tmp = `${statePath2}.tmp`;
@@ -15922,7 +16421,7 @@ var init_kv = __esm(() => {
           }
           const statePath2 = kvStatePath();
           try {
-            mkdirSync4(dirname7(statePath2), {
+            mkdirSync5(dirname7(statePath2), {
               recursive: true
             });
             const tmp = `${statePath2}.tmp`;
@@ -15939,10 +16438,10 @@ var init_kv = __esm(() => {
 });
 
 // src/tui/lib/persisted-ui-prefs.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 function readPersistedUiPrefs(fallbackTheme) {
   try {
-    const parsed = JSON.parse(readFileSync11(kvStatePath(), "utf8"));
+    const parsed = JSON.parse(readFileSync12(kvStatePath(), "utf8"));
     const theme = typeof parsed.activeTheme === "string" && hasTheme(parsed.activeTheme) ? parsed.activeTheme : fallbackTheme;
     const transparent = parsed.transparentBackground === true;
     const focusAccent = typeof parsed.focusAccent === "string" && FOCUS_ACCENT_SLOTS.includes(parsed.focusAccent) ? parsed.focusAccent : null;
@@ -16222,6 +16721,9 @@ async function ensureTaskSession2(orch, task, repo, vendor) {
   const {
     resolveRepoInit: resolveRepoInit2
   } = await Promise.resolve().then(() => (init_repo_init(), exports_repo_init));
+  const {
+    isRemoteRepoKey: isRemoteRepoKey2
+  } = await Promise.resolve().then(() => (init_repos(), exports_repos));
   const init2 = resolveRepoInit2(repo, worktree);
   const ok = await ensureSession2({
     name: session,
@@ -16229,6 +16731,7 @@ async function ensureTaskSession2(orch, task, repo, vendor) {
     command: interactiveEngineCommand(vendor),
     taskId: task.id,
     vendor,
+    remoteKey: isRemoteRepoKey2(repo) ? repo : undefined,
     initScript: init2.initScript
   });
   if (!ok)
@@ -17646,6 +18149,9 @@ function engineRowCount(customCount) {
   return ALL_VENDORS.length + customCount + 1;
 }
 function devRowCount(hasDaemon) {
+  return (hasDaemon ? 2 : 1) + 1;
+}
+function experimentalRemoteRowIndex(hasDaemon) {
   return hasDaemon ? 2 : 1;
 }
 function feedbackRowCount() {
@@ -18529,12 +19035,15 @@ function DevSettingsSection(props) {
   } = useTheme();
   const resetIsCursor = () => props.level() === "body" && props.bodyRow() === 0;
   const restartIsCursor = () => props.level() === "body" && props.bodyRow() === 1;
+  const experimentalRow = () => experimentalRemoteRowIndex(props.hasDaemon);
+  const remoteIsCursor = () => props.level() === "body" && props.bodyRow() === experimentalRow();
   return (() => {
-    var _el$128 = createElement("box"), _el$129 = createElement("text"), _el$131 = createElement("text"), _el$133 = createElement("box"), _el$134 = createElement("text"), _el$144 = createElement("text");
+    var _el$128 = createElement("box"), _el$129 = createElement("text"), _el$131 = createElement("text"), _el$133 = createElement("box"), _el$134 = createElement("text"), _el$144 = createElement("text"), _el$146 = createElement("box"), _el$147 = createElement("text"), _el$149 = createElement("text"), _el$151 = createElement("box"), _el$152 = createElement("text");
     insertNode(_el$128, _el$129);
     insertNode(_el$128, _el$131);
     insertNode(_el$128, _el$133);
     insertNode(_el$128, _el$144);
+    insertNode(_el$128, _el$146);
     setProp(_el$128, "flexDirection", "column");
     setProp(_el$128, "gap", 1);
     insertNode(_el$129, createTextNode(`Reset UI state`));
@@ -18597,8 +19106,27 @@ function DevSettingsSection(props) {
     }), _el$144);
     insertNode(_el$144, createTextNode(`Daemon wedged or unresponsive? From a shell, run \`kobe doctor\` to diagnose, or \`kobe reset\` to stop the daemon + kill sessions (keeps your tasks). Use \`kobe reset --hard\` only to also wipe the task index + UI state.`));
     setProp(_el$144, "wrapMode", "word");
+    insertNode(_el$146, _el$147);
+    insertNode(_el$146, _el$149);
+    insertNode(_el$146, _el$151);
+    setProp(_el$146, "flexDirection", "column");
+    setProp(_el$146, "gap", 0);
+    setProp(_el$146, "paddingTop", 1);
+    insertNode(_el$147, createTextNode(`Experimental`));
+    insertNode(_el$149, createTextNode(`Remote projects (SSH): register a project whose git worktrees + engine run on another host over SSH, driven from this local kobe. Unfinished \u2014 file/diff panes still degrade for remote. Enables \`kobe add --remote\`.`));
+    setProp(_el$149, "wrapMode", "word");
+    insertNode(_el$151, _el$152);
+    setProp(_el$151, "flexDirection", "row");
+    setProp(_el$151, "paddingLeft", 1);
+    setProp(_el$151, "paddingRight", 1);
+    setProp(_el$151, "onMouseUp", () => {
+      props.setLevel("body");
+      props.setBodyRow(experimentalRow());
+      props.toggleRemoteProjects();
+    });
+    insert(_el$152, () => props.remoteProjectsEnabled() ? "[x] Remote projects (on)" : "[ ] Remote projects (off)");
     effect((_p$) => {
-      var _v$86 = theme.text, _v$87 = TextAttributes8.BOLD, _v$88 = theme.textMuted, _v$89 = resetIsCursor() ? theme.primary : theme.backgroundElement, _v$90 = resetIsCursor() ? theme.selectedListItemText : theme.warning, _v$91 = TextAttributes8.BOLD, _v$92 = theme.textMuted;
+      var _v$86 = theme.text, _v$87 = TextAttributes8.BOLD, _v$88 = theme.textMuted, _v$89 = resetIsCursor() ? theme.primary : theme.backgroundElement, _v$90 = resetIsCursor() ? theme.selectedListItemText : theme.warning, _v$91 = TextAttributes8.BOLD, _v$92 = theme.textMuted, _v$93 = theme.text, _v$94 = TextAttributes8.BOLD, _v$95 = theme.textMuted, _v$96 = remoteIsCursor() ? theme.primary : theme.backgroundElement, _v$97 = remoteIsCursor() ? theme.selectedListItemText : theme.text, _v$98 = props.remoteProjectsEnabled() ? TextAttributes8.BOLD : undefined;
       _v$86 !== _p$.e && (_p$.e = setProp(_el$129, "fg", _v$86, _p$.e));
       _v$87 !== _p$.t && (_p$.t = setProp(_el$129, "attributes", _v$87, _p$.t));
       _v$88 !== _p$.a && (_p$.a = setProp(_el$131, "fg", _v$88, _p$.a));
@@ -18606,6 +19134,12 @@ function DevSettingsSection(props) {
       _v$90 !== _p$.i && (_p$.i = setProp(_el$134, "fg", _v$90, _p$.i));
       _v$91 !== _p$.n && (_p$.n = setProp(_el$134, "attributes", _v$91, _p$.n));
       _v$92 !== _p$.s && (_p$.s = setProp(_el$144, "fg", _v$92, _p$.s));
+      _v$93 !== _p$.h && (_p$.h = setProp(_el$147, "fg", _v$93, _p$.h));
+      _v$94 !== _p$.r && (_p$.r = setProp(_el$147, "attributes", _v$94, _p$.r));
+      _v$95 !== _p$.d && (_p$.d = setProp(_el$149, "fg", _v$95, _p$.d));
+      _v$96 !== _p$.l && (_p$.l = setProp(_el$151, "backgroundColor", _v$96, _p$.l));
+      _v$97 !== _p$.u && (_p$.u = setProp(_el$152, "fg", _v$97, _p$.u));
+      _v$98 !== _p$.c && (_p$.c = setProp(_el$152, "attributes", _v$98, _p$.c));
       return _p$;
     }, {
       e: undefined,
@@ -18614,7 +19148,13 @@ function DevSettingsSection(props) {
       o: undefined,
       i: undefined,
       n: undefined,
-      s: undefined
+      s: undefined,
+      h: undefined,
+      r: undefined,
+      d: undefined,
+      l: undefined,
+      u: undefined,
+      c: undefined
     });
     return _el$128;
   })();
@@ -18739,6 +19279,12 @@ function SettingsDialog(props) {
   function toggleSound() {
     props.kv.set("notifications.sound.enabled", !soundEnabled());
   }
+  function remoteProjectsEnabled() {
+    return props.kv.get("experimental.remoteProjects", false) === true;
+  }
+  function toggleRemoteProjects() {
+    props.kv.set("experimental.remoteProjects", !remoteProjectsEnabled());
+  }
   function customEngines() {
     const raw = props.kv.get("customEngineIds", []);
     return Array.isArray(raw) ? raw.filter((s) => typeof s === "string" && s.trim().length > 0) : [];
@@ -19006,6 +19552,8 @@ function SettingsDialog(props) {
         confirmResetState(dialog, props.kv, renderer);
       else if (hasDaemon && bodyRow() === 1)
         confirmRestartDaemon(dialog, props.orchestrator, renderer);
+      else if (bodyRow() === experimentalRemoteRowIndex(hasDaemon))
+        toggleRemoteProjects();
     }
   }
   useBindings(() => ({
@@ -19196,7 +19744,9 @@ function SettingsDialog(props) {
           setBodyRow,
           hasDaemon,
           confirmReset: () => void confirmResetState(dialog, props.kv, renderer),
-          confirmRestartDaemon: () => void confirmRestartDaemon(dialog, props.orchestrator, renderer)
+          confirmRestartDaemon: () => void confirmRestartDaemon(dialog, props.orchestrator, renderer),
+          remoteProjectsEnabled,
+          toggleRemoteProjects
         });
       }
     }), null);
@@ -19266,7 +19816,7 @@ var pulse_default = "../pulse-n3cq1btw.wav";
 var init_pulse = () => {};
 
 // src/tui/lib/sound.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
 import { basename as basename4, isAbsolute, join as join14, resolve as resolve8 } from "path";
 function args(player, file, volume) {
@@ -19291,12 +19841,12 @@ function pickPlayer() {
     return cachedPlayer;
   const path12 = process.env.PATH ?? "";
   const segments = path12.split(":").filter(Boolean);
-  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync12(join14(dir, p)))) ?? null;
+  cachedPlayer = PLAYERS.find((p) => segments.some((dir) => existsSync13(join14(dir, p)))) ?? null;
   return cachedPlayer;
 }
 async function ensureAsset() {
   cachedPath ??= (async () => {
-    mkdirSync5(DIR, { recursive: true });
+    mkdirSync6(DIR, { recursive: true });
     const dest = join14(DIR, basename4(pulseAsset));
     const out = Bun.file(dest);
     if (await out.exists())
@@ -19632,7 +20182,7 @@ var init_task_actions = __esm(() => {
 
 // src/tui/lib/worktree-opener.ts
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { basename as basename5, delimiter, isAbsolute as isAbsolute2, join as join15 } from "path";
 function executableOnPath(command, env, exists) {
   if (isAbsolute2(command))
@@ -19660,8 +20210,8 @@ function labelForOverride(command) {
 }
 function detectWorktreeOpener(deps = {}) {
   const env = deps.env ?? process.env;
-  const platform = deps.platform ?? process.platform;
-  const exists = deps.exists ?? existsSync13;
+  const platform2 = deps.platform ?? process.platform;
+  const exists = deps.exists ?? existsSync14;
   const override = env.KOBE_OPEN_EDITOR?.trim();
   if (override) {
     return { id: "env", label: labelForOverride(override), command: override, args: [] };
@@ -19671,7 +20221,7 @@ function detectWorktreeOpener(deps = {}) {
       return { id: c.id, label: c.label, command: c.command, args: [] };
     }
   }
-  if (platform === "darwin" && executableOnPath("open", env, exists)) {
+  if (platform2 === "darwin" && executableOnPath("open", env, exists)) {
     for (const app of MAC_APP_CANDIDATES) {
       if (app.paths.some((path12) => exists(path12))) {
         return { id: app.id, label: app.label, command: "open", args: ["-a", app.appName] };
@@ -19679,7 +20229,7 @@ function detectWorktreeOpener(deps = {}) {
     }
     return { id: "mac-open", label: "Finder", command: "open", args: [] };
   }
-  if (platform === "linux" && executableOnPath("xdg-open", env, exists)) {
+  if (platform2 === "linux" && executableOnPath("xdg-open", env, exists)) {
     return { id: "xdg-open", label: "Open", command: "xdg-open", args: [] };
   }
   return null;
@@ -19739,12 +20289,12 @@ var init_worktree_opener = __esm(() => {
 });
 
 // src/tui/panes/sidebar/git-head.ts
-import { spawnSync as spawnSync9 } from "child_process";
+import { spawnSync as spawnSync10 } from "child_process";
 function readCurrentBranch(repo) {
   if (!repo)
     return "";
   try {
-    const out = spawnSync9("git", ["symbolic-ref", "--short", "HEAD"], {
+    const out = spawnSync10("git", ["symbolic-ref", "--short", "HEAD"], {
       cwd: repo,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -19755,7 +20305,7 @@ function readCurrentBranch(repo) {
       if (name && name !== "HEAD")
         return name;
     }
-    const head = spawnSync9("git", ["rev-parse", "--verify", "HEAD"], {
+    const head = spawnSync10("git", ["rev-parse", "--verify", "HEAD"], {
       cwd: repo,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -20954,8 +21504,13 @@ var exports_host3 = {};
 __export(exports_host3, {
   startTasksPane: () => startTasksPane
 });
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { TextAttributes as TextAttributes13 } from "@opentui/core";
+function worktreeCwdUsable(cwd) {
+  if (!cwd)
+    return false;
+  return execHostForWorktreePath(cwd).isRemote || existsSync15(cwd);
+}
 function TasksShell(props) {
   const themeCtx = useTheme();
   const {
@@ -21228,7 +21783,7 @@ function TasksShell(props) {
   async function openSelectedWorktree(id) {
     const task = props.tasks().find((t) => t.id === id);
     let worktree = task?.worktreePath;
-    if (!worktree || !existsSync14(worktree)) {
+    if (!worktree || !existsSync15(worktree)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         notifyError("No daemon running \u2014 can't create the worktree");
@@ -21243,7 +21798,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!worktree || !existsSync14(worktree))
+    if (!worktree || !existsSync15(worktree))
       return;
     const opener = detectWorktreeOpener();
     if (!opener) {
@@ -21321,13 +21876,14 @@ function TasksShell(props) {
     const exists = await sessionExists(name);
     if (exists) {
       const cwd2 = await getSessionOption(name, "@kobe_worktree") || task?.worktreePath || "";
-      if (cwd2 && existsSync14(cwd2)) {
+      if (worktreeCwdUsable(cwd2)) {
         await ensureSession({
           name,
           cwd: cwd2,
           command: interactiveEngineCommand(task?.vendor),
           taskId: id,
-          vendor: task?.vendor
+          vendor: task?.vendor,
+          remoteKey: task?.repo && isRemoteRepoKey(task.repo) ? task.repo : undefined
         });
       }
       await runTmux(["switch-client", "-t", `=${name}`]);
@@ -21335,7 +21891,7 @@ function TasksShell(props) {
       return;
     }
     let cwd = task?.worktreePath;
-    if (!cwd || !existsSync14(cwd)) {
+    if (!worktreeCwdUsable(cwd)) {
       if (!props.orch) {
         console.error("[kobe tasks] no daemon; cannot materialise worktree");
         notifyError("No daemon running \u2014 can't open this task");
@@ -21350,7 +21906,7 @@ function TasksShell(props) {
       }
       await props.reload();
     }
-    if (!cwd || !existsSync14(cwd))
+    if (!worktreeCwdUsable(cwd))
       return;
     const init2 = task?.repo ? resolveRepoInit(task.repo, cwd) : {};
     const ready = await ensureSession({
@@ -21359,6 +21915,7 @@ function TasksShell(props) {
       command: interactiveEngineCommand(task?.vendor),
       taskId: id,
       vendor: task?.vendor,
+      remoteKey: task?.repo && isRemoteRepoKey(task.repo) ? task.repo : undefined,
       initScript: init2.initScript,
       initPrompt: init2.initPrompt
     });
@@ -21720,6 +22277,7 @@ var init_host3 = __esm(() => {
   init_account_detect();
   init_interactive_command();
   init_env();
+  init_resolve();
   init_errors();
   init_store();
   init_repo_init();
@@ -21906,13 +22464,13 @@ var exports_host5 = {};
 __export(exports_host5, {
   startUpdateHost: () => startUpdateHost
 });
-import { spawn as spawn4, spawnSync as spawnSync10 } from "child_process";
+import { spawn as spawn4, spawnSync as spawnSync11 } from "child_process";
 import { TextAttributes as TextAttributes14 } from "@opentui/core";
 function openExternalUrl(url) {
   if (!url)
     return false;
-  const platform = process.platform;
-  const [command, args2] = platform === "darwin" ? ["open", [url]] : platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  const platform2 = process.platform;
+  const [command, args2] = platform2 === "darwin" ? ["open", [url]] : platform2 === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
     const child = spawn4(command, args2, {
       stdio: "ignore",
@@ -22012,7 +22570,7 @@ kobe ${CURRENT_VERSION} -> latest
     process.stdout.write(`running: ${UPDATE_COMMAND}
 
 `);
-    const result = spawnSync10("sh", ["-c", UPDATE_COMMAND], {
+    const result = spawnSync11("sh", ["-c", UPDATE_COMMAND], {
       stdio: "inherit"
     });
     const code = result.status ?? (result.error ? 1 : 0);
@@ -22799,14 +23357,14 @@ var init_keys2 = __esm(() => {
 
 // src/tui/panes/filetree/open-external.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync15 } from "fs";
-import { platform } from "os";
+import { existsSync as existsSync16 } from "fs";
+import { platform as platform2 } from "os";
 function openExternally(absPath) {
   if (!absPath)
     return;
-  const plat = platform();
+  const plat = platform2();
   if (plat === "linux") {
-    if (existsSync15("/proc/sys/fs/binfmt_misc/WSLInterop") || process.env.WSL_DISTRO_NAME) {
+    if (existsSync16("/proc/sys/fs/binfmt_misc/WSLInterop") || process.env.WSL_DISTRO_NAME) {
       spawnDetached("wslview", [absPath], () => {
         const child = spawn5("wslpath", ["-w", absPath], {
           stdio: ["ignore", "pipe", "ignore"]
@@ -23614,12 +24172,12 @@ var init_filetree = __esm(() => {
 });
 
 // src/tui/ops/pr-prompt.ts
-import { spawnSync as spawnSync11 } from "child_process";
+import { spawnSync as spawnSync12 } from "child_process";
 import { promises as fs4 } from "fs";
 import path12 from "path";
-function git2(cwd, args2) {
+function git(cwd, args2) {
   try {
-    const out = spawnSync11("git", args2.slice(), {
+    const out = spawnSync12("git", args2.slice(), {
       cwd,
       encoding: "utf8",
       timeout: GIT_TIMEOUT_MS2,
@@ -23635,20 +24193,20 @@ function git2(cwd, args2) {
   }
 }
 function currentBranch(cwd) {
-  return git2(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
+  return git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || "HEAD";
 }
 function targetBranch(cwd) {
-  const out = git2(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
+  const out = git(cwd, ["symbolic-ref", "refs/remotes/origin/HEAD", "--short"]);
   if (!out)
     return "main";
   return out.startsWith("origin/") ? out.slice("origin/".length) : out;
 }
 function hasUpstream(cwd) {
-  const out = git2(cwd, ["rev-parse", "--abbrev-ref", "@{u}"]);
+  const out = git(cwd, ["rev-parse", "--abbrev-ref", "@{u}"]);
   return out !== null && out.length > 0;
 }
 function dirtyCount(cwd) {
-  const out = git2(cwd, ["status", "--porcelain"]);
+  const out = git(cwd, ["status", "--porcelain"]);
   if (!out)
     return 0;
   return out.split(`
@@ -24273,6 +24831,7 @@ async function startDirectTmux() {
       command: interactiveEngineCommand(task.vendor),
       taskId: task.id,
       vendor: task.vendor,
+      remoteKey: isRemoteRepoKey(task.repo) ? task.repo : undefined,
       initScript: init2.initScript,
       initPrompt: init2.initPrompt
     });
@@ -24687,7 +25246,7 @@ function repoBasename2(repo) {
 }
 
 // src/tui/component/top-bar.tsx
-import { spawnSync as spawnSync12 } from "child_process";
+import { spawnSync as spawnSync13 } from "child_process";
 import { TextAttributes as TextAttributes18 } from "@opentui/core";
 function TopBar(props) {
   const {
@@ -24716,7 +25275,7 @@ function TopBar(props) {
 `);
     process.stderr.write(`running: ${UPDATE_COMMAND}
 `);
-    const result = spawnSync12("sh", ["-c", UPDATE_COMMAND], {
+    const result = spawnSync13("sh", ["-c", UPDATE_COMMAND], {
       stdio: "inherit"
     });
     if (result.error) {
@@ -25435,6 +25994,7 @@ async function launchTaskTmux(opts) {
     command: opts.command,
     taskId: opts.taskId,
     vendor: opts.vendor,
+    remoteKey: opts.repo && isRemoteRepoKey(opts.repo) ? opts.repo : undefined,
     initScript: init2.initScript,
     initPrompt: init2.initPrompt
   });
@@ -25535,6 +26095,7 @@ var init_fullscreen = __esm(() => {
   init_solid();
   init_dev();
   init_repo_init();
+  init_repos();
   init_theme2();
   init_keymap();
   init_dialog();
@@ -26214,19 +26775,27 @@ function topLevelUsage() {
 }
 
 // src/cli/index.ts
-async function runAddSubcommand(arg) {
-  if (arg === "--help" || arg === "-h" || arg === "help") {
-    process.stdout.write(`Usage: kobe add [path]
+var ADD_USAGE = `Usage: kobe add [path]
+` + `       kobe add --remote --host <host> --user <user> --path <basePath> [--port N] [--key <path> | --password]
 
-Save a repo path (default: the current directory) for the new-task picker.
-`);
+` + `Save a repo for the new-task picker. With --remote, register an SSH-backed
+` + `project whose worktrees + engine run on <host> under <basePath>.
+`;
+async function runAddSubcommand(rest) {
+  const arg = rest[0];
+  if (arg === "--help" || arg === "-h" || arg === "help") {
+    process.stdout.write(ADD_USAGE);
+    return;
+  }
+  if (arg === "--remote") {
+    const { runAddRemote: runAddRemote2 } = await Promise.resolve().then(() => (init_add_remote(), exports_add_remote));
+    await runAddRemote2(rest.slice(1));
     return;
   }
   if (arg?.startsWith("-")) {
     process.stderr.write(`kobe add: unknown flag "${arg}"
 
-Usage: kobe add [path]
-`);
+${ADD_USAGE}`);
     process.exit(2);
   }
   const target = resolve10(process.cwd(), arg && arg.length > 0 ? arg : ".");
@@ -26414,7 +26983,7 @@ async function main() {
     return;
   }
   if (subcommand === "add") {
-    await runAddSubcommand(rest[0]);
+    await runAddSubcommand(rest);
     return;
   }
   if (subcommand === "adopt") {