paseo-room 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1114 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// package.json
+var package_default;
+var init_package = __esm({
+  "package.json"() {
+    package_default = {
+      name: "paseo-room",
+      version: "0.1.0-alpha.0",
+      description: "One CLI that configures Codex/Claude role homes in $HOME and registers them with your local Paseo daemon.",
+      keywords: [
+        "paseo",
+        "codex",
+        "claude-code",
+        "agent",
+        "orchestration",
+        "cli"
+      ],
+      homepage: "https://github.com/cuongntr/paseo-room#readme",
+      bugs: "https://github.com/cuongntr/paseo-room/issues",
+      repository: {
+        type: "git",
+        url: "git+https://github.com/cuongntr/paseo-room.git"
+      },
+      license: "MIT",
+      author: "Invoker <cuongnt1987@gmail.com>",
+      type: "module",
+      engines: {
+        node: ">=22"
+      },
+      bin: {
+        "paseo-room": "dist/index.js"
+      },
+      files: [
+        "dist/"
+      ],
+      scripts: {
+        typecheck: "tsc --noEmit",
+        lint: "eslint . --max-warnings 0",
+        test: "vitest run",
+        build: "tsup",
+        prepack: "npm run build",
+        verify: "npm run typecheck && npm run lint && npm test && npm run build"
+      },
+      dependencies: {
+        "@clack/prompts": "^1.8.0",
+        "@getpaseo/client": "0.8.0-beta.1",
+        commander: "^14.0.3",
+        semver: "^7.8.5",
+        "smol-toml": "^1.8.0",
+        zod: "^4.5.4"
+      },
+      devDependencies: {
+        "@eslint/js": "^10.0.1",
+        "@types/node": "^22.0.0",
+        "@types/semver": "^7.7.0",
+        eslint: "^10.10.0",
+        tsup: "^8.5.1",
+        typescript: "~5.9.3",
+        "typescript-eslint": "^8.70.0",
+        vitest: "^4.1.11"
+      }
+    };
+  }
+});
+
+// src/result.ts
+function pass(id, message) {
+  return { id, status: "pass", message };
+}
+function fail(id, message, fix) {
+  return { id, status: "fail", message, fix };
+}
+function failed(command, checks) {
+  return { command, outcome: "failed", changed: false, checks, operations: [] };
+}
+function hasFailure(checks) {
+  return checks.some((check) => check.status === "fail");
+}
+function exitCode(result) {
+  return result.outcome === "failed" || hasFailure(result.checks) ? 1 : 0;
+}
+var init_result = __esm({
+  "src/result.ts"() {
+    "use strict";
+  }
+});
+
+// src/layout.ts
+import { homedir } from "os";
+import { join, resolve, sep } from "path";
+function pick(...candidates) {
+  for (const candidate of candidates) if (candidate?.trim()) return candidate.trim();
+  throw new Error("Could not determine HOME; pass explicit --room-home and --codex-home/--claude-home paths.");
+}
+function resolveLayout(options = {}, env = process.env) {
+  const home = pick(env.HOME, homedir());
+  return {
+    home,
+    roomHome: resolve(pick(options.roomHome, env.PASEO_ROOM_HOME, join(home, ".paseo-room"))),
+    paseoHome: resolve(pick(env.PASEO_HOME, join(home, ".paseo"))),
+    agentHome: {
+      codex: resolve(pick(options.codexHome, env.CODEX_HOME, join(home, ".codex"))),
+      claude: resolve(pick(options.claudeHome, env.CLAUDE_CONFIG_DIR, join(home, ".claude")))
+    },
+    bin: {
+      codex: pick(options.codexBin, env.CODEX_BIN, "codex"),
+      claude: pick(options.claudeBin, env.CLAUDE_BIN, "claude"),
+      paseo: pick(options.paseoBin, env.PASEO_BIN, "paseo")
+    }
+  };
+}
+function contains(root, path) {
+  return path === root || path.startsWith(root.endsWith(sep) ? root : root + sep);
+}
+function layoutChecks(layout, agents) {
+  const checks = [];
+  if (contains(layout.roomHome, layout.home)) {
+    checks.push(fail(
+      "room.home",
+      `Refusing to use ${layout.roomHome} as the room home: it contains your home directory.`,
+      "Point --room-home at a dedicated directory, by default ~/.paseo-room."
+    ));
+  }
+  for (const id of agents) {
+    const home = layout.agentHome[id];
+    if (contains(layout.roomHome, home) || contains(home, layout.roomHome)) {
+      checks.push(fail(
+        `${id}.home`,
+        `The ${id} home ${home} overlaps the room home ${layout.roomHome}.`,
+        `Pass --${id}-home pointing at your own ${id} configuration (this happens when setup runs inside a room seat).`
+      ));
+    }
+  }
+  return checks;
+}
+function roleHome(layout, agent, role) {
+  return join(layout.roomHome, "roles", agent, role);
+}
+function sharedRoom(layout) {
+  return join(layout.roomHome, "room");
+}
+var init_layout = __esm({
+  "src/layout.ts"() {
+    "use strict";
+    init_result();
+  }
+});
+
+// src/fsops.ts
+import { chmod, lstat, mkdir, readFile, readlink, rm, symlink, writeFile } from "fs/promises";
+import { dirname, join as join2 } from "path";
+async function current(entry) {
+  let stat;
+  try {
+    stat = await lstat(entry.path);
+  } catch {
+    return "absent";
+  }
+  if (entry.kind === "dir") return stat.isDirectory() ? "same" : "different";
+  if (entry.kind === "link") {
+    if (!stat.isSymbolicLink()) return "different";
+    return await readlink(entry.path) === entry.target ? "same" : "different";
+  }
+  if (!stat.isFile()) return "different";
+  if (entry.once) return "same";
+  return await readFile(entry.path, "utf8") === entry.content ? "same" : "different";
+}
+async function planEntries(entries) {
+  const operations = [];
+  for (const entry of entries) {
+    const state = await current(entry);
+    operations.push({
+      action: state === "same" ? "noop" : state === "absent" ? "create" : "update",
+      kind: entry.kind,
+      target: entry.path
+    });
+  }
+  return operations;
+}
+async function applyEntries(entries) {
+  for (const entry of entries) {
+    if (await current(entry) === "same") continue;
+    if (entry.kind === "dir") {
+      await mkdir(entry.path, { recursive: true, mode: DIR_MODE });
+      continue;
+    }
+    await mkdir(dirname(entry.path), { recursive: true, mode: DIR_MODE });
+    await rm(entry.path, { force: true, recursive: true });
+    if (entry.kind === "link") await symlink(entry.target, entry.path);
+    else {
+      await writeFile(entry.path, entry.content, { mode: FILE_MODE });
+      await chmod(entry.path, FILE_MODE);
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function existingPaths(home, names) {
+  const paths = names.map((name) => join2(home, name));
+  const present = await Promise.all(paths.map(exists));
+  return paths.filter((_, index) => present[index] === true);
+}
+async function readIfPresent(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+var DIR_MODE, FILE_MODE;
+var init_fsops = __esm({
+  "src/fsops.ts"() {
+    "use strict";
+    DIR_MODE = 448;
+    FILE_MODE = 384;
+  }
+});
+
+// src/room/clauses.ts
+function clause(source) {
+  return source.trim().split(/\n\s*\n/).map((statement) => statement.split("\n").map((line) => line.trim()).join(" "));
+}
+var CLAUSES, SHARED_IDS;
+var init_clauses = __esm({
+  "src/room/clauses.ts"() {
+    "use strict";
+    CLAUSES = {
+      "RC-001": clause(`
+    Human owns product goals, priority, material-cost choices, external effects, and
+    irreversible-risk decisions. No agent may take ownership of these decisions; obtain
+    Human approval before crossing those boundaries.
+
+    Human may direct the technical route, decomposition, and lifecycle, and may override
+    an acceptance decision. Human does not normally operate the agent protocol.
+  `),
+      "RC-002": clause(`
+    Each role must read workspace-local docs/WORKSPACE_PROTOCOL.md when it exists.
+    Repository conventions, narrower scopes, validation commands, and escalation details
+    may refine workflow, but cannot weaken this authority contract.
+
+    A local protocol cannot give Peer orchestration, give Supervisor or Peer technical
+    acceptance, permit multiple writable Peers, or transfer Human decisions to an agent.
+  `),
+      "RC-003": clause(`
+    Use tests, artifacts, lifecycle states, and completion/error/attention events as
+    evidence, not as automatic authorization or acceptance.
+
+    Wait for state-changing events when progress depends on another actor. Do not
+    repeatedly poll unchanged state; resume when new evidence or a relevant event arrives.
+  `),
+      "RC-004": clause(`
+    Preserve unrelated work. Stay within the granted repository scope and external-action
+    authority; do not treat access to a tool as permission to expand either boundary.
+  `),
+      "RC-101": clause(`
+    Supervisor routes the Human directive to Lead without changing its outcome, requested
+    output, constraints, or approval gates. Label added context separately; it must not
+    rewrite the directive.
+  `),
+      "RC-102": clause(`
+    Supervisor observes technical work rather than choosing architecture, decomposing
+    work, or moving write ownership. Prefer routing work through Lead.
+
+    Supervisor must not edit project work, run project validation, or decide technical
+    acceptance. Supervisor must not direct Peer while Lead is healthy; an unhealthy Lead
+    calls for bounded recovery or escalation, not taking over Peer work.
+  `),
+      "RC-103": clause(`
+    Supervisor has Paseo tools enabled solely within its authority. Use the smallest Paseo
+    room/session lifecycle action needed for an explicit Human request or bounded room
+    recovery; preserve current ownership and inform Lead of every change.
+  `),
+      "RC-104": clause(`
+    Supervisor sends technical questions and evidence to Lead. Escalate product, priority,
+    material-cost, external-effect, and irreversible-risk choices to Human rather than
+    deciding them.
+  `),
+      "RC-201": clause(`
+    Lead owns project framing, architecture, dependencies, integration, verification, and
+    technical acceptance within Human boundaries. Lead executes the Human outcome and
+    constraints, escalating Human-owned choices to Human.
+
+    Lead has Paseo tools enabled to manage project agents and direct Peer; this capability
+    does not expand project or external-action authority.
+  `),
+      "RC-202": clause(`
+    Lead owns decomposition and moving write-scope assignment: give each moving scope
+    exactly one owner, with at most one active writable Peer across the project at a time.
+    Lead must not edit a scope concurrently with its writing Peer.
+
+    Before transferring write ownership, stop the prior writer and establish a stable
+    handoff. Read-only review does not create another writer.
+  `),
+      "RC-203": clause(`
+    Before delegation, Lead supplies a complete Peer brief: one bounded outcome,
+    prerequisites, explicit write scope or read-only mode, stable contract and invariants,
+    required acceptance evidence, and conditions that reopen the decision.
+  `),
+      "RC-204": clause(`
+    Lead permits independent Peer judgment: REOPEN_REQUEST challenges a premise;
+    DEPENDENCY_REQUEST asks for an unowned prerequisite; BLOCKED reports that no safe
+    progress is possible.
+
+    For each signal, Peer provides evidence, consequence, and the needed decision or
+    dependency. Lead resolves technical signals or escalates Human-owned choices; Peer
+    must not seize unowned work while waiting.
+  `),
+      "RC-205": clause(`
+    Lead inspects the exact candidate or a deterministic snapshot and explicitly accepts
+    or rejects it with a technical reason. Passing tests and completion reports are
+    evidence, not acceptance. Among agents, Lead alone accepts; Human retains override
+    authority.
+  `),
+      "RC-206": clause(`
+    When material uncertainty warrants independent review, Lead may dispatch a fresh
+    read-only Peer with an exact stable candidate and a bounded question. Review is
+    optional: do not introduce a dedicated reviewer role or a fixed reviewer count.
+  `),
+      "RC-301": clause(`
+    Peer owns exactly one Lead-delegated bounded outcome and proportionate evidence. Do
+    not add adjacent tasks; send technical questions to Lead and escalate Human-owned
+    choices through Lead.
+  `),
+      "RC-302": clause(`
+    A writing Peer owns only its assigned moving write scope. A review Peer stays
+    read-only and inspects only the named candidate or snapshot, without changing project
+    files or the candidate.
+  `),
+      "RC-303": clause(`
+    Peer must not spawn, manage, coordinate, or infer room topology, direct another Peer,
+    or perform Paseo room/session lifecycle operations. Peer receives no Paseo tools;
+    enabled is false. This capability boundary is not an operating-system sandbox.
+  `),
+      "RC-304": clause(`
+    Peer hands off a candidate by naming an immutable commit or deterministic snapshot,
+    the original base, all changed paths, verification performed and its results, and
+    residual risk. Make the candidate reproducible for Lead inspection.
+  `),
+      "RC-305": clause(`
+    Peer must not self-accept any work, including difficult work. Peer tests and
+    completion are evidence only; Lead alone performs technical acceptance among agents,
+    subject to Human override.
+  `)
+    };
+    SHARED_IDS = ["RC-001", "RC-002", "RC-003", "RC-004"];
+  }
+});
+
+// src/room/instructions.ts
+function instructionIds(kind) {
+  if (kind === "workspace") return Object.keys(CLAUSES);
+  return [...SHARED_IDS, ...ROLE_IDS[kind]];
+}
+function renderInstructions(kind) {
+  const sections = instructionIds(kind).map(
+    (id) => `## ${id}
+${CLAUSES[id].map((statement) => `- ${statement}`).join("\n")}`
+  );
+  return [`# ${TITLES[kind]}`, PREFACES[kind], ...sections].join("\n\n") + "\n";
+}
+var ROLE_IDS, TITLES, PREFACES;
+var init_instructions = __esm({
+  "src/room/instructions.ts"() {
+    "use strict";
+    init_clauses();
+    ROLE_IDS = {
+      supervisor: ["RC-101", "RC-102", "RC-103", "RC-104"],
+      lead: ["RC-201", "RC-202", "RC-203", "RC-204", "RC-205", "RC-206"],
+      // Peer needs the challenge protocol as well as its own numbered obligations.
+      peer: ["RC-204", "RC-301", "RC-302", "RC-303", "RC-304", "RC-305"]
+    };
+    TITLES = {
+      workspace: "Paseo Room workspace protocol \u2014 operator reference/template",
+      supervisor: "Supervisor role instructions",
+      lead: "Lead role instructions",
+      peer: "Peer role instructions"
+    };
+    PREFACES = {
+      workspace: "Operator reference: copy what you need into a workspace-local docs/WORKSPACE_PROTOCOL.md. Installation never creates or replaces that workspace file.",
+      supervisor: "You are Supervisor, the Human-facing routing seat, not the project Lead.",
+      lead: "You are Lead, the project technical owner under Human authority.",
+      peer: "You are Peer, executing one brief from Lead in writing or read-only review mode."
+    };
+  }
+});
+
+// src/which.ts
+import { execFile } from "child_process";
+import { access, constants, realpath } from "fs/promises";
+import { delimiter, isAbsolute, join as join3, resolve as resolve2 } from "path";
+import { promisify } from "util";
+async function which(command, env = process.env) {
+  const candidates = isAbsolute(command) || command.includes("/") ? [resolve2(command)] : (env.PATH ?? "").split(delimiter).filter(Boolean).map((entry) => join3(entry, command));
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK);
+      return await realpath(candidate);
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function probe(executable, args, env) {
+  try {
+    const { stdout } = await run(executable, [...args], { env, timeout: 2e4, maxBuffer: 16 * 1024 * 1024, encoding: "utf8" });
+    return { ok: true, stdout };
+  } catch {
+    return { ok: false, stdout: "" };
+  }
+}
+var run;
+var init_which = __esm({
+  "src/which.ts"() {
+    "use strict";
+    run = promisify(execFile);
+  }
+});
+
+// src/agents/claude.ts
+import { basename, join as join4 } from "path";
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function readObject(source) {
+  try {
+    return asObject(source === void 0 ? {} : JSON.parse(source));
+  } catch {
+    return {};
+  }
+}
+function renderRoleSettings(source, role) {
+  const settings = readObject(source);
+  settings.env = { ...asObject(settings.env), PASEO_ROOM_ROLE: role };
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+function renderRoleState(source) {
+  const root = readObject(source);
+  const state = { hasCompletedOnboarding: true };
+  for (const key of SEEDED_KEYS) if (key in root) state[key] = root[key];
+  return JSON.stringify(state, null, 2) + "\n";
+}
+var SHARED, SEEDED_KEYS, claudeAgent;
+var init_claude = __esm({
+  "src/agents/claude.ts"() {
+    "use strict";
+    init_layout();
+    init_fsops();
+    init_result();
+    init_instructions();
+    init_which();
+    SHARED = [".credentials.json", "skills", "plugins", "commands", "hooks"];
+    SEEDED_KEYS = ["hasCompletedOnboarding", "theme", "installMethod", "userID", "oauthAccount"];
+    claudeAgent = {
+      id: "claude",
+      label: "Claude Code",
+      homeEnv: "CLAUDE_CONFIG_DIR",
+      // Claude's own subagents would be a second control plane; Paseo owns agent
+      // lifecycle. This is the Claude counterpart of Codex's [agents] enabled = false.
+      pins: { disallowedTools: ["Task"] },
+      async build(layout, roles) {
+        const home = layout.agentHome.claude;
+        const binary = await which(layout.bin.claude);
+        if (!binary) {
+          return { entries: [], checks: [fail("claude.bin", "Claude Code executable not found.", "Install Claude Code, or pass --claude-bin /path/to/claude.")] };
+        }
+        if (!await exists(home)) {
+          return { entries: [], checks: [fail("claude.home", `No Claude config directory at ${home}.`, "Run claude once to initialise it, or pass --claude-home.")] };
+        }
+        const checks = [pass("claude.home", `Claude Code found at ${binary} using ${home}.`)];
+        const settingsSource = await readIfPresent(join4(home, "settings.json"));
+        const stateSource = await readIfPresent(join4(layout.home, ".claude.json"));
+        const shared = await existingPaths(home, SHARED);
+        const entries = [];
+        for (const role of roles) {
+          const target = roleHome(layout, "claude", role);
+          entries.push({ kind: "dir", path: target });
+          entries.push({ kind: "file", path: join4(target, "CLAUDE.md"), content: renderInstructions(role) });
+          entries.push({ kind: "file", path: join4(target, "settings.json"), content: renderRoleSettings(settingsSource, role) });
+          entries.push({ kind: "file", path: join4(target, ".claude.json"), content: renderRoleState(stateSource), once: true });
+          for (const path of shared) entries.push({ kind: "link", path: join4(target, basename(path)), target: path });
+        }
+        return { entries, checks, binary };
+      }
+    };
+  }
+});
+
+// src/agents/codex.ts
+import { basename as basename2, join as join5 } from "path";
+import { parse, stringify } from "smol-toml";
+function table(parent, key) {
+  const value = parent[key];
+  if (value === void 0 || typeof value !== "object" || Array.isArray(value) || value instanceof Date) {
+    return parent[key] = {};
+  }
+  return value;
+}
+function renderRoleConfig(source, input) {
+  const config = structuredClone(source);
+  config.sandbox_mode = "danger-full-access";
+  config.approval_policy = "never";
+  if (typeof config.profile === "string") {
+    const profile = table(table(config, "profiles"), config.profile);
+    profile.sandbox_mode = "danger-full-access";
+    profile.approval_policy = "never";
+  }
+  config.developer_instructions = input.roleDocument;
+  if (input.catalogPath) config.model_catalog_json = input.catalogPath;
+  table(config, "agents").enabled = false;
+  const features = table(config, "features");
+  features.multi_agent = false;
+  if (typeof features.multi_agent_v2 === "boolean" || features.multi_agent_v2 === void 0) features.multi_agent_v2 = false;
+  else table(features, "multi_agent_v2").enabled = false;
+  return stringify(config) + "\n";
+}
+function renderCatalog(catalog) {
+  return JSON.stringify(catalog, (key, value) => key === "multi_agent_version" ? null : value, 2) + "\n";
+}
+var SHARED2, CATALOG, codexAgent;
+var init_codex = __esm({
+  "src/agents/codex.ts"() {
+    "use strict";
+    init_layout();
+    init_fsops();
+    init_result();
+    init_instructions();
+    init_which();
+    SHARED2 = ["auth.json", "AGENTS.md", "skills", "plugins", "hooks.json"];
+    CATALOG = "model-catalog.json";
+    codexAgent = {
+      id: "codex",
+      label: "Codex",
+      homeEnv: "CODEX_HOME",
+      // Without these, Paseo's own mode preset (default auto-review) is sent to the
+      // app-server and outranks the sandbox/approval keys in the generated config.
+      pins: { params: { sandbox_mode: "danger-full-access", approval_policy: "never" } },
+      async build(layout, roles) {
+        const checks = [];
+        const home = layout.agentHome.codex;
+        const binary = await which(layout.bin.codex);
+        if (!binary) {
+          return { entries: [], checks: [fail("codex.bin", "Codex executable not found.", "Install Codex, or pass --codex-bin /path/to/codex.")] };
+        }
+        const configPath = join5(home, "config.toml");
+        const raw = await readIfPresent(configPath);
+        if (raw === void 0) {
+          return { entries: [], checks: [fail("codex.home", `No config.toml in ${home}.`, "Run codex once to initialise it, or pass --codex-home.")] };
+        }
+        let source;
+        try {
+          source = parse(raw);
+        } catch {
+          return { entries: [], checks: [fail("codex.config", `Could not read ${configPath} as TOML.`, "Fix the syntax in your Codex config, then run setup again.")] };
+        }
+        checks.push(pass("codex.home", `Codex found at ${binary} using ${home}.`));
+        const entries = [];
+        let catalogSource;
+        const models = await probe(binary, ["debug", "models"], { HOME: layout.home, CODEX_HOME: home, PATH: process.env.PATH ?? "" });
+        if (models.ok) {
+          try {
+            catalogSource = renderCatalog(JSON.parse(models.stdout));
+          } catch {
+            catalogSource = void 0;
+          }
+        }
+        if (!catalogSource) checks.push({ id: "codex.catalog", status: "warn", message: "Codex model catalog unavailable; roles keep the default catalog." });
+        const shared = await existingPaths(home, SHARED2);
+        for (const role of roles) {
+          const target = roleHome(layout, "codex", role);
+          const catalogPath = catalogSource ? join5(target, CATALOG) : void 0;
+          const roleDocument = renderInstructions(role);
+          entries.push({ kind: "dir", path: target });
+          entries.push({ kind: "file", path: join5(target, "role-instructions.md"), content: roleDocument });
+          entries.push({
+            kind: "file",
+            path: join5(target, "config.toml"),
+            content: renderRoleConfig(source, { roleDocument, ...catalogPath ? { catalogPath } : {} })
+          });
+          if (catalogSource && catalogPath) entries.push({ kind: "file", path: catalogPath, content: catalogSource });
+          for (const path of shared) entries.push({ kind: "link", path: join5(target, basename2(path)), target: path });
+        }
+        return { entries, checks, binary };
+      }
+    };
+  }
+});
+
+// src/paseo.ts
+import { gte, valid } from "semver";
+import { z } from "zod";
+function normalizeUrl(listen) {
+  const match = /^(?:ws:\/\/)?([^:/]+|\[[^\]]+\]):(\d+)$/.exec(listen.trim());
+  if (!match) return void 0;
+  const [, host = "", port = ""] = match;
+  const local = ["localhost", "127.0.0.1", "0.0.0.0", "[::1]", "[::]"].includes(host) ? "127.0.0.1" : host;
+  return `ws://${local}:${port}`;
+}
+function assessStatus(raw) {
+  const parsed = statusSchema.safeParse(raw);
+  if (!parsed.success) {
+    return { checks: [fail("paseo.status", "Paseo status output was not understood.", "Upgrade Paseo, then run: paseo daemon status --json")] };
+  }
+  const status = parsed.data;
+  if (status.localDaemon !== "running") {
+    return { checks: [fail("paseo.daemon", `Paseo daemon is ${status.localDaemon}.`, "Start it with: paseo daemon start")] };
+  }
+  const cli = valid(status.cliVersion);
+  const daemon = status.daemonVersion === null ? null : valid(status.daemonVersion);
+  if (!cli || !daemon) {
+    return { checks: [fail("paseo.version", "Paseo did not report a usable version.", "Upgrade Paseo to a release that reports semver versions.")] };
+  }
+  if (cli !== daemon) {
+    return { checks: [fail("paseo.version", `Paseo CLI is ${cli} but the running daemon is ${daemon}.`, "Restart the daemon with: paseo daemon restart")] };
+  }
+  if (!gte(daemon, MINIMUM_VERSION)) {
+    return { checks: [fail("paseo.version", `Paseo ${daemon} is older than the required ${MINIMUM_VERSION}.`, "Upgrade Paseo, then run setup again.")] };
+  }
+  const url = normalizeUrl(status.listen);
+  if (!url) {
+    return { checks: [fail("paseo.listen", `Paseo listen address ${status.listen} was not understood.`, "Use a host:port listen address in the Paseo config.")] };
+  }
+  return { checks: [pass("paseo.version", `Paseo ${daemon} is running on ${url} (compatible, needs >= ${MINIMUM_VERSION}).`)], daemon: { url, version: daemon } };
+}
+async function checkDaemon(layout, env = process.env) {
+  const binary = await which(layout.bin.paseo, env);
+  if (!binary) {
+    return { checks: [fail("paseo.bin", "Paseo executable not found.", "Install Paseo, or pass --paseo-bin /path/to/paseo.")] };
+  }
+  const output = await probe(binary, ["daemon", "status", "--json"], {
+    HOME: layout.home,
+    PASEO_HOME: layout.paseoHome,
+    PATH: env.PATH ?? "",
+    ...env.PASEO_PASSWORD === void 0 ? {} : { PASEO_PASSWORD: env.PASEO_PASSWORD }
+  });
+  if (!output.ok) {
+    return { checks: [fail("paseo.status", "Could not read Paseo daemon status.", "Run: paseo daemon status --json")] };
+  }
+  try {
+    return assessStatus(JSON.parse(output.stdout));
+  } catch {
+    return assessStatus(void 0);
+  }
+}
+async function withSession(daemon, run2, options = {}) {
+  const quiet = { debug() {
+  }, info() {
+  }, warn() {
+  }, error() {
+  } };
+  const factory = options.factory ?? (await import("@getpaseo/client")).createPaseoClient;
+  const client = factory({
+    url: `${daemon.url}/ws`,
+    ...options.password === void 0 ? {} : { password: options.password },
+    appVersion: MINIMUM_VERSION,
+    connectTimeoutMs: 1e4,
+    reconnect: { enabled: false },
+    logger: quiet
+  });
+  try {
+    await client.connect();
+    return await run2({
+      async readProviders() {
+        const response = configSchema.parse(await client.config.get());
+        return response.config.providers ?? {};
+      },
+      async writeProviders(providers) {
+        await client.config.patch({ providers });
+      },
+      async removeProviders(ids) {
+        await client.config.patch({ removeProviders: [...ids] });
+      },
+      async refresh(ids) {
+        await client.providers.refresh({ providers: [...ids] });
+      }
+    });
+  } finally {
+    await client.close();
+  }
+}
+function providerMatches(desired, live) {
+  if (live === null || typeof live !== "object") return false;
+  const entry = live;
+  const env = entry.env;
+  const tools = entry.paseoTools;
+  const same = (left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+  return entry.extends === desired.extends && same(entry.command, desired.command) && env !== null && typeof env === "object" && Object.entries(desired.env).every(([key, value]) => env[key] === value) && tools !== null && typeof tools === "object" && tools.enabled === desired.paseoTools.enabled && // Pins are the room's guarantee: drifting them silently re-enables what they block.
+  same(entry.params, desired.params) && same(entry.disallowedTools, desired.disallowedTools);
+}
+var MINIMUM_VERSION, statusSchema, configSchema;
+var init_paseo = __esm({
+  "src/paseo.ts"() {
+    "use strict";
+    init_result();
+    init_which();
+    MINIMUM_VERSION = "0.8.0-beta.1";
+    statusSchema = z.object({
+      listen: z.string().min(1),
+      localDaemon: z.enum(["running", "stopped", "stale_pid", "unresponsive"]),
+      cliVersion: z.string(),
+      daemonVersion: z.string().nullable()
+    });
+    configSchema = z.object({ config: z.object({ providers: z.record(z.string(), z.unknown()).optional() }) });
+  }
+});
+
+// src/roles.ts
+function providerId(agent, role) {
+  return `${agent}-${role}`;
+}
+function providerLabel(agent, role) {
+  const title = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+  return `${title(agent)} ${title(role)}`;
+}
+var ROLES, AGENT_IDS, ROLE_PASEO_TOOLS;
+var init_roles = __esm({
+  "src/roles.ts"() {
+    "use strict";
+    ROLES = ["supervisor", "lead", "peer"];
+    AGENT_IDS = ["codex", "claude"];
+    ROLE_PASEO_TOOLS = { supervisor: true, lead: true, peer: false };
+  }
+});
+
+// src/room.ts
+import { join as join6 } from "path";
+import { z as z2 } from "zod";
+function renderMarker(version, agents, roles) {
+  return JSON.stringify({ version, agents: [...agents], roles: [...roles] }, null, 2) + "\n";
+}
+async function readMarker(layout) {
+  const source = await readIfPresent(join6(layout.roomHome, MARKER));
+  if (source === void 0) return void 0;
+  try {
+    return markerSchema.parse(JSON.parse(source));
+  } catch {
+    return void 0;
+  }
+}
+var MARKER, markerSchema;
+var init_room = __esm({
+  "src/room.ts"() {
+    "use strict";
+    init_fsops();
+    init_roles();
+    MARKER = "room.json";
+    markerSchema = z2.object({
+      version: z2.string(),
+      agents: z2.array(z2.enum(AGENT_IDS)).min(1),
+      roles: z2.array(z2.enum(ROLES)).min(1)
+    });
+  }
+});
+
+// src/commands.ts
+import { join as join7 } from "path";
+import { rm as rm2 } from "fs/promises";
+function sessionOptions(options) {
+  const password = (options.env ?? process.env).PASEO_PASSWORD;
+  return { ...password === void 0 ? {} : { password }, ...options.factory ? { factory: options.factory } : {} };
+}
+function roleProviders(layout, agent, binary, roles) {
+  return Object.fromEntries(roles.map((role) => [providerId(agent.id, role), {
+    extends: agent.id,
+    label: providerLabel(agent.id, role),
+    command: [binary],
+    env: { [agent.homeEnv]: roleHome(layout, agent.id, role) },
+    paseoTools: { enabled: ROLE_PASEO_TOOLS[role] },
+    ...agent.pins
+  }]));
+}
+async function buildDesired(layout, agents, roles) {
+  const entries = [
+    { kind: "dir", path: layout.roomHome },
+    { kind: "dir", path: sharedRoom(layout) },
+    { kind: "file", path: join7(sharedRoom(layout), "workspace-protocol.md"), content: renderInstructions("workspace") }
+  ];
+  const providers = {};
+  const checks = [];
+  for (const id of agents) {
+    const agent = AGENTS[id];
+    const plan = await agent.build(layout, roles);
+    entries.push(...plan.entries);
+    checks.push(...plan.checks);
+    if (plan.binary !== void 0) Object.assign(providers, roleProviders(layout, agent, plan.binary, roles));
+  }
+  entries.push({ kind: "file", path: join7(layout.roomHome, MARKER), content: renderMarker(package_default.version, agents, roles) });
+  return { entries, providers, checks };
+}
+async function staleFrom(layout, previous, agents, roles) {
+  if (!previous) return NOTHING_STALE;
+  const kept = new Set(agents.flatMap((agent) => roles.map((role) => providerId(agent, role))));
+  const providerIds = [];
+  const directories = [];
+  for (const agent of previous.agents) {
+    for (const role of previous.roles) {
+      if (kept.has(providerId(agent, role))) continue;
+      providerIds.push(providerId(agent, role));
+      const path = roleHome(layout, agent, role);
+      if (await exists(path)) directories.push(path);
+    }
+  }
+  return { providerIds, directories };
+}
+async function planRoom(session, desired, stale) {
+  const live = await session.readProviders();
+  return [
+    ...await planEntries(desired.entries),
+    ...Object.entries(desired.providers).map(([id, provider]) => ({
+      action: !(id in live) ? "create" : providerMatches(provider, live[id]) ? "noop" : "update",
+      kind: "provider",
+      target: id
+    })),
+    ...stale.providerIds.filter((id) => id in live).map((id) => ({ action: "remove", kind: "provider", target: id })),
+    ...stale.directories.map((path) => ({ action: "remove", kind: "dir", target: path }))
+  ];
+}
+async function setup(options = {}) {
+  const layout = resolveLayout(options, options.env);
+  const agents = options.agents ?? ["codex"];
+  const invalid = layoutChecks(layout, agents);
+  if (invalid.length > 0) return failed("setup", invalid);
+  const daemon = await checkDaemon(layout, options.env);
+  if (!daemon.daemon) return failed("setup", daemon.checks);
+  const desired = await buildDesired(layout, agents, ROLES);
+  const checks = [...daemon.checks, ...desired.checks];
+  if (hasFailure(checks)) return failed("setup", checks);
+  const stale = await staleFrom(layout, await readMarker(layout), agents, ROLES);
+  return withSession(daemon.daemon, async (session) => {
+    const operations = await planRoom(session, desired, stale);
+    const pending = operations.filter((operation) => operation.action !== "noop");
+    if (!options.apply) {
+      return {
+        command: "setup",
+        outcome: pending.length > 0 ? "changes-planned" : "ok",
+        changed: false,
+        checks,
+        operations
+      };
+    }
+    await applyEntries(desired.entries);
+    for (const path of stale.directories) await rm2(path, { recursive: true, force: true });
+    const ids = Object.keys(desired.providers);
+    await session.writeProviders(desired.providers);
+    if (stale.providerIds.length > 0) await session.removeProviders(stale.providerIds);
+    await session.refresh(ids);
+    return {
+      command: "setup",
+      outcome: "ok",
+      changed: pending.length > 0,
+      checks: [...checks, pass("room.applied", `Room ready at ${layout.roomHome} with ${String(ids.length)} Paseo providers.`)],
+      operations
+    };
+  }, sessionOptions(options));
+}
+async function verify(options = {}) {
+  const layout = resolveLayout(options, options.env);
+  const marker = await readMarker(layout);
+  if (!marker) {
+    return failed("verify", [fail("room.marker", `No room found at ${layout.roomHome}.`, "Run: paseo-room setup --apply")]);
+  }
+  const invalid = layoutChecks(layout, marker.agents);
+  if (invalid.length > 0) return failed("verify", invalid);
+  const daemon = await checkDaemon(layout, options.env);
+  if (!daemon.daemon) return failed("verify", daemon.checks);
+  const desired = await buildDesired(layout, marker.agents, marker.roles);
+  const checks = [...daemon.checks, ...desired.checks];
+  if (hasFailure(checks)) return failed("verify", checks);
+  return withSession(daemon.daemon, async (session) => {
+    const operations = await planRoom(session, desired, NOTHING_STALE);
+    const drifted = operations.filter((operation) => operation.action !== "noop");
+    const providers = drifted.filter((operation) => operation.kind === "provider").length;
+    const files = drifted.length - providers;
+    const all = [
+      ...checks,
+      files === 0 ? pass("room.files", "Every managed role file matches the current definition.") : fail("room.files", `${String(files)} managed role files are missing or outdated.`, "Run: paseo-room setup --apply"),
+      providers === 0 ? pass("room.providers", `All ${String(Object.keys(desired.providers).length)} Paseo providers are registered as expected.`) : fail("room.providers", `${String(providers)} Paseo providers are missing or differ.`, "Run: paseo-room setup --apply")
+    ];
+    return {
+      command: "verify",
+      outcome: hasFailure(all) ? "failed" : "ok",
+      changed: false,
+      checks: all,
+      operations
+    };
+  }, sessionOptions(options));
+}
+async function remove(options = {}) {
+  const layout = resolveLayout(options, options.env);
+  const marker = await readMarker(layout);
+  if (!marker) {
+    return failed("remove", [fail("room.marker", `No room found at ${layout.roomHome}.`, "Nothing to remove; the room home was never created here.")]);
+  }
+  const invalid = layoutChecks(layout, marker.agents);
+  if (invalid.length > 0) return failed("remove", invalid);
+  const ids = marker.agents.flatMap((agent) => marker.roles.map((role) => providerId(agent, role)));
+  const operations = [
+    ...ids.map((id) => ({ action: "remove", kind: "provider", target: id })),
+    { action: "remove", kind: "dir", target: layout.roomHome }
+  ];
+  if (!options.apply) {
+    return { command: "remove", outcome: "changes-planned", changed: false, checks: [], operations };
+  }
+  const daemon = await checkDaemon(layout, options.env);
+  const checks = [];
+  if (daemon.daemon) {
+    await withSession(daemon.daemon, (session) => session.removeProviders(ids), sessionOptions(options));
+    checks.push(pass("room.providers", `Removed ${String(ids.length)} Paseo providers.`));
+  } else {
+    checks.push({ id: "room.providers", status: "warn", message: "Paseo is unreachable; provider entries were left in place.", fix: "Start Paseo and run remove again to clear them." });
+  }
+  await rm2(layout.roomHome, { recursive: true, force: true });
+  checks.push(pass("room.files", `Deleted ${layout.roomHome}.`));
+  return { command: "remove", outcome: "ok", changed: true, checks, operations };
+}
+var AGENTS, NOTHING_STALE;
+var init_commands = __esm({
+  "src/commands.ts"() {
+    "use strict";
+    init_package();
+    init_claude();
+    init_codex();
+    init_fsops();
+    init_layout();
+    init_paseo();
+    init_result();
+    init_instructions();
+    init_room();
+    init_roles();
+    AGENTS = { codex: codexAgent, claude: claudeAgent };
+    NOTHING_STALE = { providerIds: [], directories: [] };
+  }
+});
+
+// src/wizard.ts
+var wizard_exports = {};
+__export(wizard_exports, {
+  runWizard: () => runWizard,
+  terminalPrompts: () => terminalPrompts
+});
+import * as clack from "@clack/prompts";
+async function runWizard(prompts, emit, write, options = {}) {
+  const cancelled = () => {
+    write("Cancelled; nothing was changed.\n");
+    return 0;
+  };
+  const action = await prompts.select({
+    message: "What do you want to do?",
+    options: [
+      { value: "setup", label: "Set up / update the room" },
+      { value: "verify", label: "Verify the current room" },
+      { value: "remove", label: "Remove the room" }
+    ]
+  });
+  if (typeof action === "symbol") return cancelled();
+  if (action === "verify") return emit(await verify(options));
+  if (action === "remove") {
+    const preview2 = await remove(options);
+    const status2 = emit(preview2);
+    if (preview2.outcome !== "changes-planned") return status2;
+    const approved2 = await prompts.confirm({ message: "Delete the room home and its Paseo providers?" });
+    return approved2 === true ? emit(await remove({ ...options, apply: true })) : cancelled();
+  }
+  const agents = await prompts.multiselect({
+    message: "Which coding agents should the room use?",
+    options: AGENT_IDS.map((value) => ({ value, label: AGENTS[value].label }))
+  });
+  if (typeof agents === "symbol" || agents.length === 0) return cancelled();
+  const preview = await setup({ ...options, agents });
+  const status = emit(preview);
+  if (preview.outcome !== "changes-planned") return status;
+  const approved = await prompts.confirm({ message: "Apply these changes?" });
+  if (approved !== true) return cancelled();
+  return emit(await setup({ ...options, agents, apply: true }));
+}
+var terminalPrompts;
+var init_wizard = __esm({
+  "src/wizard.ts"() {
+    "use strict";
+    init_commands();
+    init_roles();
+    terminalPrompts = {
+      select: (options) => clack.select({ message: options.message, options: [...options.options] }),
+      multiselect: (options) => clack.multiselect({ message: options.message, options: [...options.options], required: true }),
+      confirm: (options) => clack.confirm({ message: options.message, initialValue: false })
+    };
+  }
+});
+
+// src/cli.ts
+init_package();
+init_commands();
+import { Command, CommanderError } from "commander";
+
+// src/render.ts
+function renderJson(result) {
+  return `${JSON.stringify({ schemaVersion: 2, ...result }, null, 2)}
+`;
+}
+var ICONS = { pass: "\u2713", warn: "!", fail: "\u2717" };
+function renderHuman(result) {
+  const lines = [];
+  for (const check of result.checks) {
+    lines.push(`${ICONS[check.status]} ${check.message}`);
+    if (check.fix) lines.push(`  \u2192 ${check.fix}`);
+  }
+  const changes = result.operations.filter((operation) => operation.action !== "noop");
+  if (changes.length > 0) {
+    lines.push("", result.changed ? "Applied:" : "Planned changes:");
+    for (const operation of changes) lines.push(`  ${operation.action} ${operation.kind} ${operation.target}`);
+    const unchanged = result.operations.length - changes.length;
+    if (unchanged > 0) lines.push(`  (${String(unchanged)} already up to date)`);
+  } else if (result.operations.length > 0) {
+    lines.push("", "Everything is already up to date.");
+  }
+  lines.push("", `${result.command}: ${result.outcome}`);
+  return `${lines.join("\n")}
+`;
+}
+
+// src/cli.ts
+init_result();
+init_roles();
+function collectAgent(value, previous) {
+  const agent = AGENT_IDS.find((id) => id === value);
+  if (!agent) throw new CommanderError(2, "agent", `Unknown agent: ${value}`);
+  const seated = previous ?? [];
+  return seated.includes(agent) ? seated : [...seated, agent];
+}
+var PATH_FLAGS = ["roomHome", "codexHome", "claudeHome", "codexBin", "claudeBin", "paseoBin"];
+function optionsFrom(raw, base) {
+  const paths = {};
+  for (const flag of PATH_FLAGS) {
+    const value = raw[flag];
+    if (typeof value === "string" && value.trim()) paths[flag] = value.trim();
+  }
+  const agents = Array.isArray(raw.agent) && raw.agent.length > 0 ? raw.agent : void 0;
+  return { ...base, ...paths, ...agents ? { agents } : {}, ...raw.apply === true ? { apply: true } : {} };
+}
+async function runCli(argv, output, context = {}) {
+  const password = (context.options?.env ?? process.env).PASEO_PASSWORD;
+  const redact = (text) => password ? text.split(password).join("[redacted]") : text;
+  let json = false;
+  const emit = (result) => {
+    output.stdout(redact(json ? renderJson(result) : renderHuman(result)));
+    return exitCode(result);
+  };
+  const isTTY = context.isTTY ?? (process.stdin.isTTY && process.stdout.isTTY);
+  const base = context.options ?? {};
+  if (argv.length === 0) {
+    if (!isTTY) {
+      output.stderr("paseo-room: no command given. Try: paseo-room setup, verify, remove, or --help.\n");
+      return 2;
+    }
+    const { runWizard: runWizard2, terminalPrompts: terminalPrompts2 } = await Promise.resolve().then(() => (init_wizard(), wizard_exports));
+    return runWizard2(context.prompts ?? terminalPrompts2, emit, (text) => {
+      output.stdout(text);
+    }, base);
+  }
+  const program = new Command().name("paseo-room").description("Configure Codex/Claude role homes in $HOME and register them with your local Paseo daemon.").version(package_default.version).argument("<command>", "setup | verify | remove").option("--agent <agent>", "codex or claude; repeat for both (default: codex)", collectAgent).option("--apply", "actually make the changes (default: dry run)").option("--json", "machine-readable output").option("--room-home <path>", "where role homes are written (default: ~/.paseo-room)").option("--codex-home <path>", "source Codex config (default: ~/.codex)").option("--claude-home <path>", "source Claude Code config (default: ~/.claude)").option("--codex-bin <path>", "Codex executable (default: found on PATH)").option("--claude-bin <path>", "Claude Code executable (default: found on PATH)").option("--paseo-bin <path>", "Paseo executable (default: found on PATH)").configureOutput({ writeOut: (text) => {
+    output.stdout(text);
+  }, writeErr: (text) => {
+    output.stderr(text);
+  } }).exitOverride();
+  let command;
+  let options;
+  try {
+    program.parse([...argv], { from: "user" });
+    const raw = program.opts();
+    json = raw.json === true;
+    command = program.args[0] ?? "";
+    options = optionsFrom(raw, base);
+  } catch (error) {
+    if (error instanceof CommanderError && error.exitCode === 0) return 0;
+    return 2;
+  }
+  try {
+    if (command === "setup") return emit(await setup(options));
+    if (command === "verify") return emit(await verify(options));
+    if (command === "remove") return emit(await remove(options));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : "unknown error";
+    return emit(failed(command, [fail(`${command}.error`, redact(detail), "Check that Paseo is running and reachable, then try again.")]));
+  }
+  output.stderr(`paseo-room: unknown command "${command}". Try: setup, verify, remove.
+`);
+  return 2;
+}
+
+// src/index.ts
+process.exitCode = await runCli(process.argv.slice(2), {
+  stdout: (text) => {
+    process.stdout.write(text);
+  },
+  stderr: (text) => {
+    process.stderr.write(text);
+  }
+});
+//# sourceMappingURL=index.js.map