@vincentkoc/multicodex 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1560 @@
+#!/usr/bin/env node
+
+// packages/cli/src/index.ts
+import { execFile } from "node:child_process";
+import path6 from "node:path";
+import { promisify } from "node:util";
+
+// packages/cli/src/builder.ts
+import { spawn as spawn2 } from "node:child_process";
+import path2 from "node:path";
+
+// packages/protocol/src/index.ts
+var protocolVersion = 1;
+function requiredPolicyForCommand(kind) {
+  switch (kind) {
+    case "suggest":
+    case "request_status":
+      return "suggest";
+    case "start_followup":
+    case "steer_active_turn":
+    case "request_interrupt":
+      return "steer";
+  }
+}
+function policyAllows(policy, command2) {
+  const rank = { observe: 0, suggest: 1, steer: 2 };
+  return rank[policy] >= rank[requiredPolicyForCommand(command2)];
+}
+function createLaneEvent(input) {
+  return {
+    ...input,
+    version: protocolVersion,
+    id: input.id ?? crypto.randomUUID(),
+    at: input.at ?? Date.now()
+  };
+}
+
+// packages/cli/src/app-server.ts
+import { spawn } from "node:child_process";
+import net from "node:net";
+var CodexAppServerClient = class {
+  endpoint;
+  socket = null;
+  nextRequestId = 1;
+  pending = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Set();
+  constructor(endpoint) {
+    this.endpoint = endpoint;
+  }
+  async connect(timeoutMs = 15e3) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError = new Error("app-server connection timed out");
+    while (Date.now() < deadline) {
+      try {
+        await this.open();
+        await this.request("initialize", {
+          clientInfo: { name: "multicodex-alpha", title: "MultiCodex Alpha", version: "0.1.0" },
+          capabilities: { experimentalApi: true }
+        });
+        this.notify("initialized", {});
+        return;
+      } catch (cause) {
+        lastError = cause instanceof Error ? cause : new Error(String(cause));
+        this.socket?.close();
+        this.socket = null;
+        await delay(150);
+      }
+    }
+    throw lastError;
+  }
+  onNotification(handler) {
+    this.notificationHandlers.add(handler);
+    return () => this.notificationHandlers.delete(handler);
+  }
+  async startThread(cwd) {
+    const result = await this.request("thread/start", {
+      cwd,
+      developerInstructions: "You are a builder lane in a MultiCodex room. Keep user-visible progress concise and continue to follow local approvals."
+    });
+    const threadId = result.thread?.id;
+    if (!threadId) throw new Error("Codex app-server did not return a thread id");
+    return threadId;
+  }
+  async resumeThread(threadId) {
+    await this.request("thread/resume", {
+      threadId,
+      excludeTurns: true
+    });
+  }
+  async startTurn(threadId, text2) {
+    const result = await this.request("turn/start", {
+      threadId,
+      input: [{ type: "text", text: text2, text_elements: [] }]
+    });
+    const turnId = result.turn?.id;
+    if (!turnId) throw new Error("Codex app-server did not return a turn id");
+    return turnId;
+  }
+  async steer(threadId, turnId, text2) {
+    await this.request("turn/steer", {
+      threadId,
+      expectedTurnId: turnId,
+      input: [{ type: "text", text: text2, text_elements: [] }]
+    });
+  }
+  async interrupt(threadId, turnId) {
+    await this.request("turn/interrupt", { threadId, turnId });
+  }
+  close() {
+    const socket = this.socket;
+    this.socket = null;
+    socket?.close();
+    for (const pending of this.pending.values()) {
+      pending.reject(new Error("Codex app-server connection closed"));
+    }
+    this.pending.clear();
+  }
+  async open() {
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket(this.endpoint);
+      const timer = setTimeout(() => {
+        socket.close();
+        reject(new Error("Codex app-server connection timed out"));
+      }, 2e3);
+      socket.addEventListener("open", () => {
+        clearTimeout(timer);
+        this.socket = socket;
+        resolve();
+      });
+      socket.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error("Codex app-server is not ready"));
+      });
+      socket.addEventListener("message", (event) => this.receive(String(event.data)));
+      socket.addEventListener("close", () => {
+        if (this.socket === socket) this.close();
+      });
+    });
+  }
+  request(method, params) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("Codex app-server is not connected"));
+    }
+    const id = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      this.socket.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+    });
+  }
+  notify(method, params) {
+    this.socket?.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+  }
+  receive(raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (typeof message.id === "number" && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      if (message.error)
+        pending.reject(new Error(message.error.message ?? "app-server request failed"));
+      else pending.resolve(message.result);
+      return;
+    }
+    if (message.method) {
+      const notification = { method: message.method, params: message.params ?? {} };
+      for (const handler of this.notificationHandlers) handler(notification);
+    }
+  }
+};
+async function startCodexAppServer(codexPath = "codex") {
+  const port = await freePort();
+  const endpoint = `ws://127.0.0.1:${port}`;
+  const child = spawn(codexPath, ["app-server", "--listen", endpoint], {
+    stdio: ["ignore", "ignore", "pipe"]
+  });
+  let recentError = "";
+  child.stderr?.on("data", (chunk) => {
+    recentError = `${recentError}${String(chunk)}`.slice(-4e3);
+  });
+  await Promise.race([
+    delay(100),
+    new Promise(
+      (_, reject) => child.once(
+        "exit",
+        (code) => reject(new Error(`Codex app-server exited (${code ?? "signal"}): ${recentError}`))
+      )
+    )
+  ]);
+  return {
+    endpoint,
+    child,
+    stop: () => {
+      if (!child.killed) child.kill("SIGTERM");
+    }
+  };
+}
+async function freePort() {
+  return await new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.unref();
+    server.once("error", reject);
+    server.listen({ host: "127.0.0.1", port: 0 }, () => {
+      const address = server.address();
+      const port = typeof address === "object" && address ? address.port : 0;
+      server.close(() => port ? resolve(port) : reject(new Error("failed to allocate port")));
+    });
+  });
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+// packages/cli/src/builder-state.ts
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+var BuilderStateStore = class {
+  statePath;
+  savePromise = Promise.resolve();
+  constructor(input) {
+    this.statePath = input.statePath ?? path.join(
+      input.repo,
+      ".multicodex-alpha",
+      "lanes",
+      `${safeName(input.displayName)}-${digest(normalizeServer(input.server))}.json`
+    );
+  }
+  async load() {
+    try {
+      const state = JSON.parse(await fs.readFile(this.statePath, "utf8"));
+      return state.version === 1 ? state : null;
+    } catch (cause) {
+      const code = cause && typeof cause === "object" && "code" in cause ? cause.code : null;
+      if (code === "ENOENT") return null;
+      throw cause;
+    }
+  }
+  async save(state) {
+    const snapshot = `${JSON.stringify(state, null, 2)}
+`;
+    this.savePromise = this.savePromise.then(async () => {
+      await fs.mkdir(path.dirname(this.statePath), { recursive: true, mode: 448 });
+      const temporary = `${this.statePath}.${process.pid}.tmp`;
+      await fs.writeFile(temporary, snapshot, { mode: 384 });
+      await fs.rename(temporary, this.statePath);
+    });
+    await this.savePromise;
+  }
+  async clear() {
+    await this.savePromise;
+    await fs.rm(this.statePath, { force: true });
+  }
+};
+function normalizeServer(server) {
+  return parseRoomEndpoint(server).server;
+}
+function parseRoomEndpoint(server) {
+  const url = new URL(server);
+  const fragment = new URLSearchParams(url.hash.replace(/^#/, ""));
+  const inviteToken = url.searchParams.get("invite") ?? fragment.get("invite") ?? void 0;
+  url.searchParams.delete("invite");
+  url.hash = "";
+  return { server: url.toString().replace(/\/$/, ""), inviteToken };
+}
+function digest(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+function safeName(value) {
+  return value.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-|-$/g, "") || "builder";
+}
+
+// packages/cli/src/builder.ts
+var BuilderBridge = class {
+  input;
+  stateStore;
+  inviteToken;
+  roomId = "";
+  laneId = "";
+  token = "";
+  sequence = 0;
+  commandSequence = 0;
+  threadId = "";
+  activeTurnId = null;
+  spool = [];
+  client = null;
+  appServerStop = null;
+  tuiChild = null;
+  stopping = false;
+  waitingForTuiThread = false;
+  pendingTuiThreadId = null;
+  attachingTuiThread = false;
+  persistenceError = null;
+  activity = new ActivityDeltaBuffer();
+  stopped;
+  resolveStopped = null;
+  constructor(input) {
+    const endpoint = parseRoomEndpoint(input.server);
+    this.input = {
+      ...input,
+      server: endpoint.server,
+      repo: path2.resolve(input.repo)
+    };
+    this.inviteToken = endpoint.inviteToken;
+    this.stopped = new Promise((resolve) => {
+      this.resolveStopped = resolve;
+    });
+    this.stateStore = new BuilderStateStore({
+      repo: this.input.repo,
+      server: this.input.server,
+      displayName: this.input.displayName,
+      statePath: this.input.statePath
+    });
+  }
+  async run() {
+    await this.joinOrResume();
+    const appServer = await startCodexAppServer(this.input.codexPath);
+    this.appServerStop = appServer.stop;
+    this.client = new CodexAppServerClient(appServer.endpoint);
+    await this.client.connect();
+    this.client.onNotification((notification) => this.receiveNotification(notification));
+    this.emit("lane.connected", `local bridge connected (${this.input.policy})`, {
+      endpoint: "loopback"
+    });
+    if (this.threadId) {
+      try {
+        await this.client.resumeThread(this.threadId);
+        this.emit("lane.thread_attached", "persisted Codex thread resumed", {
+          threadId: this.threadId,
+          codexEndpoint: appServer.endpoint
+        });
+      } catch {
+        this.threadId = "";
+        this.emit("lane.status", "persisted Codex thread unavailable; starting a new thread");
+      }
+    }
+    if (!this.threadId && this.input.noTui) {
+      this.threadId = await this.client.startThread(this.input.repo);
+      this.emit("lane.thread_attached", "headless Codex thread attached", {
+        threadId: this.threadId,
+        codexEndpoint: appServer.endpoint
+      });
+    } else if (!this.threadId) {
+      this.waitingForTuiThread = true;
+    }
+    await this.flush();
+    const poll = setInterval(() => void this.tick(), 700);
+    try {
+      if (this.input.noTui && this.input.prompt) {
+        await this.client.startTurn(this.threadId, this.input.prompt);
+      }
+      if (this.input.noTui) await this.stopped;
+      else await this.runTui(appServer.endpoint);
+    } finally {
+      clearInterval(poll);
+      this.flushActivity();
+      this.emit("lane.disconnected", "local Codex TUI disconnected");
+      await this.flush().catch(() => void 0);
+      this.stop();
+    }
+  }
+  stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    this.resolveStopped?.();
+    this.resolveStopped = null;
+    this.client?.close();
+    this.appServerStop?.();
+    if (this.tuiChild && !this.tuiChild.killed) this.tuiChild.kill("SIGTERM");
+  }
+  async joinOrResume() {
+    if (this.input.fresh) await this.stateStore.clear();
+    const restored = this.input.fresh ? null : await this.stateStore.load();
+    if (restored && this.matches(restored)) {
+      this.restore(restored);
+      const response2 = await fetch(
+        new URL(`/api/lanes/${encodeURIComponent(this.laneId)}/resume`, this.input.server),
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${this.token}`
+          },
+          body: JSON.stringify({
+            displayName: this.input.displayName,
+            repo: this.input.repo,
+            policy: this.input.policy
+          })
+        }
+      );
+      const payload2 = await response2.json();
+      if (response2.ok) {
+        this.roomId = payload2.room.id;
+        this.sequence = Math.max(this.sequence, payload2.lane.lastEventSequence);
+        this.spool = this.spool.filter(
+          (event) => event.roomId === this.roomId && event.laneId === this.laneId && event.sequence > payload2.lane.lastEventSequence
+        );
+        await this.persistState();
+        return;
+      }
+      if (![401, 404, 410].includes(response2.status)) {
+        throw new Error(payload2.error ?? `lane resume failed (${response2.status})`);
+      }
+      await this.stateStore.clear();
+      this.reset();
+    }
+    const response = await fetch(new URL("/api/join", this.input.server), {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...this.inviteToken ? { authorization: `Bearer ${this.inviteToken}` } : {}
+      },
+      body: JSON.stringify({
+        displayName: this.input.displayName,
+        repo: this.input.repo,
+        policy: this.input.policy
+      })
+    });
+    const payload = await response.json();
+    if (!response.ok) throw new Error(payload.error ?? `join failed (${response.status})`);
+    this.roomId = payload.room.id;
+    this.laneId = payload.lane.id;
+    this.token = payload.token;
+    await this.persistState();
+  }
+  async tick() {
+    if (this.stopping) return;
+    await this.attachPendingTuiThread().catch(() => void 0);
+    await this.flush().catch(() => void 0);
+    await this.pollCommands().catch(() => void 0);
+  }
+  emit(kind, summary, payload) {
+    this.sequence += 1;
+    this.spool.push(
+      createLaneEvent({
+        roomId: this.roomId,
+        laneId: this.laneId,
+        sequence: this.sequence,
+        kind,
+        summary: redact(summary, this.input.repo),
+        payload: payload ? redactObject(payload, this.input.repo) : void 0
+      })
+    );
+    this.schedulePersist();
+  }
+  async flush() {
+    if (this.persistenceError) throw this.persistenceError;
+    if (!this.spool.length) return;
+    await this.persistState();
+    const response = await fetch(
+      new URL(`/api/lanes/${encodeURIComponent(this.laneId)}/events`, this.input.server),
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.token}`
+        },
+        body: JSON.stringify({ events: this.spool })
+      }
+    );
+    const payload = await response.json();
+    this.stopIfRevoked(response, payload.error);
+    if (!response.ok) throw new Error(payload.error ?? `event flush failed (${response.status})`);
+    this.spool = this.spool.filter((event) => event.sequence > (payload.ackSequence ?? 0));
+    await this.persistState();
+  }
+  async pollCommands() {
+    const url = new URL(
+      `/api/lanes/${encodeURIComponent(this.laneId)}/commands`,
+      this.input.server
+    );
+    url.searchParams.set("after", String(this.commandSequence));
+    const response = await fetch(url, { headers: { authorization: `Bearer ${this.token}` } });
+    const payload = await response.json();
+    this.stopIfRevoked(response, payload.error);
+    if (!response.ok) throw new Error(payload.error ?? `command poll failed (${response.status})`);
+    for (const command2 of payload.commands ?? []) {
+      this.commandSequence = Math.max(this.commandSequence, command2.sequence);
+      await this.persistState();
+      await this.handleCommand(command2);
+    }
+  }
+  async handleCommand(command2) {
+    let result = "accepted";
+    let detail = "";
+    try {
+      if (command2.expiresAt < Date.now()) result = "expired";
+      else if (!policyAllows(this.input.policy, command2.kind)) result = "rejected_policy";
+      else if (!this.client) result = "failed";
+      else {
+        switch (command2.kind) {
+          case "suggest":
+            process.stdout.write(`
+[multicodex conductor suggestion] ${command2.text}
+`);
+            break;
+          case "request_status":
+            this.emit("lane.status", `conductor requested status: ${command2.text}`);
+            break;
+          case "start_followup":
+            await this.client.startTurn(this.threadId, command2.text);
+            break;
+          case "steer_active_turn":
+            if (!this.activeTurnId) {
+              result = "failed";
+              detail = "no active turn";
+            } else await this.client.steer(this.threadId, this.activeTurnId, command2.text);
+            break;
+          case "request_interrupt":
+            if (!this.activeTurnId) {
+              result = "failed";
+              detail = "no active turn";
+            } else await this.client.interrupt(this.threadId, this.activeTurnId);
+            break;
+        }
+      }
+    } catch (cause) {
+      result = "failed";
+      detail = cause instanceof Error ? cause.message : String(cause);
+    }
+    this.emit("command.result", `${command2.kind}: ${result}${detail ? ` (${detail})` : ""}`, {
+      commandId: command2.id,
+      result
+    });
+    await this.flush();
+  }
+  stopIfRevoked(response, detail) {
+    if (response.status !== 410 || this.stopping) return;
+    process.stderr.write(`
+[multicodex] ${detail || "lane removed by host"}
+`);
+    this.stop();
+  }
+  receiveNotification(notification) {
+    const params = notification.params;
+    switch (notification.method) {
+      case "thread/started": {
+        if (this.waitingForTuiThread) this.captureTuiThread(object(params.thread));
+        break;
+      }
+      case "turn/started": {
+        this.flushActivity();
+        const turn = object(params.turn);
+        this.activeTurnId = text(turn.id);
+        this.emit("turn.started", "Codex turn started", { turnId: this.activeTurnId });
+        break;
+      }
+      case "turn/completed": {
+        this.flushActivity();
+        const turn = object(params.turn);
+        const turnId = text(turn.id);
+        this.emit("turn.completed", `Codex turn ${JSON.stringify(turn.status)}`, { turnId });
+        if (turnId === this.activeTurnId) this.activeTurnId = null;
+        break;
+      }
+      case "item/agentMessage/delta":
+        this.activity.append("agent.message", params.delta);
+        break;
+      case "item/plan/delta":
+        this.activity.append("agent.plan", params.delta);
+        break;
+      case "item/started":
+        this.flushActivity();
+        this.itemEvent("started", object(params.item));
+        break;
+      case "item/completed":
+        this.flushActivity();
+        this.itemEvent("completed", object(params.item));
+        break;
+      default:
+        if (notification.method.includes("requestApproval")) {
+          this.emit("approval.requested", "local Codex approval requested");
+        }
+    }
+  }
+  flushActivity() {
+    for (const activity of this.activity.drain()) {
+      this.emit(activity.kind, activity.summary);
+    }
+  }
+  itemEvent(stage, item) {
+    const type = text(item.type) || "work";
+    const summary = text(item.command) || text(item.path) || text(item.name) || type;
+    if (/command/i.test(type)) {
+      this.emit(stage === "started" ? "command.started" : "command.completed", summary, { type });
+    } else if (/file/i.test(type)) this.emit("files.changed", summary, { type });
+  }
+  async runTui(endpoint) {
+    process.stdout.write(
+      `
+MultiCodex lane ready
+room: ${this.input.server}
+room view: ${this.participantViewUrl()}
+thread: attaching from normal TUI
+policy: ${this.input.policy}
+
+`
+    );
+    const args2 = this.threadId ? ["resume", "--remote", endpoint, "-C", this.input.repo, this.threadId] : ["--remote", endpoint, "-C", this.input.repo];
+    if (this.input.prompt) args2.push(this.input.prompt);
+    const child = spawn2(this.input.codexPath, args2, {
+      stdio: "inherit"
+    });
+    this.tuiChild = child;
+    try {
+      await waitForChild(child);
+    } finally {
+      this.tuiChild = null;
+    }
+  }
+  participantViewUrl() {
+    const url = new URL(this.input.server);
+    url.hash = new URLSearchParams({ lane: this.laneId, token: this.token }).toString();
+    return url.toString();
+  }
+  captureTuiThread(thread) {
+    if (!this.client || !this.waitingForTuiThread) return;
+    const threadId = text(thread.id);
+    const cwd = text(thread.cwd);
+    if (!threadId || path2.resolve(cwd) !== path2.resolve(this.input.repo)) return;
+    this.waitingForTuiThread = false;
+    this.threadId = threadId;
+    this.pendingTuiThreadId = threadId;
+    this.emit("lane.status", "normal Codex TUI ready; bridge attaches on first turn", { threadId });
+    void this.flush().catch(() => void 0);
+  }
+  async attachPendingTuiThread() {
+    if (!this.client || !this.pendingTuiThreadId || this.attachingTuiThread) return;
+    this.attachingTuiThread = true;
+    try {
+      await this.client.resumeThread(this.pendingTuiThreadId);
+      this.emit("lane.thread_attached", "normal Codex TUI thread attached", {
+        threadId: this.pendingTuiThreadId
+      });
+      this.pendingTuiThreadId = null;
+    } catch {
+    } finally {
+      this.attachingTuiThread = false;
+    }
+    await this.flush().catch(() => void 0);
+  }
+  matches(state) {
+    return normalizeServer(state.server) === this.input.server && path2.resolve(state.repo) === this.input.repo && state.displayName === this.input.displayName;
+  }
+  restore(state) {
+    this.roomId = state.roomId;
+    this.laneId = state.laneId;
+    this.token = state.token;
+    this.sequence = state.sequence;
+    this.commandSequence = state.commandSequence;
+    this.threadId = state.threadId;
+    this.spool = state.spool;
+  }
+  reset() {
+    this.roomId = "";
+    this.laneId = "";
+    this.token = "";
+    this.sequence = 0;
+    this.commandSequence = 0;
+    this.threadId = "";
+    this.spool = [];
+  }
+  schedulePersist() {
+    void this.persistState().catch((cause) => {
+      this.persistenceError = cause instanceof Error ? cause : new Error(String(cause));
+    });
+  }
+  async persistState() {
+    if (!this.roomId || !this.laneId || !this.token) return;
+    await this.stateStore.save({
+      version: 1,
+      server: this.input.server,
+      roomId: this.roomId,
+      laneId: this.laneId,
+      token: this.token,
+      displayName: this.input.displayName,
+      repo: this.input.repo,
+      policy: this.input.policy,
+      sequence: this.sequence,
+      commandSequence: this.commandSequence,
+      threadId: this.threadId,
+      spool: this.spool
+    });
+  }
+};
+var ActivityDeltaBuffer = class {
+  chunks = /* @__PURE__ */ new Map();
+  append(kind, delta) {
+    const chunk = text(delta);
+    if (!chunk) return;
+    const chunks = this.chunks.get(kind) ?? [];
+    chunks.push(chunk);
+    this.chunks.set(kind, chunks);
+  }
+  drain() {
+    const events = [];
+    for (const [kind, chunks] of this.chunks) {
+      const summary = chunks.join("").trim();
+      if (summary) events.push({ kind, summary });
+    }
+    this.chunks.clear();
+    return events;
+  }
+};
+function object(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function redact(value, repo) {
+  return value.replaceAll(path2.resolve(repo), "<repo>").slice(0, 2e3);
+}
+function redactObject(value, repo) {
+  return JSON.parse(redact(JSON.stringify(value), repo));
+}
+async function waitForChild(child) {
+  await new Promise((resolve, reject) => {
+    child.once("exit", (code, signal) => {
+      if (code === 0 || signal) resolve();
+      else reject(new Error(`Codex TUI exited with ${code}`));
+    });
+    child.once("error", reject);
+  });
+}
+
+// packages/cli/src/codex-path.ts
+import fs2 from "node:fs/promises";
+import path3 from "node:path";
+async function resolveUserCodexPath(input) {
+  if (input?.explicit) return input.explicit;
+  const platform = input?.platform ?? process.platform;
+  const names = platform === "win32" ? ["codex.cmd", "codex.exe", "codex.bat", "codex"] : ["codex"];
+  for (const directory of (input?.pathValue ?? process.env.PATH ?? "").split(path3.delimiter)) {
+    if (!directory || isPackageBin(directory)) continue;
+    for (const name of names) {
+      const candidate = path3.join(directory, name);
+      try {
+        await fs2.access(candidate, fs2.constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function isPackageBin(directory) {
+  return /(^|[/\\])node_modules[/\\]\.bin[/\\]?$/.test(directory);
+}
+
+// packages/cli/src/conductor.ts
+import path4 from "node:path";
+import {
+  createAcpRuntime,
+  createAgentRegistry,
+  createRuntimeStore
+} from "acpx/runtime";
+var LocalConductor = class {
+  store;
+  runtime;
+  handle = null;
+  queue = Promise.resolve();
+  constructor(store, input) {
+    this.store = store;
+    this.runtime = createAcpRuntime({
+      cwd: input.repo,
+      sessionStore: createRuntimeStore({ stateDir: path4.join(input.stateDir, "acpx") }),
+      agentRegistry: createAgentRegistry(),
+      permissionMode: "deny-all",
+      nonInteractivePermissions: "deny",
+      timeoutMs: 18e4
+    });
+  }
+  async initialize() {
+    this.handle = await this.runtime.ensureSession({
+      sessionKey: `multicodex:${this.store.snapshot().id}:conductor`,
+      agent: "codex",
+      mode: "persistent",
+      sessionOptions: {
+        systemPrompt: {
+          append: "You are the conductor for a local-first MultiCodex room. Be concise. Keep orchestration visible. Never request or approve arbitrary shell access. Participants retain local authority."
+        }
+      }
+    });
+    await this.store.addConductorMessage("system", "host-local ACPx conductor ready");
+  }
+  message(text2) {
+    return this.enqueue(async () => {
+      const response = await this.turn(
+        `Room snapshot:
+${compactSnapshot(this.store.snapshot())}
+
+Host message:
+${text2}
+
+Respond to the room concisely.`
+      );
+      await this.store.addConductorMessage("conductor", response || "acknowledged");
+    });
+  }
+  steer(laneId, text2) {
+    return this.command(laneId, "steer_active_turn", text2);
+  }
+  command(laneId, kind, text2) {
+    return this.enqueue(async () => {
+      const response = await this.turn(
+        `Room snapshot:
+${compactSnapshot(this.store.snapshot())}
+
+The host asks you to deliver the visible ${kind} action to lane ${laneId}:
+${text2}
+
+Briefly state why this action helps.`
+      );
+      if (response) await this.store.addConductorMessage("conductor", response);
+      await this.store.queueCommand(laneId, kind, text2);
+    });
+  }
+  enqueue(run) {
+    this.queue = this.queue.then(run, run);
+    return this.queue;
+  }
+  async turn(text2) {
+    if (!this.handle) throw new Error("conductor is not initialized");
+    const turn = this.runtime.startTurn({
+      handle: this.handle,
+      text: text2,
+      mode: "prompt",
+      requestId: crypto.randomUUID(),
+      timeoutMs: 18e4
+    });
+    let output = "";
+    for await (const event of turn.events) {
+      if (event.type === "text_delta" && event.stream !== "thought") output += event.text;
+    }
+    const result = await turn.result;
+    if (result.status === "failed") throw new Error(result.error.message);
+    return output.trim();
+  }
+};
+function compactSnapshot(snapshot) {
+  return JSON.stringify({
+    room: { id: snapshot.id, title: snapshot.title, repo: snapshot.repo },
+    lanes: snapshot.lanes.map((lane) => ({
+      id: lane.id,
+      name: lane.displayName,
+      policy: lane.policy,
+      connected: lane.connected,
+      status: lane.status,
+      activeTurn: lane.currentTurnId,
+      removed: Boolean(lane.removedAt)
+    })),
+    recentEvents: snapshot.events.slice(-12).map((event) => ({
+      laneId: event.laneId,
+      kind: event.kind,
+      summary: event.summary
+    }))
+  });
+}
+
+// packages/cli/src/local-room.ts
+import fs3 from "node:fs/promises";
+import http from "node:http";
+import path5 from "node:path";
+
+// packages/cli/src/ui.ts
+function localRoomHtml() {
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>MultiCodex control room</title><style>
+:root{font-family:"Avenir Next","Segoe UI",sans-serif;color:#19211e;background:#e9ede8;--paper:#fbfcf8;--soft:#eef2ec;--line:#d4dbd4;--ink-soft:#65716b;--red:#dd503c;--green:#16825d;--blue:#3267d6;--yellow:#d59b18;--terminal:#171d1a;--terminal-line:#2c3731;--terminal-copy:#d9e4dc;--role:#16825d}*{box-sizing:border-box}body{margin:0;min-width:320px;min-height:100vh}button,input,select{font:inherit;letter-spacing:0}button{cursor:pointer}button:disabled{cursor:not-allowed;opacity:.42}h1,h2,h3,p{margin:0}.mono,code,.eyebrow,.status,.event-time,.event-kind,.policy,.terminal-meta{font-family:"SFMono-Regular",Consolas,"Liberation Mono",monospace}.topbar{align-items:center;background:var(--paper);border-bottom:1px solid var(--line);display:grid;gap:18px;grid-template-columns:auto minmax(180px,1fr) auto;padding:0 18px;min-height:64px;position:sticky;top:0;z-index:10}.brand{align-items:center;display:flex;gap:10px}.brand-mark{background:#19211e;color:#f9fbf7;display:grid;font-weight:850;height:34px;place-items:center;position:relative;width:34px}.brand-mark:after{background:var(--red);bottom:-3px;content:"";height:9px;position:absolute;right:-3px;width:9px}.brand strong{font-size:17px}.room-title{min-width:0}.room-title strong,.room-title span{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.room-title strong{font-size:13px}.room-title span{color:var(--ink-soft);font-size:10px;margin-top:2px}.top-actions{align-items:center;display:flex;gap:7px}.button,.icon-button{align-items:center;border:1px solid var(--line);border-radius:4px;display:inline-flex;justify-content:center}.button{background:var(--paper);font-size:12px;font-weight:700;gap:6px;min-height:34px;padding:0 11px}.button.primary{background:#19211e;border-color:#19211e;color:#f9fbf7}.button.danger{background:#fff2ef;border-color:#efb8af;color:#9f3020}.button:hover,.icon-button:hover{border-color:#96a39b}.icon-button{background:var(--paper);color:#3d4943;font-size:17px;height:32px;padding:0;width:32px}.live-pill{align-items:center;color:var(--ink-soft);display:flex;font-size:10px;gap:7px;white-space:nowrap}.live-dot{background:var(--green);border-radius:50%;box-shadow:0 0 0 4px rgba(22,130,93,.1);height:7px;width:7px}.shell{display:grid;grid-template-columns:minmax(225px,260px) minmax(440px,1fr) minmax(300px,365px);margin:0 auto;max-width:1900px;min-height:calc(100vh - 64px)}.team,.conductor{background:var(--paper);height:calc(100vh - 64px);position:sticky;top:64px}.team{border-right:1px solid var(--line);display:flex;flex-direction:column}.conductor{border-left:1px solid var(--line);display:grid;grid-template-rows:auto minmax(160px,1fr) auto auto;min-width:0}.panel-heading{align-items:center;border-bottom:1px solid var(--line);display:flex;justify-content:space-between;min-height:66px;padding:12px 14px}.eyebrow{color:var(--ink-soft);display:block;font-size:9px;font-weight:700;text-transform:uppercase}.panel-heading h2{font-size:15px;margin-top:3px}.conductor-seat{align-items:center;background:#e6eee8;border-bottom:1px solid var(--line);display:grid;gap:9px;grid-template-columns:auto 1fr auto;padding:11px 14px}.avatar{align-items:center;background:var(--role);border-radius:50%;color:#fff;display:flex;flex:0 0 auto;font-size:10px;font-weight:800;height:31px;justify-content:center;width:31px}.conductor-seat .avatar{background:#19211e}.seat-copy{display:grid;min-width:0}.person .seat-copy{background:transparent;border:0;padding:0;text-align:left}.seat-copy strong{font-size:11px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.seat-copy span{color:var(--ink-soft);font-size:9px;margin-top:2px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.presence{background:#a5aea9;border-radius:50%;height:7px;width:7px}.presence.on{background:var(--green);box-shadow:0 0 0 3px rgba(22,130,93,.1)}.people{flex:1;overflow:auto}.person{align-items:center;background:transparent;border:0;border-bottom:1px solid var(--line);border-left:3px solid var(--role);display:grid;gap:8px;grid-template-columns:auto minmax(0,1fr) auto;padding:10px 9px;text-align:left;width:100%}.person:hover,.person.selected{background:#eef3ee}.person.removed{filter:saturate(.25);opacity:.65}.person-actions{display:flex;gap:3px}.person-actions .icon-button{height:25px;width:25px}.policy{background:#e4ebe5;color:#526059;display:inline-block;font-size:8px;margin-top:5px;padding:2px 4px;width:max-content}.add-person{border-top:1px solid var(--line);display:grid;gap:7px;padding:11px}.add-person-row{display:grid;gap:6px;grid-template-columns:minmax(0,1fr) 86px}.field,input,select{background:#fff;border:1px solid var(--line);border-radius:4px;color:inherit;min-width:0;outline:none}.field,input,select{height:36px;padding:0 9px}input:focus,select:focus{border-color:var(--blue);box-shadow:0 0 0 2px rgba(50,103,214,.12)}.stage{min-width:0;padding:18px}.stage-heading{align-items:flex-start;display:flex;gap:16px;justify-content:space-between;margin-bottom:14px}.stage-heading h1{font-size:clamp(19px,2.1vw,29px);line-height:1.05;margin-top:5px}.stage-heading p{color:var(--ink-soft);font-size:10px;margin-top:7px}.lane-state{align-items:center;background:var(--paper);border:1px solid var(--line);display:flex;gap:8px;padding:7px 9px}.lane-state .presence{background:var(--yellow)}.lane-state .presence.on{background:var(--green)}.terminal{background:var(--terminal);border:1px solid #111613;box-shadow:9px 9px 0 rgba(25,33,30,.1);color:var(--terminal-copy);min-height:470px;overflow:hidden}.terminal-bar{align-items:center;background:#222b26;border-bottom:1px solid var(--terminal-line);display:grid;gap:10px;grid-template-columns:auto minmax(0,1fr) auto;padding:10px 12px}.traffic{display:flex;gap:5px}.traffic i{background:#617068;border-radius:50%;height:7px;width:7px}.traffic i:first-child{background:var(--red)}.traffic i:nth-child(2){background:var(--yellow)}.traffic i:last-child{background:var(--green)}.terminal-title{color:#aebdb3;font-size:10px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.terminal-meta{color:#819188;font-size:8px}.terminal-stream{height:min(66vh,680px);min-height:420px;overflow:auto;padding:8px 0 28px}.terminal-empty{align-items:center;color:#78877e;display:flex;font-size:11px;justify-content:center;min-height:390px;padding:35px;text-align:center}.event{border-bottom:1px solid rgba(255,255,255,.035);display:grid;gap:10px;grid-template-columns:62px 116px minmax(0,1fr);padding:8px 12px}.event:hover{background:rgba(255,255,255,.025)}.event-time{color:#738179;font-size:8px}.event-kind{color:#84a490;font-size:8px;overflow-wrap:anywhere}.event-copy{color:#d3ded6;font-size:11px;line-height:1.5;overflow-wrap:anywhere;white-space:pre-wrap}.event.agent-message .event-copy{color:#f1f6f2}.event.agent-plan .event-kind{color:#dbb95d}.event.command-started .event-kind,.event.command-completed .event-kind{color:#77a8ee}.event.files-changed .event-kind{color:#e28d7f}.event.turn-started .event-kind,.event.turn-completed .event-kind{color:#71c99e}.event.command-result .event-kind{color:#d5a557}.cursor-line{align-items:center;color:#91a198;display:flex;font:10px "SFMono-Regular",Consolas,monospace;gap:8px;padding:12px}.cursor{animation:blink 1s steps(1,end) infinite;background:#72bd93;height:13px;width:7px}@keyframes blink{50%{opacity:0}}.activity-band{display:grid;gap:8px;grid-template-columns:repeat(3,minmax(0,1fr));margin-top:18px}.metric{border-top:3px solid var(--role);padding:9px 2px}.metric strong{display:block;font-size:16px}.metric span{color:var(--ink-soft);font-size:9px}.messages{overflow:auto;padding:8px 12px}.message{border-bottom:1px solid #e6eae5;padding:11px 3px}.message.conductor-message{background:#eaf1eb;border-left:3px solid var(--green);margin:5px -4px;padding:11px 8px}.message strong{font-size:9px;text-transform:uppercase}.message p{font-size:11px;line-height:1.45;margin-top:4px;white-space:pre-wrap}.message time{color:var(--ink-soft);font-size:8px;margin-left:5px}.form{border-top:1px solid var(--line);display:grid;gap:7px;padding:11px}.command-grid{display:grid;gap:6px;grid-template-columns:1fr 1fr}.form input,.form select{font-size:11px}.form .button{width:100%}.connection{border-top:1px solid var(--line);color:var(--ink-soft);font-size:9px;padding:9px 12px}.readonly{background:#fff3d8;border-bottom:1px solid #e6cf91;color:#76580a;font-size:10px;padding:9px 12px}.toast{background:#19211e;bottom:16px;color:#fff;font-size:11px;left:50%;opacity:0;padding:9px 12px;pointer-events:none;position:fixed;transform:translate(-50%,10px);transition:opacity .15s ease,transform .15s ease;z-index:30}.toast.show{opacity:1;transform:translate(-50%,0)}@media(max-width:1120px){.shell{grid-template-columns:230px minmax(0,1fr)}.conductor{border-left:0;border-top:1px solid var(--line);grid-column:1/-1;height:auto;position:static}.messages{max-height:320px}.terminal-stream{height:58vh}}@media(max-width:740px){.topbar{gap:9px;grid-template-columns:auto 1fr;padding:0 10px}.brand strong,.top-actions .button{display:none}.shell{display:block}.team,.conductor{height:auto;position:static}.team{border-right:0}.people{max-height:260px}.stage{padding:13px 10px}.stage-heading{align-items:flex-start;display:grid}.terminal{box-shadow:none}.terminal-stream{height:60vh;min-height:360px}.event{gap:5px;grid-template-columns:48px 88px minmax(0,1fr);padding:7px 8px}.activity-band{grid-template-columns:1fr 1fr 1fr}.command-grid{grid-template-columns:1fr}.top-actions{justify-self:end}.live-pill{display:none}}
+</style></head><body>
+<header class="topbar"><div class="brand"><span class="brand-mark">M</span><strong>multicodex</strong></div><div class="room-title"><strong id="room-title">loading room</strong><span id="room-meta">connecting to host-local room</span></div><div class="top-actions"><span class="live-pill"><i class="live-dot"></i><span id="top-status">connecting</span></span><button class="button" id="copy-invite">copy invite</button></div></header>
+<div class="shell"><aside class="team"><div class="panel-heading"><div><span class="eyebrow">team</span><h2 id="seat-count">0 active lanes</h2></div><button class="icon-button" id="quick-copy" title="copy invite command">+</button></div><div class="conductor-seat"><span class="avatar">AI</span><div class="seat-copy"><strong>conductor</strong><span>host-local coordination</span></div><i class="presence on"></i></div><div class="people" id="people"></div><form class="add-person" id="add-person"><span class="eyebrow">add a person</span><div class="add-person-row"><input name="name" placeholder="name" required maxlength="80"><select name="policy"><option value="suggest">suggest</option><option value="steer">steer</option><option value="observe">observe</option></select></div><button class="button primary">copy join command</button></form></aside>
+<main class="stage"><div class="stage-heading"><div><span class="eyebrow">live lane</span><h1 id="lane-title">waiting for a builder</h1><p id="lane-detail">copy an invite command to connect a normal local Codex TUI.</p></div><div class="lane-state"><i class="presence" id="lane-presence"></i><span class="status" id="lane-state">idle</span></div></div><section class="terminal"><div class="terminal-bar"><span class="traffic"><i></i><i></i><i></i></span><span class="terminal-title" id="terminal-title">multicodex://room/lane</span><span class="terminal-meta" id="terminal-meta">structured activity</span></div><div class="terminal-stream" id="terminal-stream"></div></section><section class="activity-band"><div class="metric" style="--role:var(--green)"><strong id="metric-active">0</strong><span>connected lanes</span></div><div class="metric" style="--role:var(--blue)"><strong id="metric-turns">0</strong><span>turns completed</span></div><div class="metric" style="--role:var(--yellow)"><strong id="metric-actions">0</strong><span>conductor actions</span></div></section></main>
+<aside class="conductor"><div class="panel-heading"><div><span class="eyebrow">conductor</span><h2>visible control</h2></div><span class="status" id="host-mode">host</span></div><div class="messages" id="messages"></div><form class="form" id="message-form"><input name="text" placeholder="message the conductor" required maxlength="2000"><button class="button primary">send to conductor</button></form><form class="form" id="command-form"><span class="eyebrow">coordinate selected lane</span><div class="command-grid"><select name="laneId" id="lane-select" required></select><select name="kind" id="kind-select"><option value="suggest">suggest</option><option value="request_status">request status</option><option value="start_followup">start follow-up</option><option value="steer_active_turn">steer active turn</option><option value="request_interrupt">interrupt active turn</option></select></div><input name="text" id="command-text" placeholder="what should the lane know or do?" required maxlength="2000"><button class="button">send visible action</button></form><div class="connection status" id="connection">connecting...</div></aside></div><div class="toast" id="toast"></div>
+<script>
+const esc=value=>String(value??'').replace(/[&<>"']/g,char=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[char]));
+const ui={roomTitle:document.querySelector('#room-title'),roomMeta:document.querySelector('#room-meta'),topStatus:document.querySelector('#top-status'),seatCount:document.querySelector('#seat-count'),people:document.querySelector('#people'),laneTitle:document.querySelector('#lane-title'),laneDetail:document.querySelector('#lane-detail'),lanePresence:document.querySelector('#lane-presence'),laneState:document.querySelector('#lane-state'),terminalTitle:document.querySelector('#terminal-title'),terminalMeta:document.querySelector('#terminal-meta'),terminalStream:document.querySelector('#terminal-stream'),messages:document.querySelector('#messages'),laneSelect:document.querySelector('#lane-select'),kindSelect:document.querySelector('#kind-select'),commandText:document.querySelector('#command-text'),connection:document.querySelector('#connection'),hostMode:document.querySelector('#host-mode'),metricActive:document.querySelector('#metric-active'),metricTurns:document.querySelector('#metric-turns'),metricActions:document.querySelector('#metric-actions'),toast:document.querySelector('#toast')};
+const roleColors=['#dd503c','#3267d6','#16825d','#d59b18','#835bb5'];
+const fragment=new URLSearchParams(location.hash.replace(/^#/,''));
+const hostToken=fragment.get('host')||sessionStorage.getItem('multicodex-host-token')||'';
+const laneToken=fragment.get('token')||sessionStorage.getItem('multicodex-lane-token')||'';
+const viewerLaneId=fragment.get('lane')||sessionStorage.getItem('multicodex-lane-id')||'';
+if(hostToken)sessionStorage.setItem('multicodex-host-token',hostToken);
+if(laneToken)sessionStorage.setItem('multicodex-lane-token',laneToken);
+if(viewerLaneId)sessionStorage.setItem('multicodex-lane-id',viewerLaneId);
+let snapshot=null,hostConfig=null,selectedLaneId='',refreshing=false;
+async function api(path,options={}){const headers={...(options.body?{'content-type':'application/json'}:{}),...(options.host&&hostToken?{authorization:'Bearer '+hostToken}:{}),...(options.lane&&laneToken?{authorization:'Bearer '+laneToken}:{})};const response=await fetch(path,{method:options.method||'GET',headers,body:options.body?JSON.stringify(options.body):undefined});const payload=await response.json();if(!response.ok)throw new Error(payload.error||response.statusText);return payload}
+function initials(name){return String(name||'?').split(/\\s+/).map(part=>part[0]).join('').slice(0,2).toUpperCase()}
+function shellQuote(value){const quote=String.fromCharCode(39),double=String.fromCharCode(34);return quote+String(value).replaceAll(quote,quote+double+quote+double+quote)+quote}
+function toast(message){ui.toast.textContent=message;ui.toast.classList.add('show');setTimeout(()=>ui.toast.classList.remove('show'),1700)}
+async function copy(value,message='copied'){await navigator.clipboard.writeText(value);toast(message)}
+function activeLanes(){return snapshot?snapshot.lanes.filter(lane=>!lane.removedAt):[]}
+function selectedLane(){const lanes=activeLanes();return lanes.find(lane=>lane.id===selectedLaneId)||lanes[0]||snapshot?.lanes[0]||null}
+function laneEvents(laneId){const source=(snapshot?.events||[]).filter(event=>event.laneId===laneId);const collapsed=[];for(const event of source){const previous=collapsed.at(-1);if(previous&&event.kind==='agent.message'&&previous.kind===event.kind){previous.summary+=event.summary;previous.at=event.at}else collapsed.push({...event})}return collapsed.slice(-100)}
+function eventClass(kind){return kind.replaceAll('.','-')}
+function eventLabel(kind){return kind.replace('agent.','ai.').replace('command.','cmd.').replace('turn.','turn.').replace('lane.','lane.').replace('files.changed','files')}
+function time(at){return new Date(at).toLocaleTimeString([],{hour:'2-digit',minute:'2-digit',second:'2-digit'})}
+function renderPeople(){const lanes=snapshot?.lanes||[];const active=lanes.filter(lane=>!lane.removedAt);ui.seatCount.textContent=active.length+' active '+(active.length===1?'lane':'lanes');ui.people.innerHTML=lanes.length?lanes.map((lane,index)=>'<div class="person '+(lane.id===selectedLaneId?'selected ':'')+(lane.removedAt?'removed':'')+'" style="--role:'+roleColors[index%roleColors.length]+'" data-lane="'+esc(lane.id)+'"><span class="avatar">'+esc(initials(lane.displayName))+'</span><button class="seat-copy" data-select="'+esc(lane.id)+'"><strong>'+esc(lane.displayName)+'</strong><span>'+esc(lane.status)+'</span><i class="policy">'+esc(lane.removedAt?'removed':lane.policy)+'</i></button><span class="person-actions">'+(!lane.removedAt&&hostToken?'<button class="icon-button" data-remove="'+esc(lane.id)+'" title="remove '+esc(lane.displayName)+'">x</button>':'')+'</span></div>').join(''):'<div class="terminal-empty">add a person to connect the first local Codex lane.</div>';ui.people.querySelectorAll('[data-select]').forEach(button=>button.onclick=()=>{selectedLaneId=button.dataset.select;render()});ui.people.querySelectorAll('[data-remove]').forEach(button=>button.onclick=()=>removeLane(button.dataset.remove))}
+function renderTerminal(){const lane=selectedLane();if(!lane){ui.laneTitle.textContent='waiting for a builder';ui.laneDetail.textContent='copy an invite command to connect a normal local Codex TUI.';ui.laneState.textContent='idle';ui.lanePresence.className='presence';ui.terminalStream.innerHTML='<div class="terminal-empty">no lane selected<br>the real Codex terminal stays on each participant machine.</div>';return}selectedLaneId=lane.id;ui.laneTitle.textContent=lane.displayName;ui.laneDetail.textContent=lane.repo+' \xB7 '+lane.policy+' policy \xB7 '+(lane.threadId?'thread '+lane.threadId:'thread pending');ui.laneState.textContent=lane.removedAt?'removed':lane.currentTurnId?'active turn':lane.connected?'connected':'disconnected';ui.lanePresence.className='presence '+(lane.connected&&!lane.removedAt?'on':'');ui.terminalTitle.textContent='multicodex://'+snapshot.id+'/'+lane.displayName.toLowerCase().replaceAll(/[^a-z0-9]+/g,'-');ui.terminalMeta.textContent=lane.policy+' \xB7 '+(lane.threadId?'attached':'pending');const events=laneEvents(lane.id);ui.terminalStream.innerHTML=(events.length?events.map(event=>'<div class="event '+eventClass(event.kind)+'"><time class="event-time">'+time(event.at)+'</time><code class="event-kind">'+esc(eventLabel(event.kind))+'</code><div class="event-copy">'+esc(event.summary)+'</div></div>').join(''):'<div class="terminal-empty">lane connected; waiting for meaningful Codex activity.</div>')+(lane.currentTurnId?'<div class="cursor-line"><span>&gt;</span><i class="cursor"></i><span>Codex turn in progress</span></div>':'');ui.terminalStream.scrollTop=ui.terminalStream.scrollHeight}
+function renderMessages(){const messages=snapshot?.conductorMessages||[];ui.messages.innerHTML=messages.length?messages.slice(-80).map(message=>'<div class="message '+(message.author==='conductor'?'conductor-message':'')+'"><strong>'+esc(message.authorName||message.author)+'</strong><time>'+time(message.at)+'</time><p>'+esc(message.body)+'</p></div>').join(''):'<div class="terminal-empty">message the conductor to begin visible coordination.</div>';ui.messages.scrollTop=ui.messages.scrollHeight}
+function renderControls(){const lanes=activeLanes();const previous=ui.laneSelect.value||selectedLaneId;ui.laneSelect.innerHTML=lanes.map(lane=>'<option value="'+esc(lane.id)+'">'+esc(lane.displayName)+'</option>').join('');ui.laneSelect.value=lanes.some(lane=>lane.id===previous)?previous:(lanes[0]?.id||'');const hostLocked=!hostToken;document.querySelectorAll('#add-person input,#add-person select,#add-person button,#command-form input,#command-form select,#command-form button,#copy-invite,#quick-copy').forEach(element=>element.disabled=hostLocked);document.querySelectorAll('#message-form input,#message-form button').forEach(element=>element.disabled=!hostToken&&!laneToken);const mode=hostToken?'host':laneToken?'participant':'observer';ui.hostMode.textContent=mode;ui.connection.textContent=(mode==='observer'?'read-only \xB7 ':'live \xB7 ')+new Date().toLocaleTimeString();ui.topStatus.textContent=mode==='host'?'host control':mode+' view'}
+function renderMetrics(){const events=snapshot?.events||[];ui.metricActive.textContent=String(activeLanes().filter(lane=>lane.connected).length);ui.metricTurns.textContent=String(events.filter(event=>event.kind==='turn.completed').length);ui.metricActions.textContent=String(events.filter(event=>event.kind==='command.result').length)}
+function render(){if(!snapshot)return;ui.roomTitle.textContent=snapshot.title;ui.roomMeta.textContent=snapshot.repo+' \xB7 '+snapshot.id;renderPeople();renderTerminal();renderMessages();renderControls();renderMetrics()}
+async function refresh(){if(refreshing)return;refreshing=true;try{snapshot=await api('/api/snapshot');if(hostToken&&!hostConfig)hostConfig=await api('/api/host/config',{host:true});if(!selectedLaneId)selectedLaneId=activeLanes()[0]?.id||'';render()}catch(error){ui.connection.textContent=error.message;ui.topStatus.textContent='offline'}finally{refreshing=false}}
+async function removeLane(laneId){const lane=snapshot.lanes.find(candidate=>candidate.id===laneId);if(!lane||!confirm('Remove '+lane.displayName+' and revoke this lane?'))return;await api('/api/lanes/'+encodeURIComponent(laneId),{method:'DELETE',host:true});toast(lane.displayName+' removed');await refresh()}
+function joinCommand(name='Builder',policy='suggest'){if(!hostConfig)return'';return hostConfig.joinCommand+' --name '+shellQuote(name)+' --policy '+policy}
+document.querySelector('#copy-invite').onclick=()=>copy(joinCommand(),'invite command copied');
+document.querySelector('#quick-copy').onclick=()=>copy(joinCommand(),'invite command copied');
+document.querySelector('#add-person').onsubmit=async event=>{event.preventDefault();const data=new FormData(event.currentTarget);await copy(joinCommand(String(data.get('name')),String(data.get('policy'))),'join command copied');event.currentTarget.querySelector('input').select()};
+document.querySelector('#message-form').onsubmit=async event=>{event.preventDefault();const data=new FormData(event.currentTarget);const path=hostToken?'/api/conductor/message':'/api/lanes/'+encodeURIComponent(viewerLaneId)+'/message';const headers=hostToken?{method:'POST',host:true,body:{text:data.get('text')}}:{method:'POST',body:{text:data.get('text')}};if(!hostToken)headers.lane=true;await api(path,headers);event.currentTarget.reset();toast('sent to room and conductor');await refresh()};
+document.querySelector('#command-form').onsubmit=async event=>{event.preventDefault();const data=new FormData(event.currentTarget);await api('/api/conductor/command',{method:'POST',host:true,body:{laneId:data.get('laneId'),kind:data.get('kind'),text:data.get('text')}});ui.commandText.value='';toast('visible action queued');await refresh()};
+ui.laneSelect.onchange=()=>{selectedLaneId=ui.laneSelect.value;render()};
+ui.kindSelect.onchange=()=>{ui.commandText.placeholder={suggest:'what should the lane know?',request_status:'what status do you need?',start_followup:'what should Codex do next?',steer_active_turn:'how should the active turn change?',request_interrupt:'why should the active turn stop?'}[ui.kindSelect.value]||'visible action'};
+setInterval(refresh,900);refresh();
+</script></body></html>`;
+}
+
+// packages/cli/src/local-room.ts
+var LocalRoomStore = class _LocalRoomStore {
+  statePath;
+  state;
+  savePromise = Promise.resolve();
+  constructor(statePath, state) {
+    this.statePath = statePath;
+    this.state = state;
+  }
+  static async create(input) {
+    await fs3.mkdir(input.stateDir, { recursive: true, mode: 448 });
+    const statePath = path5.join(input.stateDir, "room.json");
+    const state = {
+      version: protocolVersion,
+      id: `room_${crypto.randomUUID()}`,
+      title: input.title,
+      repo: input.repo,
+      createdAt: Date.now(),
+      lanes: [],
+      events: [],
+      conductorMessages: [],
+      commands: [],
+      eventIds: [],
+      hostToken: crypto.randomUUID(),
+      inviteToken: crypto.randomUUID()
+    };
+    const store = new _LocalRoomStore(statePath, state);
+    await store.save();
+    return store;
+  }
+  static async load(stateDir) {
+    const statePath = path5.join(stateDir, "room.json");
+    const state = JSON.parse(await fs3.readFile(statePath, "utf8"));
+    state.hostToken ||= crypto.randomUUID();
+    state.inviteToken ||= crypto.randomUUID();
+    for (const lane of state.lanes) lane.removedAt ??= null;
+    const store = new _LocalRoomStore(statePath, state);
+    await store.save();
+    return store;
+  }
+  snapshot() {
+    return {
+      version: this.state.version,
+      id: this.state.id,
+      title: this.state.title,
+      repo: publicRepoName(this.state.repo),
+      createdAt: this.state.createdAt,
+      lanes: this.state.lanes.map(({ token: _token, ...lane }) => ({
+        ...lane,
+        repo: publicRepoName(lane.repo)
+      })),
+      events: this.state.events.slice(-300),
+      conductorMessages: this.state.conductorMessages.slice(-100)
+    };
+  }
+  hostConfig(publicUrl) {
+    const inviteUrl = capabilityUrl(publicUrl, "invite", this.state.inviteToken);
+    return {
+      inviteUrl,
+      joinCommand: `npx --yes @vincentkoc/multicodex@latest join ${shellQuote(inviteUrl)} --repo .`,
+      activeLanes: this.state.lanes.filter((lane) => !lane.removedAt).length
+    };
+  }
+  hostUrl(publicUrl) {
+    return capabilityUrl(publicUrl, "host", this.state.hostToken);
+  }
+  inviteUrl(publicUrl) {
+    return capabilityUrl(publicUrl, "invite", this.state.inviteToken);
+  }
+  authorizeHost(token) {
+    return token === this.state.hostToken;
+  }
+  authorizeInvite(token) {
+    return token === this.state.inviteToken;
+  }
+  async join(input) {
+    const now = Date.now();
+    const lane = {
+      id: `lane_${crypto.randomUUID()}`,
+      token: crypto.randomUUID(),
+      displayName: input.displayName,
+      repo: input.repo,
+      policy: input.policy,
+      connected: false,
+      threadId: null,
+      currentTurnId: null,
+      lastEventSequence: 0,
+      lastCommandSequence: 0,
+      status: "joining",
+      joinedAt: now,
+      updatedAt: now,
+      removedAt: null
+    };
+    this.state.lanes.push(lane);
+    await this.save();
+    const { token, ...publicLane } = lane;
+    return { lane: publicLane, token };
+  }
+  async resumeLane(laneId, token, input) {
+    const lane = this.state.lanes.find(
+      (candidate) => candidate.id === laneId && candidate.token === token
+    );
+    if (!lane) throw new RoomError(401, "valid lane capability required");
+    if (lane.removedAt) throw new RoomError(410, "lane removed by host");
+    lane.displayName = input.displayName;
+    lane.repo = input.repo;
+    lane.policy = input.policy;
+    lane.updatedAt = Date.now();
+    lane.status = "reconnecting";
+    await this.save();
+    const { token: _token, ...publicLane } = lane;
+    return { lane: publicLane };
+  }
+  authorizeLane(laneId, token) {
+    return this.state.lanes.find(
+      (lane) => lane.id === laneId && lane.token === token && !lane.removedAt
+    ) ?? null;
+  }
+  async appendEvents(laneId, token, events) {
+    const lane = this.requireLane(laneId, token);
+    for (const event of events) {
+      if (event.version !== protocolVersion || event.roomId !== this.state.id || event.laneId !== lane.id) {
+        throw new RoomError(400, "invalid lane event envelope");
+      }
+      if (this.state.eventIds.includes(event.id) || event.sequence <= lane.lastEventSequence)
+        continue;
+      if (event.sequence !== lane.lastEventSequence + 1) {
+        throw new RoomError(409, `event gap: expected ${lane.lastEventSequence + 1}`);
+      }
+      this.state.events.push(event);
+      this.state.eventIds.push(event.id);
+      lane.lastEventSequence = event.sequence;
+      lane.updatedAt = event.at;
+      applyLaneEvent(lane, event);
+    }
+    this.state.events.splice(0, Math.max(0, this.state.events.length - 1e3));
+    this.state.eventIds.splice(0, Math.max(0, this.state.eventIds.length - 2e3));
+    await this.save();
+    return lane.lastEventSequence;
+  }
+  commandsAfter(laneId, token, after) {
+    this.requireLane(laneId, token);
+    return this.state.commands.filter(
+      (command2) => command2.laneId === laneId && command2.sequence > after
+    );
+  }
+  async queueCommand(laneId, kind, text2) {
+    const lane = this.state.lanes.find((candidate) => candidate.id === laneId);
+    if (!lane) throw new RoomError(404, "lane not found");
+    if (lane.removedAt) throw new RoomError(410, "lane removed by host");
+    if (!policyAllows(lane.policy, kind)) {
+      throw new RoomError(409, `${kind} requires ${requiredPolicyForCommand(kind)} policy`);
+    }
+    const now = Date.now();
+    const command2 = {
+      version: protocolVersion,
+      id: `command_${crypto.randomUUID()}`,
+      roomId: this.state.id,
+      laneId,
+      sequence: lane.lastCommandSequence + 1,
+      at: now,
+      expiresAt: now + 5 * 6e4,
+      kind,
+      text: text2,
+      source: "conductor",
+      requiredPolicy: requiredPolicyForCommand(kind)
+    };
+    lane.lastCommandSequence = command2.sequence;
+    lane.updatedAt = now;
+    this.state.commands.push(command2);
+    this.state.commands.splice(0, Math.max(0, this.state.commands.length - 500));
+    await this.save();
+    return command2;
+  }
+  async removeLane(laneId) {
+    const lane = this.state.lanes.find((candidate) => candidate.id === laneId);
+    if (!lane) throw new RoomError(404, "lane not found");
+    if (lane.removedAt) return;
+    const now = Date.now();
+    lane.removedAt = now;
+    lane.connected = false;
+    lane.currentTurnId = null;
+    lane.status = "removed by host";
+    lane.updatedAt = now;
+    await this.addConductorMessage("system", `${lane.displayName} removed by host`);
+  }
+  async addParticipantMessage(laneId, token, body) {
+    const lane = this.requireLane(laneId, token);
+    await this.addConductorMessage("participant", body, {
+      authorName: lane.displayName,
+      laneId: lane.id
+    });
+    return lane.displayName;
+  }
+  async addConductorMessage(author, body, detail) {
+    const previous = this.state.conductorMessages.at(-1);
+    if (previous?.author === author && previous.body === body && previous.authorName === detail?.authorName && previous.laneId === detail?.laneId) {
+      return;
+    }
+    this.state.conductorMessages.push({
+      id: `message_${crypto.randomUUID()}`,
+      author,
+      ...detail,
+      body,
+      at: Date.now()
+    });
+    this.state.conductorMessages.splice(0, Math.max(0, this.state.conductorMessages.length - 300));
+    await this.save();
+  }
+  requireLane(laneId, token) {
+    const lane = this.state.lanes.find((candidate) => candidate.id === laneId);
+    if (!lane || lane.token !== token) throw new RoomError(401, "valid lane capability required");
+    if (lane.removedAt) throw new RoomError(410, "lane removed by host");
+    return lane;
+  }
+  async save() {
+    this.savePromise = this.savePromise.then(async () => {
+      const temporary = `${this.statePath}.tmp`;
+      await fs3.writeFile(temporary, `${JSON.stringify(this.state, null, 2)}
+`, { mode: 384 });
+      await fs3.rename(temporary, this.statePath);
+    });
+    await this.savePromise;
+  }
+};
+async function startLocalRoomServer(input) {
+  const host2 = input.host ?? "127.0.0.1";
+  if (["0.0.0.0", "::"].includes(host2) && !input.publicUrl) {
+    throw new RoomError(400, "--public-url is required when binding to all interfaces");
+  }
+  if (input.publicUrl) new URL(input.publicUrl);
+  let publicUrl = "";
+  const server = http.createServer((request, response) => {
+    void handleRequest(input.store, input.handlers, publicUrl, request, response).catch((cause) => {
+      const error = cause instanceof RoomError ? cause : new RoomError(500, errorMessage(cause));
+      sendJson(response, error.status, { error: error.message });
+    });
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(input.port, host2, resolve);
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : input.port;
+  publicUrl = advertisedUrl(host2, port, input.publicUrl);
+  return {
+    url: publicUrl,
+    hostUrl: input.store.hostUrl(publicUrl),
+    inviteUrl: input.store.inviteUrl(publicUrl),
+    close: async () => {
+      await new Promise(
+        (resolve, reject) => server.close((cause) => cause ? reject(cause) : resolve())
+      );
+    }
+  };
+}
+async function handleRequest(store, handlers, publicUrl, request, response) {
+  const url = new URL(request.url ?? "/", "http://127.0.0.1");
+  if (request.method === "GET" && url.pathname === "/") {
+    sendText(response, 200, localRoomHtml(), "text/html; charset=utf-8");
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/snapshot") {
+    sendJson(response, 200, store.snapshot());
+    return;
+  }
+  if (request.method === "GET" && url.pathname === "/api/host/config") {
+    requireHost(store, request);
+    sendJson(response, 200, store.hostConfig(publicUrl));
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/join") {
+    if (!store.authorizeInvite(bearer(request))) {
+      throw new RoomError(401, "valid room invite required");
+    }
+    const body = await readJson(request);
+    const policy = body.policy;
+    if (!["observe", "suggest", "steer"].includes(String(policy))) {
+      throw new RoomError(400, "policy must be observe, suggest, or steer");
+    }
+    const joined = await store.join({
+      displayName: requiredString(body.displayName, "displayName"),
+      repo: requiredString(body.repo, "repo"),
+      policy
+    });
+    sendJson(response, 201, { room: store.snapshot(), ...joined });
+    return;
+  }
+  const resumeMatch = url.pathname.match(/^\/api\/lanes\/([^/]+)\/resume$/);
+  if (request.method === "POST" && resumeMatch) {
+    const body = await readJson(request);
+    const policy = body.policy;
+    if (!["observe", "suggest", "steer"].includes(String(policy))) {
+      throw new RoomError(400, "policy must be observe, suggest, or steer");
+    }
+    const resumed = await store.resumeLane(decodeURIComponent(resumeMatch[1]), bearer(request), {
+      displayName: requiredString(body.displayName, "displayName"),
+      repo: requiredString(body.repo, "repo"),
+      policy
+    });
+    sendJson(response, 200, { room: store.snapshot(), ...resumed });
+    return;
+  }
+  const eventMatch = url.pathname.match(/^\/api\/lanes\/([^/]+)\/events$/);
+  if (request.method === "POST" && eventMatch) {
+    const laneId = decodeURIComponent(eventMatch[1]);
+    const body = await readJson(request);
+    const events = Array.isArray(body.events) ? body.events : [];
+    const ackSequence = await store.appendEvents(laneId, bearer(request), events);
+    sendJson(response, 200, { ackSequence });
+    return;
+  }
+  const commandMatch = url.pathname.match(/^\/api\/lanes\/([^/]+)\/commands$/);
+  if (request.method === "GET" && commandMatch) {
+    const laneId = decodeURIComponent(commandMatch[1]);
+    const after = Number(url.searchParams.get("after") ?? "0");
+    sendJson(response, 200, { commands: store.commandsAfter(laneId, bearer(request), after) });
+    return;
+  }
+  const laneMessageMatch = url.pathname.match(/^\/api\/lanes\/([^/]+)\/message$/);
+  if (request.method === "POST" && laneMessageMatch) {
+    const laneId = decodeURIComponent(laneMessageMatch[1]);
+    const body = await readJson(request);
+    const text2 = requiredString(body.text, "text");
+    const displayName = await store.addParticipantMessage(laneId, bearer(request), text2);
+    void handlers.onConductorMessage(`${displayName}: ${text2}`).catch(
+      (cause) => store.addConductorMessage("system", `conductor failed: ${errorMessage(cause)}`)
+    );
+    sendJson(response, 202, { accepted: true });
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/conductor/message") {
+    requireHost(store, request);
+    const body = await readJson(request);
+    const text2 = requiredString(body.text, "text");
+    await store.addConductorMessage("host", text2);
+    void handlers.onConductorMessage(text2).catch(
+      (cause) => store.addConductorMessage("system", `conductor failed: ${errorMessage(cause)}`)
+    );
+    sendJson(response, 202, { accepted: true });
+    return;
+  }
+  const removeMatch = url.pathname.match(/^\/api\/lanes\/([^/]+)$/);
+  if (request.method === "DELETE" && removeMatch) {
+    requireHost(store, request);
+    await store.removeLane(decodeURIComponent(removeMatch[1]));
+    sendJson(response, 200, { removed: true });
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/conductor/command") {
+    requireHost(store, request);
+    const body = await readJson(request);
+    const laneId = requiredString(body.laneId, "laneId");
+    const kind = requiredCommandKind(body.kind);
+    const text2 = requiredString(body.text, "text");
+    void handlers.onConductorCommand(laneId, kind, text2).catch(
+      (cause) => store.addConductorMessage("system", `conductor command failed: ${errorMessage(cause)}`)
+    );
+    sendJson(response, 202, { accepted: true });
+    return;
+  }
+  if (request.method === "POST" && url.pathname === "/api/conductor/steer") {
+    requireHost(store, request);
+    const body = await readJson(request);
+    const laneId = requiredString(body.laneId, "laneId");
+    const text2 = requiredString(body.text, "text");
+    await store.addConductorMessage("host", `requested steer -> ${laneId}: ${text2}`);
+    void handlers.onConductorCommand(laneId, "steer_active_turn", text2).catch(
+      (cause) => store.addConductorMessage("system", `conductor steer failed: ${errorMessage(cause)}`)
+    );
+    sendJson(response, 202, { accepted: true });
+    return;
+  }
+  throw new RoomError(404, "not found");
+}
+function applyLaneEvent(lane, event) {
+  lane.status = event.summary;
+  if (event.kind === "lane.connected") lane.connected = true;
+  if (event.kind === "lane.disconnected") lane.connected = false;
+  if (event.kind === "lane.thread_attached") lane.threadId = stringPayload(event, "threadId");
+  if (event.kind === "turn.started") lane.currentTurnId = stringPayload(event, "turnId");
+  if (["turn.completed", "turn.failed"].includes(event.kind)) lane.currentTurnId = null;
+}
+function stringPayload(event, key) {
+  const value = event.payload?.[key];
+  return typeof value === "string" ? value : null;
+}
+function publicRepoName(repo) {
+  return path5.basename(path5.resolve(repo)) || "<repo>";
+}
+var RoomError = class extends Error {
+  status;
+  constructor(status2, message) {
+    super(message);
+    this.status = status2;
+  }
+};
+async function readJson(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.from(chunk);
+    size += buffer.length;
+    if (size > 256e3) throw new RoomError(413, "request too large");
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+  } catch {
+    throw new RoomError(400, "valid JSON required");
+  }
+}
+function requiredString(value, name) {
+  if (typeof value !== "string" || !value.trim()) throw new RoomError(400, `${name} is required`);
+  return value.trim();
+}
+function bearer(request) {
+  const value = request.headers.authorization;
+  if (!value?.startsWith("Bearer ")) throw new RoomError(401, "lane capability required");
+  return value.slice("Bearer ".length);
+}
+function requireHost(store, request) {
+  if (!store.authorizeHost(bearer(request))) throw new RoomError(401, "host capability required");
+}
+function requiredCommandKind(value) {
+  if (![
+    "suggest",
+    "start_followup",
+    "steer_active_turn",
+    "request_status",
+    "request_interrupt"
+  ].includes(String(value))) {
+    throw new RoomError(400, "valid command kind required");
+  }
+  return value;
+}
+function advertisedUrl(host2, port, configured) {
+  if (configured) return new URL(configured).toString().replace(/\/$/, "");
+  if (["0.0.0.0", "::"].includes(host2)) {
+    throw new RoomError(400, "--public-url is required when binding to all interfaces");
+  }
+  const displayHost = host2.includes(":") ? `[${host2}]` : host2;
+  return `http://${displayHost}:${port}`;
+}
+function capabilityUrl(base, kind, token) {
+  const url = new URL(base);
+  url.hash = new URLSearchParams({ [kind]: token }).toString();
+  return url.toString();
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function sendJson(response, status2, body) {
+  sendText(response, status2, JSON.stringify(body), "application/json; charset=utf-8");
+}
+function sendText(response, status2, body, contentType) {
+  response.writeHead(status2, {
+    "content-type": contentType,
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  response.end(body);
+}
+function errorMessage(cause) {
+  return cause instanceof Error ? cause.message : String(cause);
+}
+
+// packages/cli/src/index.ts
+var execFileAsync = promisify(execFile);
+var [command = "help", ...args] = process.argv.slice(2);
+try {
+  switch (command) {
+    case "host":
+      await host(args);
+      break;
+    case "join":
+      await join(args);
+      break;
+    case "doctor":
+      await doctor();
+      break;
+    case "status":
+      await status(args);
+      break;
+    default:
+      help();
+      process.exitCode = command === "help" || command === "--help" ? 0 : 2;
+  }
+} catch (cause) {
+  process.stderr.write(`multicodex: ${cause instanceof Error ? cause.message : String(cause)}
+`);
+  process.exitCode = 1;
+}
+async function host(args2) {
+  const options = parseArgs(args2);
+  const repo = path6.resolve(options.repo ?? ".");
+  const port = Number(options.port ?? "7331");
+  const bind = options.bind ?? "127.0.0.1";
+  const stateDir = path6.resolve(options.state ?? path6.join(repo, ".multicodex", "host"));
+  const store = options.resume ? await LocalRoomStore.load(stateDir) : await LocalRoomStore.create({
+    stateDir,
+    title: options.title ?? "MultiCodex local alpha",
+    repo
+  });
+  const conductor = new LocalConductor(store, { repo, stateDir });
+  const server = await startLocalRoomServer({
+    store,
+    port,
+    host: bind,
+    publicUrl: options["public-url"],
+    handlers: {
+      onConductorMessage: (text2) => conductor.message(text2),
+      onConductorCommand: (laneId, kind, text2) => conductor.command(laneId, kind, text2)
+    }
+  });
+  try {
+    await conductor.initialize();
+  } catch (cause) {
+    await server.close();
+    throw cause;
+  }
+  process.stdout.write(
+    [
+      "",
+      "MultiCodex room ready",
+      `control: ${server.hostUrl}`,
+      `invite: npx --yes @vincentkoc/multicodex@latest join ${shellQuote2(server.inviteUrl)} --repo . --name Builder --policy suggest`,
+      `dev join: pnpm multicodex join ${shellQuote2(server.inviteUrl)} --repo . --name Builder --policy suggest`,
+      "conductor: local ACPx / Codex",
+      "runtime: no Crabfleet, Crabbox, server OpenAI key, or GitHub token",
+      ""
+    ].join("\n")
+  );
+  await waitForSignal(async () => server.close());
+}
+async function join(args2) {
+  const positional = args2.find((arg) => !arg.startsWith("-"));
+  const options = parseArgs(positional ? args2.filter((arg) => arg !== positional) : args2);
+  const server = positional ?? options.server ?? "http://127.0.0.1:7331";
+  const policy = options.policy ?? "suggest";
+  if (!["observe", "suggest", "steer"].includes(policy)) {
+    throw new Error("policy must be observe, suggest, or steer");
+  }
+  const codexPath = await resolveUserCodexPath({ explicit: options.codex });
+  if (!codexPath) {
+    throw new Error(
+      "user Codex not found outside package-local dependencies; install Codex or pass --codex"
+    );
+  }
+  const bridge = new BuilderBridge({
+    server,
+    repo: path6.resolve(options.repo ?? "."),
+    displayName: options.name ?? process.env.USER ?? "Builder",
+    policy,
+    codexPath,
+    noTui: Boolean(options["no-tui"]),
+    prompt: options.prompt,
+    fresh: Boolean(options.fresh),
+    statePath: options.state ? path6.resolve(options.state) : void 0
+  });
+  process.once("SIGINT", () => bridge.stop());
+  process.once("SIGTERM", () => bridge.stop());
+  await bridge.run();
+}
+async function doctor() {
+  const checks = [];
+  const [nodeMajor = 0, nodeMinor = 0] = process.versions.node.split(".").map(Number);
+  checks.push([
+    "Node",
+    nodeMajor > 22 || nodeMajor === 22 && nodeMinor >= 13,
+    `${process.version} (requires >=22.13.0)`
+  ]);
+  const codexPath = await resolveUserCodexPath();
+  if (!codexPath) {
+    checks.push(["Codex", false, "user install not found outside package-local dependencies"]);
+  } else {
+    try {
+      const { stdout } = await execFileAsync(codexPath, ["--version"]);
+      checks.push(["Codex", true, stdout.trim()]);
+    } catch {
+      checks.push(["Codex", false, "not found"]);
+    }
+  }
+  checks.push(["WebSocket", typeof WebSocket === "function", "Node WebSocket client"]);
+  for (const [name, ok, detail] of checks)
+    process.stdout.write(`${ok ? "ok" : "fail"}  ${name}: ${detail}
+`);
+  if (checks.some(([, ok]) => !ok)) process.exitCode = 1;
+}
+async function status(args2) {
+  const server = args2.find((arg) => !arg.startsWith("-")) ?? "http://127.0.0.1:7331";
+  const response = await fetch(new URL("/api/snapshot", server));
+  if (!response.ok) throw new Error(`status failed (${response.status})`);
+  process.stdout.write(`${JSON.stringify(await response.json(), null, 2)}
+`);
+}
+function parseArgs(args2) {
+  const values = {};
+  for (let index = 0; index < args2.length; index += 1) {
+    const argument = args2[index];
+    if (!argument.startsWith("--")) continue;
+    const key = argument.slice(2);
+    const next = args2[index + 1];
+    if (!next || next.startsWith("--")) values[key] = "true";
+    else {
+      values[key] = next;
+      index += 1;
+    }
+  }
+  return values;
+}
+function help() {
+  process.stdout.write(`MultiCodex self-contained room
+
+Usage:
+  multicodex doctor
+  multicodex host --repo . [--port 7331] [--bind 127.0.0.1] [--public-url <url>]
+  multicodex join <invite-url> --repo . --name Builder [--policy observe|suggest|steer]
+  multicodex status [room-url]
+
+Options:
+  --no-tui           connect the bridge without launching the normal Codex TUI
+  --prompt <text>    start a builder turn after connecting
+  --fresh            create a new lane instead of resuming local lane state
+  --state <path>     override the builder lane state file
+  --resume           resume the host room state from --state
+`);
+}
+async function waitForSignal(cleanup) {
+  await new Promise((resolve) => {
+    const stop = () => void cleanup().finally(resolve);
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+  });
+}
+function shellQuote2(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}