codehost 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+# [0.18.0](https://github.com/snomiao/codehost/compare/v0.17.0...v0.18.0) (2026-06-11)
+
+
+### Features
+
+* **cli:** ~/ws as the default workspace root + loud y/N confirm for serving $HOME ([aee5a20](https://github.com/snomiao/codehost/commit/aee5a207a930058472f5b2042a56904051e079a7))
+* **provision:** batteries-included roots — setup auto-scaffolds .codehost/, scaffold detaches fresh clones ([625d958](https://github.com/snomiao/codehost/commit/625d9587d97b59da0bb595aa456a56d3bf920ac4))
+
+# [0.17.0](https://github.com/snomiao/codehost/compare/v0.16.0...v0.17.0) (2026-06-11)
+
+
+### Bug Fixes
+
+* **vscode:** reject the desktop bin/code wrapper — probe serve-web support, not just --version ([e5b133d](https://github.com/snomiao/codehost/commit/e5b133d0ff38f4e1052f87c22279c7850eb98968))
+
+
+### Features
+
+* **history:** durable history via hostId + machine-preferring deep-link resolution ([1935579](https://github.com/snomiao/codehost/commit/1935579a40fb7c42f46b8f1596497dac812cdc2b))
+* **host:** one daemon per host — `dev` registers with a live root daemon instead of spawning a second peer ([43051de](https://github.com/snomiao/codehost/commit/43051deaae33f647b26bdcf0facb0bac9507471f))
+* **identity:** stable per-machine hostId, advertised in PeerMeta; web groups workspaces by host ([43a48a2](https://github.com/snomiao/codehost/commit/43a48a2630534c36c399f0cce294a2e96235b5fb))
+* **lib:** embeddable room-client bundle for external consoles (agent-yes.com) ([fd0afd1](https://github.com/snomiao/codehost/commit/fd0afd19234816127b640c397eeac5cc7968f484))
+* **plugins:** daemon plugin layer + agent-yes plugin (agents[] in meta, ay API proxy over the tunnel) ([60f77b2](https://github.com/snomiao/codehost/commit/60f77b2dbbe3b649bbc8a34982b028d5a432ddb7))
+* **tree:** root daemons advertise enumerated workspaces; live meta updates; exact deep-link matching ([81493be](https://github.com/snomiao/codehost/commit/81493be6694d85110a0e9f1244bd6604875c02a2))
+
 # [0.16.0](https://github.com/snomiao/codehost/compare/v0.15.0...v0.16.0) (2026-06-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -18,6 +18,7 @@
     "dev:signal": "cd worker && wrangler dev",
     "cli": "bun src/cli/index.ts",
     "build": "vite build && vite build --config vite.sw.config.ts",
+    "build:lib": "bun build src/web/room-client.ts --target browser --format esm --minify --outfile dist/room-client.js",
     "deploy:signal": "cd worker && wrangler deploy",
     "deploy:pages": "vite build && wrangler pages deploy dist/public --project-name codehost",
     "start": "bun src/server.ts",

package/src/cli/commands/dev.ts

@@ -3,12 +3,14 @@ import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
 import { repoIdentity } from "../git";
-import { toPosixPath } from "../../shared/repo";
+import { liveDaemon, registerWorkspace } from "../registry";
+import { shareableDeepLink, toPosixPath } from "../../shared/repo";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
 interface DevArgs {
@@ -17,6 +19,7 @@ interface DevArgs {
   name?: string;
   signal: string;
   daemon: boolean;
+  standalone: boolean;
   port?: number;
 }
 
@@ -52,6 +55,11 @@ export const devCommand: CommandModule<{}, DevArgs> = {
         type: "boolean",
         default: false,
       })
+      .option("standalone", {
+        describe: "Always spawn an own peer + VS Code, even when a host daemon already runs",
+        type: "boolean",
+        default: false,
+      })
       .option("port", {
         describe: "Fixed port for the local VS Code server (default: ephemeral)",
         type: "number",
@@ -68,6 +76,28 @@ export const devCommand: CommandModule<{}, DevArgs> = {
     const dir = resolve(process.cwd(), argv.dir);
     const host = hostname();
 
+    // One daemon per host: a single VS Code serve-web opens any local path via
+    // ?folder=, so when a root daemon already runs here, just REGISTER this
+    // directory with it (it re-advertises within moments) instead of spawning a
+    // second peer + VS Code. --standalone restores the old behavior.
+    const daemon = argv.standalone ? null : liveDaemon();
+    if (daemon) {
+      registerWorkspace(dir);
+      const id = repoIdentity(dir);
+      const path =
+        (id.repo
+          ? shareableDeepLink({ repo: id.repo, branch: id.branch })
+          : shareableDeepLink({ folder: toPosixPath(dir), host })) ?? "/";
+      console.log(`[codehost] host daemon already serving "${daemon.root}" (pid ${daemon.pid})`);
+      console.log(`[codehost] registered ${dir} with it — no second daemon needed`);
+      console.log(`[codehost] open: https://codehost.dev${path}#t=${encodeURIComponent(daemon.token)}`);
+      if (daemon.token !== argv.token) {
+        console.log("[codehost] note: the host daemon's room differs from your -t; the link above uses the daemon's room");
+      }
+      console.log("[codehost] (use --standalone to force an own daemon instead)");
+      return;
+    }
+
     if (argv.daemon) {
       const { ok } = await launchServeDaemon({
         command: "dev",
@@ -90,6 +120,7 @@ export const devCommand: CommandModule<{}, DevArgs> = {
       // the real OS path for the local VS Code working dir.
       cwd: toPosixPath(dir),
       host,
+      hostId: ensureHostId(),
       kind: "repo",
       repo: id.repo,
       branch: id.branch,

package/src/cli/commands/expose.ts

@@ -2,6 +2,7 @@ import { hostname } from "node:os";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { runServer } from "../run-server";
 import { DEFAULT_SIGNAL_URL } from "./serve";
@@ -78,6 +79,7 @@ export const exposeCommand: CommandModule<{}, ExposeArgs> = {
       name: argv.name ?? `localhost:${argv.port}`,
       cwd: `localhost:${argv.port}`,
       host,
+      hostId: ensureHostId(),
     };
 
     // No VS Code: tunnel directly to the given port, stripping the /vs/<peerId>

package/src/cli/commands/serve.ts

@@ -1,18 +1,66 @@
-import { hostname } from "node:os";
+import { mkdirSync } from "node:fs";
+import { homedir, hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import type { PeerMeta } from "../../shared/signaling";
 import { DEFAULT_LAYOUT, GITHUB_HOST, toPosixPath } from "../../shared/repo";
 import { TOKEN_REQUIREMENTS, validateToken } from "../../shared/token";
+import { defaultRoot, ensureHostId } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { announceConnect } from "../open-url";
+import { agentYesPlugin } from "../plugins/agent-yes";
+import { withPluginMeta } from "../plugins/types";
+import { readCodehostConfig } from "../provision-server";
+import {
+  clearDaemonPresence,
+  readRegisteredWorkspaces,
+  workspacesFile,
+  writeDaemonPresence,
+} from "../registry";
+import { repoIdentity } from "../git";
 import { runServer } from "../run-server";
 import { launchVscode } from "../vscode";
+import { enumerateWorkspaces } from "../workspaces";
 
 export const DEFAULT_SIGNAL_URL = "wss://signal.codehost.dev";
 
+/** Warn + interactively confirm a risky root (default No). Non-TTY contexts
+ *  (the oxmgr-daemonized child, CI) can't answer — there the human already
+ *  confirmed at launch time, so warn loudly and proceed. */
+export async function confirmRiskyRoot(dir: string): Promise<boolean> {
+  const warning = rootWarning(dir);
+  if (!warning) return true;
+  console.warn(`[codehost] warning: ${warning}`);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return true;
+  process.stdout.write("[codehost] serve it anyway? [y/N] ");
+  const line = await new Promise<string>((res) => {
+    process.stdin.resume();
+    process.stdin.once("data", (d) => {
+      process.stdin.pause();
+      res(String(d));
+    });
+  });
+  return /^y(es)?$/i.test(line.trim());
+}
+
+/** Warning for serving a risky workspace root, or null if fine. $HOME (and the
+ *  filesystem root) expose everything you own over the room, collide the
+ *  provisioning `.codehost/` with the machine-level `~/.codehost`, and make
+ *  workspace enumeration walk your whole home. Allowed if you insist — but
+ *  say so loudly and point at a dedicated dir like ~/ws. */
+export function rootWarning(dir: string): string | null {
+  const norm = resolve(dir);
+  if (norm === resolve(homedir())) {
+    return "serving your HOME directory as the workspace root — everything in it is reachable through this room. A dedicated dir is safer: codehost serve ~/ws";
+  }
+  if (norm === resolve("/")) {
+    return "serving the filesystem root — the entire machine is reachable through this room. A dedicated dir is safer, e.g. ~/ws";
+  }
+  return null;
+}
+
 interface ServeArgs {
-  dir: string;
+  dir?: string;
   token: string;
   name?: string;
   signal: string;
@@ -27,9 +75,8 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
   builder: (y) =>
     y
       .positional("dir", {
-        describe: "Directory to serve (defaults to cwd)",
+        describe: "Workspace root to serve (default: the remembered root, else ~/ws)",
         type: "string",
-        default: ".",
       })
       .option("token", {
         alias: "t",
@@ -65,7 +112,17 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
       process.exit(1);
     }
 
-    const dir = resolve(process.cwd(), argv.dir);
+    // Explicit dir > remembered root (config.json) > ~/ws. Bare `codehost
+    // serve` should land somewhere sane, never accidentally on $HOME/cwd.
+    const dir = argv.dir ? resolve(process.cwd(), argv.dir) : defaultRoot();
+    if (!argv.dir) {
+      mkdirSync(dir, { recursive: true });
+      console.log(`[codehost] no dir given — serving workspace root ${dir}`);
+    }
+    if (!(await confirmRiskyRoot(dir))) {
+      console.error("[codehost] aborted");
+      process.exit(1);
+    }
     const host = hostname();
 
     // `-d`: re-launch this same `serve` (without -d) under oxmgr, then exit.
@@ -84,22 +141,54 @@ export const serveCommand: CommandModule<{}, ServeArgs> = {
     }
 
     // A workspace root: repos under it open by GitHub-shaped deep link, mapped
-    // onto subfolders via VS Code's ?folder= using this layout.
-    const meta: PeerMeta = {
-      name: argv.name ?? host,
-      // VS Code-web ?folder= form for the browser (C:\ws -> /C:/ws); the real
-      // OS path `dir` is still what we spawn VS Code in.
-      cwd: toPosixPath(dir),
-      host,
-      kind: "root",
-      layout: DEFAULT_LAYOUT,
+    // onto subfolders via VS Code's ?folder= using this layout. The layout is
+    // the same template provisioning uses (.codehost/config.yaml `workspace`),
+    // so the advertised list and the provisioned paths agree.
+    const layout = readCodehostConfig(dir).workspace || DEFAULT_LAYOUT;
+    const plugins = [agentYesPlugin()].filter((p) => p != null);
+    const buildMeta = (): PeerMeta => {
+      // Layout-enumerated checkouts plus directories other `codehost dev` runs
+      // registered with this host daemon (git-identified best-effort).
+      const workspaces = enumerateWorkspaces(dir, layout);
+      for (const w of readRegisteredWorkspaces()) {
+        const path = toPosixPath(w.path);
+        if (workspaces.some((x) => x.path === path)) continue;
+        const id = repoIdentity(w.path);
+        workspaces.push({
+          path,
+          ...(id.repo ? { repo: id.repo } : {}),
+          ...(id.branch ? { branch: id.branch } : {}),
+        });
+      }
+      return withPluginMeta(
+        {
+          name: argv.name ?? host,
+          // VS Code-web ?folder= form for the browser (C:\ws -> /C:/ws); the
+          // real OS path `dir` is still what we spawn VS Code in.
+          cwd: toPosixPath(dir),
+          host,
+          hostId: ensureHostId(),
+          kind: "root",
+          layout,
+          workspaces,
+        },
+        plugins,
+      );
     };
 
+    // Mark this process as the host daemon, so later `codehost dev` runs
+    // register their directory with it instead of spawning a second peer.
+    writeDaemonPresence({ pid: process.pid, root: dir, token: argv.token, startedAt: Date.now() });
+    process.on("exit", () => clearDaemonPresence());
+
     announceConnect(argv.token);
     await runServer({
       token: argv.token,
       signal: argv.signal,
-      meta,
+      meta: buildMeta(),
+      refreshMeta: buildMeta,
+      watchFiles: [workspacesFile()],
+      plugins,
       label: `serving workspace root ${dir}`,
       provision: { homeDir: dir, host: GITHUB_HOST },
       launch: async (basePath) => {

package/src/cli/commands/setup.ts

@@ -1,16 +1,19 @@
+import { mkdirSync } from "node:fs";
 import { hostname } from "node:os";
 import { resolve } from "node:path";
 import type { CommandModule } from "yargs";
 import { generateToken, validateToken, TOKEN_REQUIREMENTS } from "../../shared/token";
-import { readConfig, writeConfig } from "../config";
+import { defaultRoot, readConfig, writeConfig } from "../config";
 import { launchServeDaemon } from "../daemonize";
 import { isGitRepo } from "../git";
+import { scaffoldCodehost } from "../init";
+import { confirmRiskyRoot } from "./serve";
 import { resolveCodeBinary } from "../vscode-install";
 import { announceConnect } from "../open-url";
 import { DEFAULT_SIGNAL_URL } from "./serve";
 
 interface SetupArgs {
-  dir: string;
+  dir?: string;
   token?: string;
   newToken: boolean;
   name?: string;
@@ -23,7 +26,10 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
   describe: "One-shot: pick a token, ensure VS Code, and start a daemonized server",
   builder: (y) =>
     y
-      .positional("dir", { describe: "Directory to serve (defaults to cwd)", type: "string", default: "." })
+      .positional("dir", {
+        describe: "Directory to serve (default: a git cwd serves itself, else the remembered root / ~/ws)",
+        type: "string",
+      })
       .option("token", {
         alias: "t",
         describe: "Room token (generated + saved if omitted)",
@@ -38,7 +44,23 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
       .option("signal", { describe: "Signaling server URL", type: "string", default: DEFAULT_SIGNAL_URL })
       .option("port", { describe: "Fixed port for the local VS Code server", type: "number" }) as any,
   handler: async (argv) => {
-    const dir = resolve(process.cwd(), argv.dir);
+    // Explicit dir > a git cwd (serve THIS repo) > remembered root > ~/ws —
+    // so a bare `codehost setup` (e.g. from the installer) lands on a sane
+    // workspace root instead of whatever directory it happened to run in.
+    let dir: string;
+    if (argv.dir) {
+      dir = resolve(process.cwd(), argv.dir);
+    } else if (isGitRepo(process.cwd())) {
+      dir = process.cwd();
+    } else {
+      dir = defaultRoot();
+      mkdirSync(dir, { recursive: true });
+      console.log(`[codehost] no dir given — using workspace root ${dir}`);
+    }
+    if (!(await confirmRiskyRoot(dir))) {
+      console.error("[codehost] aborted");
+      process.exit(1);
+    }
     const host = hostname();
 
     // 1. Resolve the room token: validate an explicit one, otherwise reuse the
@@ -53,10 +75,24 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
     const codeBin = await resolveCodeBinary();
     console.log(`[codehost] using VS Code: ${codeBin}`);
 
-    // 3. Start the WebRTC + VS Code server under oxmgr. A git repo is a single
+    // 3. Batteries included: a workspace root gets its `.codehost/` scaffold
+    //    (config.yaml + clone/worktree setup hook) so /gh/<owner>/<repo> links
+    //    provision on demand out of the box. Existing files are never touched;
+    //    no new trust — the room token already grants code execution.
+    const root = !isGitRepo(dir);
+    if (root) {
+      const written = scaffoldCodehost(dir);
+      if (written.length > 0) {
+        console.log(`[codehost] scaffolded ${dir}/.codehost (config.yaml + setup hook — edit freely)`);
+      }
+      // Remember an explicitly chosen root so future bare runs reuse it.
+      if (argv.dir) writeConfig({ ...readConfig(), root: dir });
+    }
+
+    // 4. Start the WebRTC + VS Code server under oxmgr. A git repo is a single
     //    workspace (`dev`); anything else is treated as a root (`serve`).
     const { ok, name } = await launchServeDaemon({
-      command: isGitRepo(dir) ? "dev" : "serve",
+      command: root ? "serve" : "dev",
       dir,
       token,
       signal: argv.signal,
@@ -66,7 +102,7 @@ export const setupCommand: CommandModule<{}, SetupArgs> = {
     });
     if (!ok) process.exit(1);
 
-    // 4. Tell the user how to connect, and open the browser straight at the
+    // 5. Tell the user how to connect, and open the browser straight at the
     //    token-carrying URL so VS Code loads without typing the token in.
     console.log("");
     console.log(`[codehost] ✓ server "${name}" is live, serving ${dir}`);

package/src/cli/config.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ensureHostId, readConfig, writeConfig } from "./config";
+
+const tmpConfig = () => join(mkdtempSync(join(tmpdir(), "codehost-config-")), "config.json");
+
+describe("ensureHostId", () => {
+  test("mints a UUID once and returns the same id on later calls", () => {
+    const file = tmpConfig();
+    const first = ensureHostId(file);
+    expect(first).toMatch(/^[0-9a-f-]{36}$/);
+    expect(ensureHostId(file)).toBe(first);
+    expect(readConfig(file).hostId).toBe(first);
+  });
+
+  test("preserves other config fields when minting", () => {
+    const file = tmpConfig();
+    writeConfig({ token: "Str0ng-Token-99" }, file);
+    const id = ensureHostId(file);
+    const config = JSON.parse(readFileSync(file, "utf8"));
+    expect(config).toEqual({ token: "Str0ng-Token-99", hostId: id });
+  });
+
+  test("returns an existing hostId without rewriting", () => {
+    const file = tmpConfig();
+    writeConfig({ hostId: "pre-existing-id" }, file);
+    expect(ensureHostId(file)).toBe("pre-existing-id");
+  });
+});

package/src/cli/config.ts

@@ -3,25 +3,47 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 
 // Persistent CLI config under ~/.codehost (same root as the managed VS Code
-// cache in vscode-install.ts). Currently just the reusable room token so
-// `codehost setup` lands on a stable room URL across runs.
+// cache in vscode-install.ts): the reusable room token and this machine's
+// stable hostId.
 
 const CONFIG_FILE = join(homedir(), ".codehost", "config.json");
 
 export interface CliConfig {
   /** Room token reused by `setup` until --new-token or an explicit -t. */
   token?: string;
+  /** Stable machine identity (UUID), minted once on first use. Every daemon on
+   *  this machine advertises it, so the web UI can group peers by host and
+   *  history entries survive daemon restarts (peerIds are per-process). */
+  hostId?: string;
+  /** Workspace root remembered from an explicit `codehost setup <dir>` —
+   *  reused when serve/setup run with no dir. Absent -> ~/ws. */
+  root?: string;
 }
 
-export function readConfig(): CliConfig {
+export function readConfig(file: string = CONFIG_FILE): CliConfig {
   try {
-    return JSON.parse(readFileSync(CONFIG_FILE, "utf8")) as CliConfig;
+    return JSON.parse(readFileSync(file, "utf8")) as CliConfig;
   } catch {
     return {};
   }
 }
 
-export function writeConfig(config: CliConfig): void {
-  mkdirSync(dirname(CONFIG_FILE), { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+export function writeConfig(config: CliConfig, file: string = CONFIG_FILE): void {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(config, null, 2));
+}
+
+/** The workspace root to use when no dir was given: the remembered root from
+ *  config, else ~/ws (created on demand by the caller). Never $HOME itself. */
+export function defaultRoot(file: string = CONFIG_FILE): string {
+  return readConfig(file).root || join(homedir(), "ws");
+}
+
+/** This machine's persistent hostId, minting + saving it on first call. */
+export function ensureHostId(file: string = CONFIG_FILE): string {
+  const config = readConfig(file);
+  if (config.hostId) return config.hostId;
+  const hostId = crypto.randomUUID();
+  writeConfig({ ...config, hostId }, file);
+  return hostId;
 }

package/src/cli/daemonize.ts

@@ -75,6 +75,10 @@ function buildForegroundArgv(opts: ServeDaemonOptions): string[] {
   const parts = [process.execPath, process.argv[1], opts.command ?? "serve", opts.arg ?? opts.dir, "-t", opts.token, "--signal", opts.signal];
   if (opts.name) parts.push("--name", opts.name);
   if (opts.port) parts.push("--port", String(opts.port));
+  // An oxmgr-managed `dev` must stay a real daemon across restarts/reboots —
+  // never collapse into register-with-the-host-daemon-and-exit (oxmgr would
+  // see an instant exit and thrash).
+  if ((opts.command ?? "serve") === "dev") parts.push("--standalone");
   return parts;
 }
 

package/src/cli/init.test.ts

@@ -23,11 +23,11 @@ describe("scaffoldCodehost", () => {
     expect(existsSync(join(home, ".codehost", "setup.ps1"))).toBe(true);
   });
 
-  test("config.yaml is valid YAML with a workspace template", () => {
+  test("config.yaml is valid YAML with a prefix-free workspace template", () => {
     const home = mkHome();
     scaffoldCodehost(home);
     const cfg = parseYaml(readFileSync(join(home, ".codehost", "config.yaml"), "utf8"));
-    expect(cfg.workspace).toBe("ws/{owner}/{repo}/tree/{branch}");
+    expect(cfg.workspace).toBe("{owner}/{repo}/tree/{branch}");
   });
 
   test("setup.sh keeps shell vars literal (no JS interpolation leaked)", () => {
@@ -37,6 +37,8 @@ describe("scaffoldCodehost", () => {
     expect(sh).toContain("$CODEHOST_WS");
     expect(sh).toContain("${ws%/tree/$CODEHOST_BRANCH}");
     expect(sh).toContain("git -C \"$repo\" worktree add");
+    // Fresh clones detach so the default branch is worktree-able too.
+    expect(sh).toContain('git -C "$repo" switch --detach');
   });
 
   test("idempotent: a second run writes nothing; --force overwrites", () => {

package/src/cli/init.ts

@@ -7,9 +7,9 @@ import { join } from "node:path";
 
 const CONFIG_YAML = `# codehost workspace config — see docs/provisioning.md
 
-# Where /gh/<owner>/<repo>/tree/<branch> lands, relative to this home dir.
-# Default (if omitted): {owner}/{repo}/tree/{branch}
-workspace: "ws/{owner}/{repo}/tree/{branch}"
+# Where /gh/<owner>/<repo>/tree/<branch> lands, relative to this served root
+# (serve a dedicated workspace dir like ~/ws — never \$HOME itself).
+workspace: "{owner}/{repo}/tree/{branch}"
 
 # Optional: only these repos may auto-provision (a trailing /* is an owner
 # wildcard). Empty/absent = allow all. The room token already grants access, so
@@ -41,6 +41,10 @@ if [ ! -e "$repo/.git" ]; then
   echo "[setup] cloning $url"
   mkdir -p "$(dirname "$repo")"
   git clone "$url" "$repo"
+  # Detach the fresh primary clone so EVERY branch (incl. the default one it
+  # just checked out) can be worktree-added under tree/<branch>. Skipped for
+  # pre-existing clones — they may be someone's live working copy.
+  git -C "$repo" switch --detach
 fi
 
 echo "[setup] adding worktree $ws @ $CODEHOST_BRANCH"
@@ -67,6 +71,8 @@ if (-not (Test-Path (Join-Path $repo ".git"))) {
   Write-Host "[setup] cloning $url"
   New-Item -ItemType Directory -Force -Path (Split-Path $repo) | Out-Null
   git clone $url $repo
+  # Detach so every branch (incl. the default) can be worktree-added.
+  git -C $repo switch --detach
 }
 Write-Host "[setup] adding worktree $ws @ $($env:CODEHOST_BRANCH)"
 New-Item -ItemType Directory -Force -Path (Split-Path $ws) | Out-Null

package/src/cli/plugins/agent-yes.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { agentYesPlugin, readAgents } from "./agent-yes";
+import { routePlugins, withPluginMeta } from "./types";
+
+function makeAyDir(lines: object[]): string {
+  const dir = mkdtempSync(join(tmpdir(), "codehost-ay-"));
+  writeFileSync(join(dir, "pids.jsonl"), lines.map((l) => JSON.stringify(l)).join("\n") + "\n");
+  return dir;
+}
+
+describe("readAgents", () => {
+  test("last line per pid wins; exited and dead pids are dropped", () => {
+    const dir = makeAyDir([
+      { pid: process.pid, cli: "claude", prompt: "fix the bug", cwd: "/tmp", status: "idle", started_at: 5 },
+      { pid: 99999999, cli: "gemini", cwd: "/tmp", status: "active" }, // dead pid
+      { pid: process.pid, cli: "claude", status: "exited", exit_code: 0 }, // last line per pid wins
+    ]);
+    // The final line marks our (live) pid exited, and the other pid is dead.
+    expect(readAgents(dir)).toHaveLength(0);
+  });
+
+  test("maps a live record to AgentInfo", () => {
+    const dir = makeAyDir([
+      { pid: process.pid, cli: "claude", prompt: "do things", cwd: "/tmp/x", status: "active", started_at: 7 },
+    ]);
+    expect(readAgents(dir)).toEqual([
+      { pid: process.pid, tool: "claude", title: "do things", cwd: "/tmp/x", state: "active", startedAt: 7 },
+    ]);
+  });
+
+  test("missing registry -> empty", () => {
+    expect(readAgents(mkdtempSync(join(tmpdir(), "codehost-ay-empty-")))).toEqual([]);
+  });
+});
+
+describe("plugin routing + meta", () => {
+  test("routePlugins dispatches under /__codehost/<name>/ with the sub-path", async () => {
+    const seen: string[] = [];
+    const plugin = {
+      name: "agent-yes",
+      route: async (path: string) => {
+        seen.push(path);
+        return new Response("ok");
+      },
+    };
+    const res = routePlugins([plugin], {
+      method: "GET",
+      path: "/__codehost/agent-yes/api/ls?active=1",
+      headers: new Headers(),
+    });
+    expect(res).not.toBeNull();
+    await res;
+    expect(seen).toEqual(["/api/ls?active=1"]);
+    expect(
+      routePlugins([plugin], { method: "GET", path: "/__codehost/other/x", headers: new Headers() }),
+    ).toBeNull();
+  });
+
+  test("withPluginMeta merges contributions over the base", () => {
+    const base = { name: "x", cwd: "/", host: "mac" };
+    const merged = withPluginMeta(base, [{ name: "agent-yes", meta: () => ({ agents: [] }) }]);
+    expect(merged).toEqual({ name: "x", cwd: "/", host: "mac", agents: [] });
+  });
+
+  test("agentYesPlugin returns null when the dir doesn't exist", () => {
+    expect(agentYesPlugin("/nonexistent/definitely-not-here")).toBeNull();
+  });
+});