codehost 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -1,3 +1,20 @@
+# [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.17.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

@@ -4,10 +4,22 @@ 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 { 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";
 
@@ -84,22 +96,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/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,38 @@ 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;
 }
 
-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));
+}
+
+/** 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/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();
+  });
+});

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

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { toPosixPath } from "../../shared/repo";
+import type { AgentInfo } from "../../shared/signaling";
+import type { DaemonPlugin } from "./types";
+
+// agent-yes plugin: advertises the machine's live agent CLI sessions (read
+// straight from agent-yes's registry, so it works even when `ay serve` is
+// down) and proxies /__codehost/agent-yes/* to the local `ay serve` API with
+// its bearer token injected. Granting room members agent control is not new
+// trust: the room token already grants code execution (the editor is a
+// terminal) — same boundary as provisioning (see shared/provision.ts).
+
+const AY_DIR = join(homedir(), ".agent-yes");
+const AY_PORT = Number(process.env.CODEHOST_AY_PORT) || 7432;
+/** Cap the advertised list (meta rides the signaling room broadcast). */
+const MAX_AGENTS = 50;
+
+interface AyRecord {
+  pid: number;
+  cli?: string;
+  prompt?: string | null;
+  cwd?: string;
+  status?: "active" | "idle" | "exited";
+  started_at?: number;
+}
+
+/** agent-yes's global registry: JSONL, last line per pid wins. */
+export function readAgents(dir: string = AY_DIR): AgentInfo[] {
+  let raw: string;
+  try {
+    raw = readFileSync(join(dir, "pids.jsonl"), "utf8");
+  } catch {
+    return [];
+  }
+  const byPid = new Map<number, AyRecord>();
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      const rec = JSON.parse(line) as AyRecord;
+      if (typeof rec.pid === "number") byPid.set(rec.pid, { ...byPid.get(rec.pid), ...rec });
+    } catch {
+      // skip malformed lines
+    }
+  }
+  const out: AgentInfo[] = [];
+  for (const rec of [...byPid.values()].sort((a, b) => (b.started_at ?? 0) - (a.started_at ?? 0))) {
+    if (out.length >= MAX_AGENTS) break;
+    if (rec.status === "exited" || !alive(rec.pid)) continue;
+    out.push({
+      pid: rec.pid,
+      tool: rec.cli || "agent",
+      ...(rec.prompt ? { title: rec.prompt.slice(0, 120) } : {}),
+      cwd: toPosixPath(rec.cwd ?? ""),
+      state: rec.status === "active" ? "active" : "idle",
+      ...(rec.started_at ? { startedAt: rec.started_at } : {}),
+    });
+  }
+  return out;
+}
+
+function alive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function serveToken(dir: string): string | null {
+  try {
+    const t = readFileSync(join(dir, ".serve-token"), "utf8").trim();
+    return t || null;
+  } catch {
+    return null;
+  }
+}
+
+/** The plugin, or null when this machine has never run agent-yes. */
+export function agentYesPlugin(dir: string = AY_DIR): DaemonPlugin | null {
+  if (!existsSync(dir)) return null;
+  return {
+    name: "agent-yes",
+    meta: () => {
+      const agents = readAgents(dir);
+      return agents.length > 0 ? { agents } : {};
+    },
+    route: async (path, req) => {
+      const token = serveToken(dir);
+      if (!token) {
+        return new Response(JSON.stringify({ error: "ay serve has no token (is agent-yes installed?)" }), {
+          status: 503,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      const headers = new Headers(req.headers);
+      headers.set("authorization", `Bearer ${token}`);
+      headers.set("host", `127.0.0.1:${AY_PORT}`);
+      try {
+        return await fetch(`http://127.0.0.1:${AY_PORT}${path}`, {
+          method: req.method,
+          headers,
+          body: req.body as BodyInit | undefined,
+          redirect: "manual",
+        });
+      } catch {
+        return new Response(JSON.stringify({ error: "ay serve is not running (start it with `ay serve install`)" }), {
+          status: 502,
+          headers: { "content-type": "application/json" },
+        });
+      }
+    },
+  };
+}

package/src/cli/plugins/types.ts

@@ -0,0 +1,39 @@
+import type { PeerMeta } from "../../shared/signaling";
+
+// Daemon plugin surface: a plugin contributes (a) fields merged into the
+// advertised PeerMeta on every refresh, and (b) an HTTP route mounted under the
+// tunnel at /__codehost/<name>/*. codehost stays the transport + registry;
+// plugins (agent-yes first) own their domain.
+
+export interface DaemonPlugin {
+  /** Identifier; also the tunnel mount: requests to /__codehost/<name>/* land
+   *  in `route`. */
+  name: string;
+  /** Resource contribution, merged into PeerMeta by the daemon's meta builder
+   *  (startup + every refresh). Keep it small — it rides room broadcasts. */
+  meta?: () => Partial<PeerMeta>;
+  /** Serve a tunneled request. `path` is the remainder after the mount, always
+   *  starting with "/" and keeping the query string. */
+  route?: (path: string, req: { method: string; headers: Headers; body?: Uint8Array }) => Promise<Response>;
+}
+
+/** Route a local tunnel request to the owning plugin, or null to fall through. */
+export function routePlugins(
+  plugins: DaemonPlugin[],
+  req: { method: string; path: string; headers: Headers; body?: Uint8Array },
+): Promise<Response> | null {
+  for (const p of plugins) {
+    if (!p.route) continue;
+    const mount = `/__codehost/${p.name}`;
+    if (req.path === mount || req.path.startsWith(`${mount}/`) || req.path.startsWith(`${mount}?`)) {
+      const rest = req.path.slice(mount.length) || "/";
+      return p.route(rest.startsWith("/") ? rest : `/${rest}`, req);
+    }
+  }
+  return null;
+}
+
+/** Merge every plugin's meta contribution into a base meta. */
+export function withPluginMeta(base: PeerMeta, plugins: DaemonPlugin[]): PeerMeta {
+  return Object.assign({}, base, ...plugins.map((p) => p.meta?.() ?? {}));
+}

package/src/cli/provision-server.ts

@@ -18,9 +18,12 @@ export interface ProvisionDeps {
   homeDir: string;
   /** Git host advertised by this daemon (default github.com). */
   host: string;
+  /** Called after a setup script finishes (any exit code) — lets the daemon
+   *  re-enumerate + re-advertise its workspaces. */
+  onProvisioned?: () => void;
 }
 
-interface CodehostConfig {
+export interface CodehostConfig {
   workspace?: string; // layout template, e.g. "ws/{owner}/{repo}/tree/{branch}"
   allowlist?: string[];
 }
@@ -30,7 +33,7 @@ export function isProvisionPath(path: string): boolean {
   return path.split("?")[0] === PROVISION_PATH;
 }
 
-function readConfig(homeDir: string): CodehostConfig {
+export function readCodehostConfig(homeDir: string): CodehostConfig {
   try {
     const raw = readFileSync(join(homeDir, ".codehost", "config.yaml"), "utf8");
     const c = (parseYaml(raw) ?? {}) as Record<string, unknown>;
@@ -74,7 +77,7 @@ export async function handleProvision(rawPath: string, deps: ProvisionDeps): Pro
   if (!v.ok) return json(400, { error: v.reason });
 
   const host = (url.searchParams.get("host") ?? deps.host).toLowerCase();
-  const cfg = readConfig(deps.homeDir);
+  const cfg = readCodehostConfig(deps.homeDir);
   const key = repoKey({ host, owner: v.target.owner, name: v.target.repo });
   if (!repoAllowed(key, cfg.allowlist)) return json(403, { error: `repo not allowlisted: ${key}` });
 
@@ -152,6 +155,11 @@ function freshBody(
         resolveDone(code);
         say(`\n::codehost:exit=${code}\n`);
         controller.close();
+        try {
+          deps.onProvisioned?.();
+        } catch {
+          // advertising is best-effort; never fail the provision response
+        }
       }
     },
   });

package/src/cli/registry.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  clearDaemonPresence,
+  liveDaemon,
+  readRegisteredWorkspaces,
+  registerWorkspace,
+  writeDaemonPresence,
+} from "./registry";
+
+const tmp = () => mkdtempSync(join(tmpdir(), "codehost-registry-"));
+
+describe("daemon presence", () => {
+  test("round-trips while the pid is alive; cleared file -> null", () => {
+    const file = join(tmp(), "daemon.json");
+    const p = { pid: process.pid, root: "/Users/x", token: "Str0ng-Token-99", startedAt: 1 };
+    writeDaemonPresence(p, file);
+    expect(liveDaemon(file)).toEqual(p);
+    clearDaemonPresence(file);
+    expect(liveDaemon(file)).toBeNull();
+  });
+
+  test("a dead pid (stale kill -9 leftover) reads as no daemon", () => {
+    const file = join(tmp(), "daemon.json");
+    writeDaemonPresence({ pid: 99999999, root: "/x", token: "t0k-En-Stronk", startedAt: 1 }, file);
+    expect(liveDaemon(file)).toBeNull();
+  });
+
+  test("garbage file reads as no daemon", () => {
+    const file = join(tmp(), "daemon.json");
+    writeFileSync(file, "not json");
+    expect(liveDaemon(file)).toBeNull();
+  });
+});
+
+describe("workspace registry", () => {
+  test("register is idempotent; missing dirs are filtered on read", () => {
+    const dir = tmp();
+    const file = join(dir, "workspaces.json");
+    const ws = join(dir, "proj");
+    mkdirSync(ws);
+    registerWorkspace(ws, file);
+    registerWorkspace(ws, file);
+    registerWorkspace(join(dir, "gone"), file); // never created on disk
+    const got = readRegisteredWorkspaces(file);
+    expect(got).toHaveLength(1);
+    expect(got[0].path).toBe(ws);
+  });
+});