paseo-room 0.5.0 → 0.6.0

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "paseo-room",
-      version: "0.5.0",
+      version: "0.6.0",
       description: "One CLI that configures Codex, Claude Code, and Pi role homes in $HOME and registers them with your local Paseo daemon.",
       keywords: [
         "paseo",
@@ -45,17 +45,17 @@ var init_package = __esm({
         "dist/"
       ],
       scripts: {
-        typecheck: "tsc --noEmit",
+        typecheck: "tsc --noEmit && tsc -p src/runtime-plugin",
         lint: "eslint . --max-warnings 0",
         test: "vitest run",
         "test:package": "vitest run --config vitest.package.config.ts",
-        build: `tsup && node --input-type=module -e "import { cpSync, rmSync } from 'node:fs'; for (const [source, target] of [['src/room/prompts', 'dist/prompts'], ['src/room/skills', 'dist/skills'], ['src/plugin-assets', 'dist/plugin-assets']]) { rmSync(target, { recursive: true, force: true }); cpSync(source, target, { recursive: true }); }"`,
+        build: `tsup && node --input-type=module -e "import { cpSync, rmSync } from 'node:fs'; for (const [source, target] of [['src/room/prompts', 'dist/prompts'], ['src/room/skills', 'dist/skills'], ['src/plugin-assets', 'dist/plugin-assets'], ['src/runtime-plugin', 'dist/runtime-plugin']]) { rmSync(target, { recursive: true, force: true }); cpSync(source, target, { recursive: true }); }"`,
         prepack: "npm run build",
         verify: "npm run typecheck && npm run lint && npm test && npm run build && npm run test:package"
       },
       dependencies: {
         "@clack/prompts": "^1.8.0",
-        "@getpaseo/client": "0.8.0-beta.1",
+        "@getpaseo/client": "0.9.1",
         commander: "^14.0.3",
         semver: "^7.8.5",
         "smol-toml": "^1.8.0",
@@ -63,9 +63,14 @@ var init_package = __esm({
       },
       devDependencies: {
         "@eslint/js": "^10.0.1",
+        "@getpaseo/plugin": "0.9.1",
+        "@getpaseo/protocol": "0.9.1",
         "@types/node": "^22.0.0",
+        "@types/react": "19.2.2",
         "@types/semver": "^7.7.0",
         eslint: "^10.10.0",
+        react: "19.1.0",
+        "react-native": "0.81.5",
         tsup: "^8.5.1",
         typescript: "~5.9.3",
         "typescript-eslint": "^8.70.0",
@@ -76,14 +81,14 @@ var init_package = __esm({
 });
 
 // src/result.ts
-function pass(id, message) {
-  return { id, status: "pass", message };
+function pass(id2, message) {
+  return { id: id2, status: "pass", message };
 }
-function warn(id, message, fix) {
-  return { id, status: "warn", message, ...fix === void 0 ? {} : { fix } };
+function warn(id2, message, fix) {
+  return { id: id2, status: "warn", message, ...fix === void 0 ? {} : { fix } };
 }
-function fail(id, message, fix) {
-  return { id, status: "fail", message, fix };
+function fail(id2, message, fix) {
+  return { id: id2, status: "fail", message, fix };
 }
 function failed(command, checks) {
   return { command, outcome: "failed", changed: false, checks, operations: [] };
@@ -158,9 +163,9 @@ function preservedCredentialCheck(input) {
 function presentNames(names, supported) {
   return supported.filter((name) => names.has(name));
 }
-function ambientNamesCheck(id, agent, role, names) {
+function ambientNamesCheck(id2, agent, role, names) {
   return warn(
-    `${id}.ambient-auth-unverifiable`,
+    `${id2}.ambient-auth-unverifiable`,
     `${agent} ${role} auth: ambient auth unverifiable; ${names.join(", ")} ${names.length === 1 ? "is" : "are"} present by name in the setup process. paseo-room does not copy credential values into providers, so availability to the Paseo-launched role, token validity, and freshness were not checked.`
   );
 }
@@ -214,13 +219,13 @@ function layoutChecks(layout, agents) {
       "Point --room-home at a dedicated directory, by default ~/.paseo-room."
     ));
   }
-  for (const id of agents) {
-    const home = layout.agentHome[id];
+  for (const id2 of agents) {
+    const home = layout.agentHome[id2];
     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).`
+        `${id2}.home`,
+        `The ${id2} home ${home} overlaps the room home ${layout.roomHome}.`,
+        `Pass --${id2}-home pointing at your own ${id2} configuration (this happens when setup runs inside a room seat).`
       ));
     }
   }
@@ -444,13 +449,14 @@ function providerLabel(agent, role) {
   const title2 = (value) => value.charAt(0).toUpperCase() + value.slice(1);
   return `${title2(agent)} ${title2(role)}`;
 }
-var ROLES, AGENT_IDS, ROLE_PASEO_TOOLS, ROLE_THINKING, DELEGATING_THINKING, ROLE_ICON, ROLE_COLOR, ROLE_NOTES;
+var ROLES, AGENT_IDS, ROLE_PASEO_TOOLS, ROLE_PEER_REPORTING, ROLE_THINKING, DELEGATING_THINKING, ROLE_ICON, ROLE_COLOR, ROLE_NOTES;
 var init_roles = __esm({
   "src/roles.ts"() {
     "use strict";
     ROLES = ["supervisor", "lead", "peer"];
     AGENT_IDS = ["codex", "claude", "pi"];
     ROLE_PASEO_TOOLS = { supervisor: true, lead: true, peer: false };
+    ROLE_PEER_REPORTING = { supervisor: false, lead: false, peer: true };
     ROLE_THINKING = { supervisor: "low", lead: "high", peer: "high" };
     DELEGATING_THINKING = ["ultra", "ultracode"];
     ROLE_ICON = { supervisor: "eye", lead: "compass", peer: "code" };
@@ -466,14 +472,15 @@ var init_roles = __esm({
 // src/room.ts
 import { join as join3 } from "path";
 import { z } from "zod";
-function renderMarker(version, agents, roles, contract, claudeMemoryContract) {
+function renderMarker(version, agents, roles, contract, claudeMemoryContract, runtime) {
   return JSON.stringify({
     version,
     agents: [...agents],
     roles: [...roles],
     ...contract === void 0 ? {} : { contract },
     // Written only when it differs from the default, so an unchanged room's marker is unchanged.
-    ...claudeMemoryContract === false ? { claudeMemoryContract: false } : {}
+    ...claudeMemoryContract === false ? { claudeMemoryContract: false } : {},
+    ...runtime === void 0 ? {} : { runtime }
   }, null, 2) + "\n";
 }
 async function readMarker(layout) {
@@ -507,7 +514,12 @@ var init_room = __esm({
        * leaving the plugin as its only Claude carrier. Optional and defaulted to true so a room
        * written before the option existed keeps parsing and keeps its current behaviour.
        */
-      claudeMemoryContract: z.boolean().optional()
+      claudeMemoryContract: z.boolean().optional(),
+      /**
+       * Present only when this room opted in to runtime coordination. Missing means disabled, so a
+       * marker written before runtime existed keeps parsing and keeps its behaviour.
+       */
+      runtime: z.strictObject({ enabled: z.literal(true), generation: z.string().min(1), schema: z.literal(1) }).optional()
     });
   }
 });
@@ -677,12 +689,12 @@ async function loginRole(agentValue, roleValue, options, output) {
   }
   const childEnv = { ...env, ...invocation.env };
   const launch = options.spawn ?? spawnLogin;
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
-    const finish = (code) => {
+    const finish = (code2) => {
       if (settled) return;
       settled = true;
-      resolve4(code);
+      resolve5(code2);
     };
     let child;
     try {
@@ -704,9 +716,9 @@ async function loginRole(agentValue, roleValue, options, output) {
 `);
       finish(1);
     });
-    child.once("close", (code, signal) => {
-      if (code !== null) {
-        finish(code);
+    child.once("close", (code2, signal) => {
+      if (code2 !== null) {
+        finish(code2);
         return;
       }
       if (signal) {
@@ -962,11 +974,11 @@ function detectPaseoServers(servers) {
 function evidence(match) {
   return match.field === "name" ? `${match.server} (server name)` : `${match.server} (${match.field}: ${match.value})`;
 }
-function paseoMcpCheck(id, path, servers) {
+function paseoMcpCheck(id2, path, servers) {
   const matches = detectPaseoServers(servers);
   if (matches.length === 0) return void 0;
   return fail(
-    id,
+    id2,
     `${path} declares MCP servers that are recognizably Paseo-related: ${matches.map(evidence).join("; ")}.`,
     `Remove or rename those servers in ${path} so no room seat reaches Paseo outside its own seat, then run setup again. paseo-room never edits your MCP configuration, and this name check is a bounded heuristic rather than a sandbox.`
   );
@@ -1202,22 +1214,22 @@ async function claudeCredentialDiagnostic(layout, role, platform = process.platf
   const login = roleCommand(roleEnvironment, binary, ["auth", "login"]);
   const status = roleCommand(roleEnvironment, binary, ["auth", "status"]);
   const state = await inspectCredentialPath(path);
-  const id = `claude.auth.${role}`;
+  const id2 = `claude.auth.${role}`;
   if (state.kind !== "missing") {
-    return { path, checks: [preservedCredentialCheck({ id, agent: "Claude", role, path, state, login, status })] };
+    return { path, checks: [preservedCredentialCheck({ id: id2, agent: "Claude", role, path, state, login, status })] };
   }
   const ambient = presentNames(layout.envNames, AUTH_ENV);
-  if (ambient.length > 0) return { path, checks: [ambientNamesCheck(id, "Claude", role, ambient)] };
+  if (ambient.length > 0) return { path, checks: [ambientNamesCheck(id2, "Claude", role, ambient)] };
   if (platform === "darwin") {
     return { path, checks: [{
-      id: `${id}.native-keyring-unverifiable`,
+      id: `${id2}.native-keyring-unverifiable`,
       status: "warn",
       message: `Claude ${role} auth: native-keyring unverifiable; the current runtime's secure-storage location is pinned to this role home, but no Keychain entry was queried and older runtime behavior was not assumed. Token validity and freshness were not checked.`,
       fix: `Authenticate this role with: ${login}. If that subcommand is unavailable, launch ${roleCommand(roleEnvironment, binary)} and run /login. Check status with: ${status}.`
     }] };
   }
   return { path, checks: [{
-    id: `${id}.login-required`,
+    id: `${id2}.login-required`,
     status: "warn",
     message: `Claude ${role} auth: login-required; no role-owned .credentials.json or supported ambient auth environment name was detected. Authentication was not attempted.`,
     fix: `Authenticate this role with: ${login}. If that subcommand is unavailable, launch ${roleCommand(roleEnvironment, binary)} and run /login. Check status with: ${status}.`
@@ -1441,14 +1453,14 @@ async function credentialDiagnostic(layout, role, store, binary) {
   const login = roleCommand({ CODEX_HOME: home }, binary, ["login"]);
   const status = roleCommand({ CODEX_HOME: home }, binary, ["login", "status"]);
   const state = await inspectCredentialPath(path);
-  const id = `codex.auth.${role}`;
+  const id2 = `codex.auth.${role}`;
   const checks = [];
   if (state.kind !== "missing") {
-    checks.push(preservedCredentialCheck({ id, agent: "Codex", role, path, state, login, status }));
+    checks.push(preservedCredentialCheck({ id: id2, agent: "Codex", role, path, state, login, status }));
   } else {
     if (store === "keyring" || store === "auto") {
       checks.push({
-        id: `${id}.native-keyring-unverifiable`,
+        id: `${id2}.native-keyring-unverifiable`,
         status: "warn",
         message: `Codex ${role} auth: native-keyring unverifiable; cli_auth_credentials_store is ${store}, and no keyring was queried. Token validity and freshness were not checked.`,
         fix: `Authenticate this role with: ${login}. Check status with: ${status}.`
@@ -1457,7 +1469,7 @@ async function credentialDiagnostic(layout, role, store, binary) {
       const apiKey = layout.envNames.has("OPENAI_API_KEY") ? " OPENAI_API_KEY is present only in the setup process; Codex has not stored it for this role and paseo-room does not copy it into the provider." : "";
       const detail = store === "ephemeral" ? "cli_auth_credentials_store is ephemeral, so no persistent credential file is expected" : `no role-owned auth.json exists${store === "file" ? " for the configured file store" : ""}`;
       checks.push({
-        id: `${id}.login-required`,
+        id: `${id2}.login-required`,
         status: "warn",
         message: `Codex ${role} auth: login-required; ${detail}.${apiKey} Authentication was not attempted.`,
         fix: `Authenticate this role with: ${login}. Check status with: ${status}.`
@@ -1466,7 +1478,7 @@ async function credentialDiagnostic(layout, role, store, binary) {
   }
   if (state.kind !== "missing" && (store === "keyring" || store === "auto")) {
     checks.push({
-      id: `${id}.native-keyring-unverifiable`,
+      id: `${id2}.native-keyring-unverifiable`,
       status: "warn",
       message: `Codex ${role} auth: native-keyring unverifiable; cli_auth_credentials_store is ${store}, and the preserved auth.json does not prove what the runtime will use. No keyring was queried.`,
       fix: `Check status without exposing credentials: ${status}.`
@@ -1682,10 +1694,10 @@ function runProbeProcess(executable, adapterEntry, env, options, cwd) {
       clearTimeout(timer);
       resolveResult(result);
     };
-    const abort = (reason) => {
+    const abort = (reason3) => {
       if (settled) return;
       terminateProbe(child);
-      finish({ ok: false, stdout: Buffer.concat(stdout).toString("utf8"), reason });
+      finish({ ok: false, stdout: Buffer.concat(stdout).toString("utf8"), reason: reason3 });
     };
     const capture = (chunk, keep) => {
       if (settled) return;
@@ -1714,9 +1726,9 @@ function runProbeProcess(executable, adapterEntry, env, options, cwd) {
     child.on("error", () => {
       abort("failure");
     });
-    child.on("close", (code) => {
+    child.on("close", (code2) => {
       const output = Buffer.concat(stdout).toString("utf8");
-      finish(code === 0 ? { ok: true, stdout: output } : { ok: false, stdout: output, reason: "failure" });
+      finish(code2 === 0 ? { ok: true, stdout: output } : { ok: false, stdout: output, reason: "failure" });
     });
     child.stdin.on("error", () => {
     });
@@ -1805,12 +1817,12 @@ async function piCredentialDiagnostic(layout, role, binary = "pi") {
   const path = join10(home, "auth.json");
   const launch = piLoginCommand(home, binary);
   const state = await inspectCredentialPath(path);
-  const id = `pi.auth.${role}`;
+  const id2 = `pi.auth.${role}`;
   if (state.kind !== "missing") {
     return {
       path,
       checks: [preservedCredentialCheck({
-        id,
+        id: id2,
         agent: "Pi",
         role,
         path,
@@ -1820,9 +1832,9 @@ async function piCredentialDiagnostic(layout, role, binary = "pi") {
     };
   }
   const configured = presentNames(layout.envNames, AUTH_ENV2);
-  if (configured.length > 0) return { path, checks: [ambientNamesCheck(id, "Pi", role, configured)] };
+  if (configured.length > 0) return { path, checks: [ambientNamesCheck(id2, "Pi", role, configured)] };
   return { path, checks: [{
-    id: `${id}.login-required`,
+    id: `${id2}.login-required`,
     status: "warn",
     message: `Pi ${role} auth: login-required; no role-owned auth.json or known provider environment name was detected. Ambient provider auth may exist, but it was not inspected or validated.`,
     fix: `Start a minimal, non-room-equivalent interactive login session with: ${launch}. Run /login, then exit Pi.`
@@ -1994,8 +2006,8 @@ var init_pi = __esm({
 // src/paseo.ts
 import { gte, valid } from "semver";
 import { z as z2 } from "zod";
-function minimumPaseoVersion(agents) {
-  return agents.includes("pi") || agents.includes("claude") ? PI_MINIMUM_VERSION : MINIMUM_VERSION;
+function minimumPaseoVersion(agents, runtime = false) {
+  return runtime || agents.includes("pi") || agents.includes("claude") ? PI_MINIMUM_VERSION : MINIMUM_VERSION;
 }
 function normalizeUrl(listen) {
   const match = /^(?:ws:\/\/)?([^:/]+|\[[^\]]+\]):(\d+)$/.exec(listen.trim());
@@ -2004,7 +2016,7 @@ function normalizeUrl(listen) {
   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, minimumVersion = MINIMUM_VERSION) {
+function assessStatus(raw, minimumVersion = MINIMUM_VERSION, cliVersion) {
   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")] };
@@ -2013,8 +2025,8 @@ function assessStatus(raw, minimumVersion = MINIMUM_VERSION) {
   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);
+  const cli = valid(status.cliVersion ?? 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.")] };
   }
@@ -2044,11 +2056,16 @@ async function checkDaemon(layout, env = process.env, minimumVersion = MINIMUM_V
   if (!output.ok) {
     return { checks: [fail("paseo.status", "Could not read Paseo daemon status.", "Run: paseo daemon status --json")] };
   }
+  let status;
   try {
-    return assessStatus(JSON.parse(output.stdout), minimumVersion);
+    status = JSON.parse(output.stdout);
   } catch {
     return assessStatus(void 0, minimumVersion);
   }
+  const reported = status?.cliVersion;
+  if (typeof reported === "string") return assessStatus(status, minimumVersion);
+  const version = await probe(binary, ["--version"], { HOME: layout.home, PATH: layout.searchPath });
+  return assessStatus(status, minimumVersion, version.ok ? version.stdout.trim() : void 0);
 }
 async function withSession(daemon, run2, options = {}) {
   const quiet = { debug() {
@@ -2072,7 +2089,13 @@ async function withSession(daemon, run2, options = {}) {
       import("@getpaseo/client"),
       import("@getpaseo/client/internal/daemon-client")
     ]);
-    const raw = new DaemonClient({ ...clientConfig, clientId: `paseo-room-${String(process.pid)}`, clientType: "cli" });
+    const { capabilities, ...config } = clientConfig;
+    const raw = new DaemonClient({
+      ...config,
+      ...capabilities === void 0 ? {} : { capabilities },
+      clientId: `paseo-room-${String(process.pid)}`,
+      clientType: "cli"
+    });
     client = {
       ...createPaseoApi(raw),
       connect: () => raw.connect(),
@@ -2082,10 +2105,10 @@ async function withSession(daemon, run2, options = {}) {
       },
       getConnectionState: () => raw.getConnectionState(),
       listPlugins: () => raw.listPlugins(),
-      installDirectoryPlugin: (path, id) => raw.installDirectoryPlugin(path, id),
-      reloadPlugin: (id) => raw.reloadPlugin(id),
-      enablePlugin: (id) => raw.enablePlugin(id),
-      removePlugin: (id) => raw.removePlugin(id)
+      installDirectoryPlugin: (path, id2) => raw.installDirectoryPlugin(path, id2),
+      reloadPlugin: (id2) => raw.reloadPlugin(id2),
+      enablePlugin: (id2) => raw.enablePlugin(id2),
+      removePlugin: (id2) => raw.removePlugin(id2)
     };
   }
   try {
@@ -2115,17 +2138,17 @@ async function withSession(daemon, run2, options = {}) {
       async listPlugins() {
         return await client.listPlugins();
       },
-      async installPlugin(path, id) {
-        return await client.installDirectoryPlugin(path, id);
+      async installPlugin(path, id2) {
+        return await client.installDirectoryPlugin(path, id2);
       },
-      async reloadPlugin(id) {
-        return await client.reloadPlugin(id);
+      async reloadPlugin(id2) {
+        return await client.reloadPlugin(id2);
       },
-      async enablePlugin(id) {
-        return await client.enablePlugin(id);
+      async enablePlugin(id2) {
+        return await client.enablePlugin(id2);
       },
-      async removePlugin(id) {
-        await client.removePlugin(id);
+      async removePlugin(id2) {
+        await client.removePlugin(id2);
       },
       async refresh(ids) {
         await client.providers.refresh({ providers: [...ids] });
@@ -2185,9 +2208,9 @@ var init_paseo = __esm({
     PI_MINIMUM_VERSION = "0.8.0";
     statusSchema = z2.object({
       listen: z2.string().min(1),
-      localDaemon: z2.enum(["running", "stopped", "stale_pid", "unresponsive"]),
-      cliVersion: z2.string(),
-      daemonVersion: z2.string().nullable()
+      localDaemon: z2.string().min(1),
+      cliVersion: z2.string().optional(),
+      daemonVersion: z2.string().nullish()
     });
     configSchema = z2.object({
       config: z2.object({
@@ -2215,8 +2238,8 @@ function typescriptTemplateLiteral(value) {
 }
 function renderClaudeCarrierContract(roles) {
   const entries = roles.map((role) => {
-    const id = JSON.stringify(providerId("claude", role));
-    return `  ${id}: ${typescriptTemplateLiteral(renderInstructions(role))},`;
+    const id2 = JSON.stringify(providerId("claude", role));
+    return `  ${id2}: ${typescriptTemplateLiteral(renderInstructions(role))},`;
   });
   return [
     "/** Generated by paseo-room. The Markdown prompt assets remain authoritative. */",
@@ -2236,13 +2259,14 @@ function claudeCarrierEntries(layout, roles) {
     { kind: "file", path: join11(root, "server", "contract.ts"), content: renderClaudeCarrierContract(roles) }
   ];
 }
-var CLAUDE_CARRIER_PLUGIN_ID, STATIC_ASSETS;
+var CLAUDE_CARRIER_PLUGIN_ID, CLAUDE_CARRIER_PASEO_RANGE, STATIC_ASSETS;
 var init_plugin = __esm({
   "src/plugin.ts"() {
     "use strict";
     init_roles();
     init_instructions();
     CLAUDE_CARRIER_PLUGIN_ID = "paseo-room-claude-carrier";
+    CLAUDE_CARRIER_PASEO_RANGE = ">=0.8.0 <0.10.0";
     STATIC_ASSETS = [
       "paseo-plugin.json",
       "package.json",
@@ -2253,9 +2277,1312 @@ var init_plugin = __esm({
   }
 });
 
+// src/runtime-plugin/shared/policy.ts
+function runtimeRolePolicy(role, peerReportingEligible) {
+  if (role === "supervisor") return { capabilities: [...SUPERVISOR_OPERATIONS] };
+  if (role === "lead") return { capabilities: [...LEAD_OPERATIONS] };
+  return peerReportingEligible ? { capabilities: [...PEER_REPORTING_TOOLS], peerReporting: PEER_REPORTING_DECLARATION } : { capabilities: [] };
+}
+var RUNTIME_ROLES, RUNTIME_AGENTS, SUPERVISOR_OPERATIONS, LEAD_OPERATIONS, PEER_REPORTING_TOOLS, RUNTIME_CAPABILITIES, PEER_REPORTING_DECLARATION;
+var init_policy = __esm({
+  "src/runtime-plugin/shared/policy.ts"() {
+    "use strict";
+    RUNTIME_ROLES = ["supervisor", "lead", "peer"];
+    RUNTIME_AGENTS = ["codex", "claude", "pi"];
+    SUPERVISOR_OPERATIONS = ["room_status", "runtime_findings", "message_lead"];
+    LEAD_OPERATIONS = [
+      "assignment_create",
+      "assignment_dispatch",
+      "assignment_answer",
+      "assignment_rework",
+      "assignment_accept",
+      "assignment_reject",
+      "assignment_abandon",
+      "assignment_close",
+      "assignment_status",
+      "gate_run"
+    ];
+    PEER_REPORTING_TOOLS = ["ask", "handoff"];
+    RUNTIME_CAPABILITIES = [
+      ...SUPERVISOR_OPERATIONS,
+      ...LEAD_OPERATIONS,
+      ...PEER_REPORTING_TOOLS
+    ];
+    PEER_REPORTING_DECLARATION = {
+      protocol: 1,
+      tools: ["ask", "handoff"],
+      qualifiedVia: "exact-room-provider"
+    };
+  }
+});
+
+// src/runtime-plugin/shared/manifest.ts
+import { z as z3 } from "zod";
+var MANIFEST_FILE, generation, peerReportingSchema, providerSchema, providerId2, runtimeRoomManifestSchema;
+var init_manifest = __esm({
+  "src/runtime-plugin/shared/manifest.ts"() {
+    "use strict";
+    init_policy();
+    MANIFEST_FILE = "generated/room-manifest.json";
+    generation = z3.string().min(1).max(256);
+    peerReportingSchema = z3.strictObject({
+      protocol: z3.literal(1),
+      tools: z3.tuple([z3.literal(PEER_REPORTING_TOOLS[0]), z3.literal(PEER_REPORTING_TOOLS[1])]),
+      qualifiedVia: z3.literal("exact-room-provider")
+    });
+    providerSchema = z3.strictObject({
+      agent: z3.enum(RUNTIME_AGENTS),
+      role: z3.enum(RUNTIME_ROLES),
+      capabilities: z3.array(z3.enum(RUNTIME_CAPABILITIES)),
+      peerReporting: peerReportingSchema.optional()
+    }).superRefine((entry, context) => {
+      const eligible = entry.role === "peer" && entry.peerReporting !== void 0;
+      const expected = runtimeRolePolicy(entry.role, eligible);
+      if (JSON.stringify(entry.capabilities) !== JSON.stringify(expected.capabilities)) {
+        context.addIssue({ code: "custom", message: `capabilities do not match the ${entry.role} runtime policy` });
+      }
+      if (entry.peerReporting !== void 0 && entry.role !== "peer") {
+        context.addIssue({ code: "custom", message: "peerReporting is only valid on a Peer entry" });
+      }
+    });
+    providerId2 = z3.string().regex(/^[a-z0-9][a-z0-9-]*$/).max(128);
+    runtimeRoomManifestSchema = z3.strictObject({
+      schema: z3.literal(1),
+      roomGeneration: generation,
+      contractGeneration: generation,
+      reportingPolicyGeneration: generation,
+      providers: z3.record(providerId2, providerSchema)
+    });
+  }
+});
+
+// src/runtime-plugin/shared/identity.ts
+var RUNTIME_PLUGIN_ID, RUNTIME_PASEO_RANGE;
+var init_identity = __esm({
+  "src/runtime-plugin/shared/identity.ts"() {
+    "use strict";
+    RUNTIME_PLUGIN_ID = "paseo-room-runtime";
+    RUNTIME_PASEO_RANGE = ">=0.8.0 <0.10.0";
+  }
+});
+
+// src/runtime.ts
+import { createHash as createHash2 } from "crypto";
+import { readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join12, relative, sep as sep2 } from "path";
+import { fileURLToPath } from "url";
+function runtimePluginDir(layout) {
+  return join12(layout.roomHome, "runtime-plugin");
+}
+function digest(value) {
+  return `sha256:${createHash2("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 16)}`;
+}
+function reportingPolicy() {
+  return {
+    supervisor: runtimeRolePolicy("supervisor", ROLE_PEER_REPORTING.supervisor),
+    lead: runtimeRolePolicy("lead", ROLE_PEER_REPORTING.lead),
+    peer: runtimeRolePolicy("peer", ROLE_PEER_REPORTING.peer)
+  };
+}
+function reportingPolicyGeneration() {
+  return digest(reportingPolicy());
+}
+function renderRuntimeManifest(agents, roles) {
+  const policy = reportingPolicy();
+  const providers = {};
+  for (const agent of agents) {
+    for (const role of roles) {
+      const { capabilities, peerReporting } = policy[role];
+      providers[providerId(agent, role)] = {
+        agent,
+        role,
+        capabilities: [...capabilities],
+        ...peerReporting === void 0 ? {} : { peerReporting: { ...peerReporting, tools: ["ask", "handoff"] } }
+      };
+    }
+  }
+  const contractGeneration = contractDigest();
+  return runtimeRoomManifestSchema.parse({
+    schema: 1,
+    roomGeneration: digest({ agents: [...agents], roles: [...roles], contractGeneration }),
+    contractGeneration,
+    reportingPolicyGeneration: reportingPolicyGeneration(),
+    providers
+  });
+}
+function renderRuntimeManifestFile(agents, roles) {
+  return `${JSON.stringify(renderRuntimeManifest(agents, roles), null, 2)}
+`;
+}
+function renderRuntimeLocation(layout) {
+  const location = { pluginDirectory: runtimePluginDir(layout), runtimeRoot: join12(layout.roomHome, "runtime", "v1") };
+  return [
+    "/** Generated by paseo-room setup for this room. */",
+    "export interface RoomLocation {",
+    "  readonly pluginDirectory: string;",
+    "  readonly runtimeRoot: string;",
+    "}",
+    "",
+    `export const ROOM_LOCATION: RoomLocation | undefined = ${JSON.stringify(location)};`,
+    ""
+  ].join("\n");
+}
+function bundleInventory() {
+  const entries = readdirSync(BUNDLE, { recursive: true, withFileTypes: true });
+  const toRelative = (entry) => relative(BUNDLE, join12(entry.parentPath, entry.name)).split(sep2).join("/");
+  return {
+    dirs: entries.filter((entry) => entry.isDirectory()).map(toRelative).sort(),
+    files: entries.filter((entry) => entry.isFile()).map(toRelative).sort()
+  };
+}
+function runtimePluginEntries(layout, agents, roles) {
+  const root = runtimePluginDir(layout);
+  const { dirs, files } = bundleInventory();
+  const generatedDir = MANIFEST_FILE.split("/").slice(0, -1).join("/");
+  return [
+    { kind: "dir", path: root },
+    ...[.../* @__PURE__ */ new Set([...dirs, generatedDir])].sort().map((path) => ({ kind: "dir", path: join12(root, path) })),
+    ...files.map((path) => ({
+      kind: "file",
+      path: join12(root, path),
+      content: path === LOCATION_MODULE ? renderRuntimeLocation(layout) : readFileSync4(join12(BUNDLE, path), "utf8")
+    })),
+    { kind: "file", path: join12(root, MANIFEST_FILE), content: renderRuntimeManifestFile(agents, roles) }
+  ];
+}
+var BUNDLE, LOCATION_MODULE;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    "use strict";
+    init_roles();
+    init_instructions();
+    init_manifest();
+    init_identity();
+    init_policy();
+    BUNDLE = fileURLToPath(new URL("./runtime-plugin/", import.meta.url));
+    LOCATION_MODULE = "server/generated/location.ts";
+  }
+});
+
+// src/runtime-plugin/server/domain/state.ts
+function emptyProjectState(projectId) {
+  return { projectId, assignments: /* @__PURE__ */ new Map(), ownership: /* @__PURE__ */ new Map(), notices: /* @__PURE__ */ new Map(), lastSequence: 0 };
+}
+function activeWriter(state) {
+  for (const owner of state.ownership.values()) if (owner.state !== "released") return owner;
+  return void 0;
+}
+function need(condition, message) {
+  return condition ? void 0 : message;
+}
+function assignmentOf(state, event) {
+  return event.assignmentId === void 0 ? void 0 : state.assignments.get(event.assignmentId);
+}
+function inState(assignment2, allowed, action) {
+  return need(allowed.includes(assignment2.state), `Cannot ${action} while the assignment is ${assignment2.state}.`);
+}
+function checkEvent(state, event) {
+  if (event.projectId !== state.projectId) return "Event belongs to another project.";
+  switch (event.type) {
+    case "project.bound":
+      return need(state.binding === void 0, "The project is already bound.");
+    case "project.rebound":
+      return need(state.binding !== void 0, "Only a bound project can be rebound.");
+    case "project.ownership-conflict":
+      return void 0;
+    case "project.ownership-resolved":
+      return need(state.ownershipConflict !== void 0, "There is no ownership conflict to resolve.");
+    case "notice.pending":
+      return need(!state.notices.has(event.data.noticeId), `Notice ${event.data.noticeId} already exists.`);
+    case "notice.sent":
+    case "notice.failed":
+    case "notice.uncertain":
+      return need(state.notices.has(event.data.noticeId), `Unknown notice ${event.data.noticeId}.`);
+    default:
+      break;
+  }
+  if (event.type === "assignment.created") {
+    if (event.assignmentId === void 0) return "An assignment event needs an assignment id.";
+    return need(!state.assignments.has(event.assignmentId), `Assignment ${event.assignmentId} already exists.`);
+  }
+  const assignment2 = assignmentOf(state, event);
+  if (assignment2 === void 0) return `Event ${event.type} names no known assignment.`;
+  const owner = state.ownership.get(assignment2.id);
+  const writable = assignment2.input.mode === "writable";
+  switch (event.type) {
+    case "assignment.dispatch-requested":
+      return inState(assignment2, ["draft"], "dispatch") ?? need(state.ownershipConflict === void 0, "Dispatch is paused by a Lead ownership conflict.") ?? need(!writable || activeWriter(state) === void 0, "Another writer still owns this project.");
+    case "ownership.reserved":
+      return need(writable, "A read-only assignment reserves no writer ownership.") ?? inState(assignment2, ["dispatching"], "reserve ownership") ?? need(activeWriter(state) === void 0, "Another writer still owns this project.");
+    case "agent.create-requested":
+      return inState(assignment2, ["dispatching"], "create the Peer") ?? need(!writable || owner?.state === "reserved", "A writable Peer is created only after ownership is reserved.") ?? need(assignment2.peerAgentId === void 0, "This assignment already has a Peer.");
+    case "agent.create-succeeded":
+    case "agent.create-failed":
+    case "agent.create-uncertain":
+      return need(assignment2.openIntents[event.data.intentId] === "agent.create-requested" || assignment2.state === "uncertain" && event.type !== "agent.create-uncertain", "No unresolved create intent matches.");
+    case "binding.refused":
+      return inState(assignment2, ["dispatching"], "refuse the Peer binding") ?? need(assignment2.peerAgentId === event.data.agentId, "The refusal names a different agent than the one created.");
+    case "binding.published":
+      return inState(assignment2, ["dispatching"], "bind the Peer") ?? need(assignment2.peerAgentId === event.data.agentId, "The binding names a different agent than the one created.");
+    case "ownership.held":
+      return need(owner?.state === "reserved", "Only reserved ownership becomes held.") ?? need(assignment2.peerAgentId === event.data.agentId && assignment2.observedProviderId !== void 0, "Ownership is held only by the bound Peer.");
+    case "reporting.generation-opened": {
+      const from = {
+        initial: ["dispatching"],
+        answer: ["questioned"],
+        "follow-up": ["blocked"],
+        rework: ["rework"]
+      };
+      return inState(assignment2, from[event.data.turn], `open a ${event.data.turn} reporting generation`) ?? need(event.data.generation === assignment2.reportingGeneration + 1, "Reporting generations increase by exactly one.") ?? need(assignment2.reportingState === "closed" || assignment2.reportingState === "consumed", "The previous reporting generation is not terminal.") ?? need(assignment2.observedProviderId !== void 0, "No proven Peer binding exists.") ?? need(!writable || owner?.state === "held", "A writable Peer needs held ownership before any turn.");
+    }
+    case "run.requested":
+      return need(event.data.generation === assignment2.reportingGeneration && assignment2.reportingState === "open", "A run must use the open reporting generation.") ?? need(assignment2.runGeneration < event.data.generation, "This reporting generation already has its run.") ?? need(!Object.values(assignment2.openIntents).includes("run.requested"), "Another run is still unresolved.");
+    case "run.succeeded":
+    case "run.failed":
+    case "run.uncertain":
+      return need(assignment2.openIntents[event.data.intentId] === "run.requested" || assignment2.state === "uncertain" && event.type !== "run.uncertain", "No unresolved run intent matches.");
+    case "report.accepted":
+      return need(event.data.generation === assignment2.reportingGeneration, "The report names a stale generation.") ?? need(assignment2.reportingState === "open" || assignment2.reportingState === "uncertain", "The reporting generation is not open.") ?? inState(assignment2, ["active", "awaiting-permission", "uncertain"], "accept a report");
+    case "report.refused":
+      return void 0;
+    case "report.missing":
+      return need(event.data.generation === assignment2.reportingGeneration, "Missing report names a stale generation.") ?? need(assignment2.reportingState === "open" || assignment2.reportingState === "uncertain", "The reporting generation is not open.") ?? inState(assignment2, ["active", "awaiting-permission", "uncertain"], "record a missing report");
+    case "report.uncertain":
+      return need(event.data.generation === assignment2.reportingGeneration, "Uncertain report names a stale generation.");
+    case "permission.awaiting":
+      return inState(assignment2, ["active"], "await a reporting permission") ?? need(event.data.generation === assignment2.reportingGeneration && assignment2.reportingState === "open", "Permission applies only to the open generation.");
+    case "permission.resolved":
+      return inState(assignment2, ["awaiting-permission"], "resolve a permission") ?? need(assignment2.awaitingPermissionId === event.data.permissionRequestId, "A different permission request is outstanding.");
+    case "assignment.answered":
+      return inState(assignment2, ["questioned", "blocked"], "answer");
+    case "assignment.rework-requested":
+      return inState(assignment2, ["handed-back"], "request rework");
+    case "assignment.accepted":
+      return inState(assignment2, ["handed-back"], "accept");
+    case "assignment.rejected":
+      return inState(assignment2, ["handed-back"], "reject");
+    case "assignment.abandoned":
+      if (assignment2.state === "uncertain") {
+        return need(assignment2.reportingState !== "open" && assignment2.reportingState !== "uncertain", "Abandon an uncertain assignment only after its generation is terminal.") ?? need(assignment2.closure === "closing" || assignment2.closure === "uncertain", "Abandon an uncertain assignment only after archive is requested.");
+      }
+      return inState(assignment2, ["draft", "questioned", "blocked", "handed-back", "rework"], "abandon");
+    case "assignment.close-requested":
+      return need(TERMINAL_STATES.includes(assignment2.state) || assignment2.state === "uncertain", "Close an assignment only after a technical decision or while it is uncertain.") ?? need(assignment2.closure === "open" || assignment2.closure === "uncertain", "The assignment is already closing or closed.");
+    case "archive.requested":
+      return need(assignment2.closure === "closing" || assignment2.closure === "uncertain", "Archive follows a close request.") ?? need(assignment2.peerAgentId === event.data.agentId, "Archive names a different agent.") ?? need(!Object.values(assignment2.openIntents).includes("archive.requested"), "Another archive is still unresolved.");
+    case "archive.succeeded":
+    case "archive.failed":
+    case "archive.uncertain":
+      return need(assignment2.openIntents[event.data.intentId] === "archive.requested" || assignment2.closure === "uncertain" && event.type !== "archive.uncertain", "No unresolved archive intent matches.");
+    case "ownership.releasing":
+      return need(owner?.state === "held", "Only held ownership starts releasing.") ?? need(assignment2.closure === "closing", "Release starts only after a close request.");
+    case "ownership.released":
+      return need(owner?.state === "releasing" || owner?.state === "uncertain", "Only releasing or uncertain ownership is released.") ?? need(assignment2.closure === "closed", "Ownership is released only after archive is proven.");
+    case "ownership.uncertain":
+      return need(owner !== void 0 && owner.state !== "released", "No unreleased ownership to mark uncertain.");
+    case "gate.requested":
+      return inState(assignment2, ["handed-back"], "run a gate") ?? need(assignment2.candidate !== void 0 && assignment2.candidate.commit === event.data.candidate.commit, "A gate runs only against the projected candidate.") ?? need(!assignment2.gates.some((gate) => gate.status === "running"), "Another gate is still running.");
+    case "gate.finished":
+      return need(assignment2.gates.some((gate) => gate.gateRunId === event.data.result.id && gate.status !== "finished"), "No unsettled gate matches.");
+    case "gate.uncertain":
+      return need(assignment2.gates.some((gate) => gate.gateRunId === event.data.gateRunId && gate.status === "running"), "No running gate matches.");
+    default: {
+      const exhaustive = event;
+      return `Unhandled event ${exhaustive.type}.`;
+    }
+  }
+}
+function update(state, id2, change, event) {
+  const current2 = state.assignments.get(id2);
+  if (current2 === void 0) return;
+  state.assignments.set(id2, { ...current2, ...change, eventIds: [...current2.eventIds, event.id] });
+}
+function withIntent(view, intentId, type) {
+  const next = { ...view.openIntents };
+  if (type === void 0) Reflect.deleteProperty(next, intentId);
+  else next[intentId] = type;
+  return next;
+}
+function withoutPermission(view) {
+  const copy = { ...view };
+  delete copy.awaitingPermissionId;
+  return copy;
+}
+function setOwner(state, id2, change) {
+  const current2 = state.ownership.get(id2);
+  if (current2 !== void 0) state.ownership.set(id2, { ...current2, ...change });
+}
+function applyReport(state, view, event) {
+  const report = {
+    generation: event.data.generation,
+    tool: event.data.tool,
+    requestId: event.data.requestId,
+    fingerprint: event.data.fingerprint,
+    receipt: event.data.receipt,
+    report: event.data.report,
+    eventId: event.id
+  };
+  update(state, view.id, {
+    state: event.data.receipt.assignmentState,
+    reportingState: "consumed",
+    reports: [...view.reports, report],
+    ...event.data.candidate === void 0 ? {} : { candidate: event.data.candidate },
+    ...event.data.inspectedCommit === void 0 ? {} : { inspectedCommit: event.data.inspectedCommit }
+  }, event);
+}
+function applyEvent(state, event) {
+  state.lastSequence = Math.max(state.lastSequence, event.sequence);
+  switch (event.type) {
+    case "project.bound":
+    case "project.rebound":
+      state.binding = { canonicalRoot: event.data.canonicalRoot, gitCommonDir: event.data.gitCommonDir };
+      return;
+    case "project.ownership-conflict":
+      state.ownershipConflict = { leadAgentIds: event.data.leadAgentIds, eventId: event.id };
+      return;
+    case "project.ownership-resolved":
+      delete state.ownershipConflict;
+      return;
+    case "notice.pending":
+      state.notices.set(event.data.noticeId, {
+        noticeId: event.data.noticeId,
+        kind: event.data.kind,
+        class: event.data.class,
+        state: "pending",
+        eventId: event.id,
+        ...event.assignmentId === void 0 ? {} : { assignmentId: event.assignmentId }
+      });
+      return;
+    case "notice.sent":
+    case "notice.failed":
+    case "notice.uncertain": {
+      const notice = state.notices.get(event.data.noticeId);
+      if (notice !== void 0) state.notices.set(notice.noticeId, { ...notice, state: event.type === "notice.sent" ? "sent" : event.type === "notice.failed" ? "failed" : "uncertain" });
+      return;
+    }
+    case "assignment.created":
+      if (event.assignmentId === void 0) return;
+      state.assignments.set(event.assignmentId, {
+        id: event.assignmentId,
+        input: event.data.input,
+        leadAgentId: event.data.leadAgentId,
+        leadProviderId: event.data.leadProviderId,
+        state: "draft",
+        closure: "open",
+        reportingGeneration: 0,
+        reportingState: "closed",
+        runGeneration: 0,
+        reports: [],
+        gates: [],
+        openIntents: {},
+        eventIds: [event.id]
+      });
+      return;
+    default:
+      break;
+  }
+  const view = assignmentOf(state, event);
+  if (view === void 0) return;
+  const id2 = view.id;
+  switch (event.type) {
+    case "assignment.dispatch-requested":
+      update(state, id2, { state: "dispatching", peerProviderId: event.data.peerProviderId, workspaceId: event.data.workspaceId }, event);
+      return;
+    case "ownership.reserved":
+      state.ownership.set(id2, { assignmentId: id2, workspaceId: event.data.workspaceId, baseCommit: event.data.baseCommit, state: "reserved" });
+      update(state, id2, {}, event);
+      return;
+    case "agent.create-requested":
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, event.type) }, event);
+      return;
+    case "agent.create-succeeded":
+      update(state, id2, { peerAgentId: event.data.agentId, openIntents: withIntent(view, event.data.intentId, void 0), ...view.state === "uncertain" ? { state: "dispatching" } : {} }, event);
+      return;
+    case "agent.create-failed": {
+      const owner = state.ownership.get(id2);
+      if (owner?.state === "reserved" || owner?.state === "uncertain" && owner.agentId === void 0) setOwner(state, id2, { state: "released" });
+      update(state, id2, { state: "blocked", openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    }
+    case "agent.create-uncertain":
+      setOwner(state, id2, { state: "uncertain" });
+      update(state, id2, { state: "uncertain" }, event);
+      return;
+    case "binding.refused":
+      setOwner(state, id2, { state: "uncertain", agentId: event.data.agentId });
+      update(state, id2, { state: "uncertain" }, event);
+      return;
+    case "binding.published":
+      update(state, id2, { observedProviderId: event.data.providerId, observedModel: event.data.model, workspaceId: event.data.workspaceId }, event);
+      return;
+    case "ownership.held":
+      setOwner(state, id2, { state: "held", agentId: event.data.agentId });
+      update(state, id2, {}, event);
+      return;
+    case "reporting.generation-opened":
+      update(state, id2, { reportingGeneration: event.data.generation, reportingState: "open" }, event);
+      return;
+    case "run.requested":
+      update(state, id2, { state: "active", runGeneration: event.data.generation, openIntents: withIntent(view, event.data.intentId, event.type) }, event);
+      return;
+    case "run.succeeded":
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, void 0), ...view.state === "uncertain" ? { state: "active", reportingState: "open" } : {} }, event);
+      return;
+    case "run.failed":
+      update(state, id2, { state: "blocked", reportingState: "consumed", openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "run.uncertain":
+      update(state, id2, { state: "uncertain", reportingState: "uncertain" }, event);
+      return;
+    case "report.accepted":
+      applyReport(state, view, event);
+      return;
+    case "report.refused":
+      update(state, id2, {}, event);
+      return;
+    case "report.missing":
+      state.assignments.set(id2, { ...withoutPermission(view), state: "blocked", reportingState: "consumed", eventIds: [...view.eventIds, event.id] });
+      return;
+    case "report.uncertain":
+      update(state, id2, { state: "uncertain", reportingState: "uncertain" }, event);
+      return;
+    case "permission.awaiting":
+      update(state, id2, { state: "awaiting-permission", awaitingPermissionId: event.data.permissionRequestId }, event);
+      return;
+    case "permission.resolved":
+      state.assignments.set(id2, { ...withoutPermission(view), state: "active", eventIds: [...view.eventIds, event.id] });
+      return;
+    case "assignment.answered":
+      update(state, id2, {}, event);
+      return;
+    case "assignment.rework-requested":
+      update(state, id2, { state: "rework" }, event);
+      return;
+    case "assignment.accepted":
+    case "assignment.rejected":
+    case "assignment.abandoned": {
+      const type = event.type === "assignment.accepted" ? "accepted" : event.type === "assignment.rejected" ? "rejected" : "abandoned";
+      update(state, id2, { state: type, decision: { type, eventId: event.id } }, event);
+      return;
+    }
+    case "assignment.close-requested":
+      update(state, id2, { closure: "closing" }, event);
+      return;
+    case "archive.requested":
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, event.type) }, event);
+      return;
+    case "archive.succeeded":
+      update(state, id2, { closure: "closed", openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "archive.failed":
+      update(state, id2, { closure: "uncertain", openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "archive.uncertain":
+      update(state, id2, { closure: "uncertain" }, event);
+      return;
+    case "ownership.releasing":
+      setOwner(state, id2, { state: "releasing" });
+      update(state, id2, {}, event);
+      return;
+    case "ownership.released":
+      setOwner(state, id2, { state: "released" });
+      update(state, id2, {}, event);
+      return;
+    case "ownership.uncertain":
+      setOwner(state, id2, { state: "uncertain" });
+      update(state, id2, {}, event);
+      return;
+    case "gate.requested":
+      update(state, id2, { gates: [...view.gates, { gateRunId: event.data.gateRunId, candidate: event.data.candidate, command: event.data.command, status: "running" }] }, event);
+      return;
+    case "gate.finished":
+      update(state, id2, { gates: view.gates.map((gate) => gate.gateRunId === event.data.result.id ? { ...gate, status: "finished", result: event.data.result } : gate) }, event);
+      return;
+    case "gate.uncertain":
+      update(state, id2, { gates: view.gates.map((gate) => gate.gateRunId === event.data.gateRunId ? { ...gate, status: "uncertain" } : gate) }, event);
+      return;
+    default:
+      return;
+  }
+}
+function project(projectId, events) {
+  const state = emptyProjectState(projectId);
+  for (const event of events) {
+    const problem = checkEvent(state, event);
+    if (problem !== void 0) return { state, violations: [{ eventId: event.id, type: event.type, message: problem }] };
+    applyEvent(state, event);
+  }
+  return { state, violations: [] };
+}
+var TERMINAL_STATES;
+var init_state = __esm({
+  "src/runtime-plugin/server/domain/state.ts"() {
+    "use strict";
+    TERMINAL_STATES = ["accepted", "rejected", "abandoned"];
+  }
+});
+
+// src/runtime-plugin/server/domain/receipts.ts
+import { createHash as createHash3 } from "crypto";
+var init_receipts = __esm({
+  "src/runtime-plugin/server/domain/receipts.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime-plugin/server/domain/views.ts
+function quiescence(state) {
+  const blockers = [];
+  for (const view of state.assignments.values()) {
+    if (view.state !== "draft" && !TERMINAL_STATES.includes(view.state)) blockers.push({ kind: "assignment", id: view.id, detail: `is ${view.state}` });
+    if (view.peerAgentId !== void 0 && view.closure !== "closed") blockers.push({ kind: "archive", id: view.id, detail: `managed Peer ${view.peerAgentId} is not archived (${view.closure})` });
+    for (const gate of view.gates) {
+      if (gate.status === "running" || gate.status === "uncertain" && view.closure !== "closed") {
+        blockers.push({ kind: "gate", id: gate.gateRunId, detail: `gate is ${gate.status}` });
+      }
+    }
+    for (const [intent, type] of Object.entries(view.openIntents)) blockers.push({ kind: "intent", id: intent, detail: `${type} has no result` });
+  }
+  for (const owner of state.ownership.values()) {
+    if (owner.state !== "released") blockers.push({ kind: "ownership", id: owner.assignmentId, detail: `writer ownership is ${owner.state}` });
+  }
+  for (const notice of state.notices.values()) {
+    if (notice.state === "pending" || notice.state === "uncertain") blockers.push({ kind: "delivery", id: notice.noticeId, detail: `notice is ${notice.state}` });
+  }
+  return { quiescent: blockers.length === 0, blockers };
+}
+var init_views = __esm({
+  "src/runtime-plugin/server/domain/views.ts"() {
+    "use strict";
+    init_receipts();
+    init_state();
+  }
+});
+
+// src/runtime-plugin/shared/limits.ts
+import { z as z4 } from "zod";
+function utf8Bytes(value) {
+  return encoder.encode(value).length;
+}
+function boundedString(max = MAX_STRING_BYTES) {
+  return z4.string().refine((value) => {
+    const bytes = utf8Bytes(value);
+    return bytes >= 1 && bytes <= max;
+  }, { message: `must be 1 byte to ${String(max)} bytes of UTF-8` });
+}
+function boundedArray(item) {
+  return z4.array(item).max(MAX_ARRAY_ITEMS);
+}
+var MAX_AGGREGATE_BYTES, MAX_ARRAY_ITEMS, MAX_STRING_BYTES, MAX_COMMAND_BYTES, MAX_GATE_TIMEOUT_SECONDS, encoder;
+var init_limits = __esm({
+  "src/runtime-plugin/shared/limits.ts"() {
+    "use strict";
+    MAX_AGGREGATE_BYTES = 64 * 1024;
+    MAX_ARRAY_ITEMS = 64;
+    MAX_STRING_BYTES = 8 * 1024;
+    MAX_COMMAND_BYTES = 16 * 1024;
+    MAX_GATE_TIMEOUT_SECONDS = 3600;
+    encoder = new TextEncoder();
+  }
+});
+
+// src/runtime-plugin/server/contracts/assignment.ts
+import { z as z5 } from "zod";
+var ASSIGNMENT_MODES, ASSIGNMENT_KINDS, commitSchema, gateSpecSchema, items, assignmentCreateSchema, candidateRefSchema;
+var init_assignment = __esm({
+  "src/runtime-plugin/server/contracts/assignment.ts"() {
+    "use strict";
+    init_limits();
+    ASSIGNMENT_MODES = ["writable", "read-only"];
+    ASSIGNMENT_KINDS = ["engineer", "architect", "reviewer", "scout"];
+    commitSchema = z5.string().regex(/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/);
+    gateSpecSchema = z5.strictObject({
+      command: boundedString(MAX_COMMAND_BYTES),
+      timeoutSeconds: z5.number().int().min(1).max(MAX_GATE_TIMEOUT_SECONDS),
+      runtimeRerun: z5.enum(["none", "optional", "required"]),
+      processContractVersion: z5.literal(1)
+    });
+    items = boundedArray(boundedString());
+    assignmentCreateSchema = z5.strictObject({
+      mode: z5.enum(ASSIGNMENT_MODES),
+      kind: z5.enum(ASSIGNMENT_KINDS),
+      outcome: boundedString(),
+      prerequisites: items,
+      writeScope: items,
+      exclusions: items,
+      invariants: items,
+      acceptanceEvidence: items,
+      gate: gateSpecSchema.optional(),
+      expectedHandoff: items,
+      reopenConditions: items,
+      baseCommit: commitSchema
+    });
+    candidateRefSchema = z5.strictObject({
+      kind: z5.literal("git-commit"),
+      commit: commitSchema,
+      baseCommit: commitSchema,
+      changedPaths: z5.array(z5.string().min(1)),
+      workspaceId: z5.string().min(1),
+      branch: z5.string().min(1).optional()
+    });
+  }
+});
+
+// src/runtime-plugin/server/contracts/actions.ts
+import { z as z6 } from "zod";
+var assignmentIdSchema, reason, assignment, SUPERVISOR_ACTION_SCHEMAS, LEAD_ACTION_SCHEMAS;
+var init_actions = __esm({
+  "src/runtime-plugin/server/contracts/actions.ts"() {
+    "use strict";
+    init_limits();
+    init_assignment();
+    assignmentIdSchema = z6.string().regex(/^asg_[A-Za-z0-9_-]{8,64}$/);
+    reason = boundedString();
+    assignment = { assignmentId: assignmentIdSchema };
+    SUPERVISOR_ACTION_SCHEMAS = {
+      room_status: z6.strictObject({}),
+      runtime_findings: z6.strictObject({}),
+      message_lead: z6.strictObject({ message: boundedString() })
+    };
+    LEAD_ACTION_SCHEMAS = {
+      assignment_create: assignmentCreateSchema,
+      // An eligible exact Peer provider id from the room manifest; the model is never selectable.
+      assignment_dispatch: z6.strictObject({ ...assignment, peerProvider: z6.string().min(1).max(128) }),
+      assignment_answer: z6.strictObject({ ...assignment, answer: boundedString() }),
+      assignment_rework: z6.strictObject({ ...assignment, instructions: boundedString() }),
+      assignment_accept: z6.strictObject({
+        ...assignment,
+        reason,
+        // Required by the domain when the Peer gate or a required rerun is red; never a waiver of
+        // a missing gate.
+        override: z6.strictObject({ reason, residualRiskAcknowledged: z6.literal(true) }).optional()
+      }),
+      assignment_reject: z6.strictObject({ ...assignment, reason }),
+      assignment_abandon: z6.strictObject({ ...assignment, reason }),
+      assignment_close: z6.strictObject(assignment),
+      assignment_status: z6.strictObject({ assignmentId: assignmentIdSchema.optional() }),
+      gate_run: z6.strictObject(assignment)
+    };
+  }
+});
+
+// src/runtime-plugin/server/contracts/peer.ts
+import { z as z7 } from "zod";
+var text, texts, verificationReportSchema, askInputSchema, HANDOFF_DETAILS, handoffBase, PEER_REPORT_ERROR_CODES, peerReportReceiptSchema, peerReportErrorSchema;
+var init_peer = __esm({
+  "src/runtime-plugin/server/contracts/peer.ts"() {
+    "use strict";
+    init_limits();
+    text = boundedString();
+    texts = boundedArray(text);
+    verificationReportSchema = z7.strictObject({
+      command: boundedString(MAX_COMMAND_BYTES),
+      outcome: z7.enum(["passed", "failed", "not-run"]),
+      note: text.optional()
+    });
+    askInputSchema = z7.strictObject({
+      question: text,
+      blockingContext: text,
+      evidence: texts
+    });
+    HANDOFF_DETAILS = {
+      engineer: z7.strictObject({ kind: z7.literal("engineer") }),
+      architect: z7.strictObject({
+        kind: z7.literal("architect"),
+        alternatives: texts,
+        strongestCounterargument: text,
+        reversalConditions: texts,
+        evidence: texts
+      }),
+      reviewer: z7.strictObject({
+        kind: z7.literal("reviewer"),
+        findings: boundedArray(z7.strictObject({ claim: text, evidence: texts }))
+      }),
+      scout: z7.strictObject({
+        kind: z7.literal("scout"),
+        evidence: texts,
+        remainingUnknowns: texts,
+        confidence: z7.enum(["low", "medium", "high"])
+      })
+    };
+    handoffBase = {
+      summary: text,
+      deliverables: texts,
+      verification: boundedArray(verificationReportSchema),
+      residualRisks: texts,
+      evidence: texts
+    };
+    PEER_REPORT_ERROR_CODES = [
+      "report_malformed",
+      "report_unauthorized",
+      "report_stale",
+      "report_conflict",
+      "report_state",
+      "report_precondition",
+      "report_uncertain"
+    ];
+    peerReportReceiptSchema = z7.strictObject({
+      schema: z7.literal(1),
+      receipt: z7.string().min(1).max(128),
+      tool: z7.enum(["ask", "handoff"]),
+      status: z7.literal("accepted"),
+      assignmentState: z7.enum(["questioned", "blocked", "handed-back"])
+    });
+    peerReportErrorSchema = z7.strictObject({
+      schema: z7.literal(1),
+      error: z7.strictObject({
+        code: z7.enum(PEER_REPORT_ERROR_CODES),
+        message: boundedString(1024),
+        retryable: z7.boolean()
+      })
+    });
+  }
+});
+
+// src/runtime-plugin/server/events/schema.ts
+import { z as z8 } from "zod";
+function variants(strict) {
+  return EVENT_TYPES.map((type) => z8.strictObject({
+    ...envelope,
+    type: z8.literal(type),
+    payloadVersion: z8.literal(1),
+    data: strict ? z8.strictObject(EVENT_PAYLOADS[type]) : z8.object(EVENT_PAYLOADS[type])
+  }));
+}
+function validateForWrite(event) {
+  return writerSchema.parse(event);
+}
+function readEvent(value) {
+  if (typeof value !== "object" || value === null) return { ok: false, reason: "invalid", detail: "Event is not an object." };
+  const { type, payloadVersion } = value;
+  if (typeof type !== "string" || !Object.hasOwn(EVENT_PAYLOADS, type)) {
+    return { ok: false, reason: "unknown-type", detail: `Unknown event type ${typeof type === "string" ? type : typeof type}.` };
+  }
+  if (typeof payloadVersion !== "number" || !SUPPORTED_PAYLOAD_VERSIONS[type].includes(payloadVersion)) {
+    return { ok: false, reason: "unsupported-version", detail: `Unsupported payload version ${String(payloadVersion)} for ${type}.` };
+  }
+  const parsed = readerSchema.safeParse(value);
+  return parsed.success ? { ok: true, event: parsed.data } : { ok: false, reason: "invalid", detail: z8.prettifyError(parsed.error) };
+}
+var EVENT_SCHEMA, id, text2, reason2, generation2, digest2, timestamp, gateResultSchema, NOTICE_DISPOSITIONS, NOTICE_CLASSES, EVENT_PAYLOADS, EVENT_TYPES, SUPPORTED_PAYLOAD_VERSIONS, actorSchema, envelope, firstWriter, restWriters, firstReader, restReaders, writerSchema, readerSchema;
+var init_schema = __esm({
+  "src/runtime-plugin/server/events/schema.ts"() {
+    "use strict";
+    init_limits();
+    init_policy();
+    init_actions();
+    init_assignment();
+    init_peer();
+    EVENT_SCHEMA = "paseo-room.runtime-event";
+    id = z8.string().min(1).max(128);
+    text2 = boundedString();
+    reason2 = boundedString(1024);
+    generation2 = z8.number().int().min(1);
+    digest2 = z8.string().regex(/^sha256:[0-9a-f]{64}$/);
+    timestamp = z8.iso.datetime({ offset: true });
+    gateResultSchema = z8.strictObject({
+      id,
+      assignmentId: assignmentIdSchema,
+      candidate: candidateRefSchema,
+      command: boundedString(MAX_COMMAND_BYTES),
+      startedAt: timestamp,
+      finishedAt: timestamp.optional(),
+      exitCode: z8.number().int().optional(),
+      signal: z8.string().min(1).max(32).optional(),
+      timedOut: z8.boolean(),
+      termination: z8.enum(["exited", "signaled", "killed", "uncertain"]),
+      processContractVersion: z8.literal(1),
+      environmentPolicyVersion: z8.literal(1),
+      outputDigest: digest2,
+      outputTailAttachment: z8.string().min(1).max(256).optional(),
+      workspaceMoved: z8.boolean()
+    });
+    NOTICE_DISPOSITIONS = ["record", "panel", "lead-now", "supervisor-digest", "supervisor-now", "operator-now", "human-required"];
+    NOTICE_CLASSES = ["record", "owner", "operator", "page"];
+    EVENT_PAYLOADS = {
+      // Project binding and Lead ownership (§4.1, §5.2).
+      "project.bound": { canonicalRoot: z8.string().min(1), gitCommonDir: z8.string().min(1) },
+      "project.rebound": { canonicalRoot: z8.string().min(1), gitCommonDir: z8.string().min(1), previousRoot: z8.string().min(1) },
+      "project.ownership-conflict": { leadAgentIds: z8.array(id).min(2), leadProviderIds: z8.array(id).min(1) },
+      "project.ownership-resolved": { keptLeadAgentId: id, decidedBy: z8.enum(["evidence", "human"]) },
+      // Assignment lifecycle decided by Lead or Human (§5.1).
+      "assignment.created": { input: assignmentCreateSchema, leadAgentId: id, leadProviderId: id },
+      "assignment.dispatch-requested": { peerProviderId: id, workspaceId: id },
+      "assignment.answered": { answer: text2 },
+      "assignment.rework-requested": { instructions: text2 },
+      "assignment.accepted": {
+        candidate: candidateRefSchema.optional(),
+        inspectedCommit: commitSchema.optional(),
+        reason: reason2,
+        override: z8.strictObject({ reason: reason2, residualRiskAcknowledged: z8.literal(true) }).optional(),
+        gateResultId: id.optional()
+      },
+      "assignment.rejected": { reason: reason2 },
+      "assignment.abandoned": { reason: reason2 },
+      "assignment.close-requested": {},
+      // Writer ownership, independent of assignment state (§5.3).
+      "ownership.reserved": { workspaceId: id, baseCommit: commitSchema },
+      "ownership.held": { agentId: id },
+      "ownership.releasing": { agentId: id },
+      "ownership.released": { agentId: id, archivedAt: timestamp },
+      "ownership.uncertain": { reason: reason2 },
+      // External effects: agent creation, turn delivery and archive (§6).
+      "agent.create-requested": { intentId: id, peerProviderId: id, workspaceId: id, parentAgentId: id, label: id },
+      "agent.create-succeeded": { intentId: id, agentId: id },
+      "agent.create-failed": { intentId: id, reason: reason2 },
+      "agent.create-uncertain": { intentId: id, reason: reason2 },
+      // A created Peer whose fresh snapshot did not prove provider, parent, workspace, idleness
+      // and no prior prompt. It is archived, never adopted or prompted (§3.3, §5.3).
+      "binding.refused": { agentId: id, reason: reason2 },
+      "binding.published": {
+        agentId: id,
+        providerId: id,
+        model: z8.string().min(1).max(256),
+        parentAgentId: id,
+        workspaceId: id,
+        roomGeneration: id
+      },
+      "reporting.generation-opened": { generation: generation2, capabilityHash: digest2, turn: z8.enum(["initial", "answer", "rework", "follow-up"]) },
+      "run.requested": { intentId: id, generation: generation2, promptDigest: digest2 },
+      "run.succeeded": { intentId: id, generation: generation2 },
+      "run.failed": { intentId: id, generation: generation2, reason: reason2 },
+      "run.uncertain": { intentId: id, generation: generation2, reason: reason2 },
+      "archive.requested": { intentId: id, agentId: id },
+      "archive.succeeded": { intentId: id, agentId: id, archivedAt: timestamp, liveStatus: z8.literal("closed") },
+      "archive.failed": { intentId: id, agentId: id, reason: reason2 },
+      "archive.uncertain": { intentId: id, agentId: id, reason: reason2 },
+      // Peer reporting (§3.4). Report content is evidence; identity and candidate are derived.
+      "report.accepted": {
+        generation: generation2,
+        tool: z8.enum(PEER_REPORTING_TOOLS),
+        requestId: id,
+        fingerprint: digest2,
+        receipt: peerReportReceiptSchema,
+        report: z8.record(z8.string(), z8.unknown()),
+        candidate: candidateRefSchema.optional(),
+        inspectedCommit: commitSchema.optional()
+      },
+      "report.refused": { generation: generation2.optional(), tool: z8.string().min(1).max(64), requestId: id, code: z8.enum(PEER_REPORT_ERROR_CODES), reason: reason2 },
+      "report.missing": { generation: generation2 },
+      "report.uncertain": { generation: generation2, requestId: id.optional(), reason: reason2 },
+      "permission.awaiting": { generation: generation2, permissionRequestId: id, tool: z8.enum(PEER_REPORTING_TOOLS) },
+      "permission.resolved": { generation: generation2, permissionRequestId: id, outcome: z8.enum(["allowed", "denied", "other"]) },
+      // Independent runtime gate (D6).
+      "gate.requested": {
+        gateRunId: id,
+        candidate: candidateRefSchema,
+        command: boundedString(MAX_COMMAND_BYTES),
+        timeoutSeconds: gateSpecSchema.shape.timeoutSeconds,
+        processContractVersion: z8.literal(1),
+        environmentPolicyVersion: z8.literal(1)
+      },
+      "gate.finished": { result: gateResultSchema },
+      "gate.uncertain": { gateRunId: id, reason: reason2 },
+      // Deterministic notices (D9). Delivery is at least once with a stable id.
+      "notice.pending": {
+        noticeId: id,
+        kind: z8.string().min(1).max(64),
+        class: z8.enum(NOTICE_CLASSES),
+        disposition: z8.enum(NOTICE_DISPOSITIONS),
+        recipientAgentId: id.optional(),
+        recipientRole: z8.enum(RUNTIME_ROLES).exclude(["peer"]).optional(),
+        text: text2
+      },
+      "notice.sent": { noticeId: id },
+      "notice.failed": { noticeId: id, reason: reason2 },
+      "notice.uncertain": { noticeId: id, reason: reason2 }
+    };
+    EVENT_TYPES = Object.keys(EVENT_PAYLOADS);
+    SUPPORTED_PAYLOAD_VERSIONS = Object.fromEntries(
+      EVENT_TYPES.map((type) => [type, [1]])
+    );
+    actorSchema = z8.strictObject({
+      source: z8.enum(["human", "plugin", "seat", "paseo"]),
+      role: z8.enum(RUNTIME_ROLES).optional(),
+      agentId: id.optional(),
+      providerId: id.optional()
+    });
+    envelope = {
+      schema: z8.literal(EVENT_SCHEMA),
+      version: z8.literal(1),
+      id: z8.string().regex(/^evt_[A-Za-z0-9_-]{8,64}$/),
+      sequence: z8.number().int().min(1),
+      projectId: z8.uuid(),
+      assignmentId: assignmentIdSchema.optional(),
+      actor: actorSchema,
+      causationId: id.optional(),
+      idempotencyKey: id.optional(),
+      occurredAt: timestamp
+    };
+    [firstWriter, ...restWriters] = variants(true);
+    [firstReader, ...restReaders] = variants(false);
+    if (firstWriter === void 0 || firstReader === void 0) throw new Error("The runtime event union is empty.");
+    writerSchema = z8.discriminatedUnion("type", [firstWriter, ...restWriters]);
+    readerSchema = z8.discriminatedUnion("type", [firstReader, ...restReaders]);
+  }
+});
+
+// src/runtime-plugin/server/store/publish.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { chmod as chmod2, link, lstat as lstat4, mkdir as mkdir2, open, readdir as readdir3, unlink as unlink2 } from "fs/promises";
+import { join as join13 } from "path";
+function code(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+async function ensurePrivateDirectory(path) {
+  await mkdir2(path, { recursive: true, mode: PRIVATE_DIR_MODE });
+  const stat2 = await lstat4(path);
+  if (!stat2.isDirectory()) throw new Error(`${path} is not a directory.`);
+  if ((stat2.mode & 511) !== PRIVATE_DIR_MODE) await chmod2(path, PRIVATE_DIR_MODE);
+}
+async function writeTemporary(directory, content, hook) {
+  const temporary = join13(directory, `${TEMPORARY_PREFIX}${String(process.pid)}-${randomBytes2(8).toString("hex")}`);
+  const handle = await open(temporary, "wx", PRIVATE_FILE_MODE);
+  try {
+    await handle.writeFile(content);
+    hook?.("temporary-written");
+    await handle.sync();
+    hook?.("temporary-synced");
+  } finally {
+    await handle.close();
+  }
+  return temporary;
+}
+async function syncDirectory(directory) {
+  let handle;
+  try {
+    handle = await open(directory, "r");
+    await handle.sync();
+  } catch (error) {
+    if (!["EISDIR", "EINVAL", "EPERM", "EBADF", "ENOTSUP"].includes(code(error) ?? "")) throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+async function publishWith(directory, content, allocate, hook) {
+  const temporary = await writeTemporary(directory, content, hook);
+  let published;
+  try {
+    for (let attempt = 0; ; attempt += 1) {
+      const name = allocate(attempt);
+      if (name === void 0) break;
+      const target = join13(directory, name);
+      try {
+        await link(temporary, target);
+        published = target;
+        break;
+      } catch (error) {
+        const reason3 = code(error);
+        if (reason3 === "EEXIST") continue;
+        if (reason3 !== void 0 && UNSUPPORTED.has(reason3)) throw new PublishUnsupportedError(directory, error);
+        throw error;
+      }
+    }
+    if (published !== void 0) hook?.("linked");
+  } finally {
+    await unlink2(temporary).catch(() => void 0);
+  }
+  if (published === void 0) return "";
+  hook?.("temporary-removed");
+  await syncDirectory(directory);
+  return published;
+}
+async function publishOnce(directory, name, content, hook) {
+  const path = await publishWith(directory, content, (attempt) => attempt === 0 ? name : void 0, hook);
+  if (path === "") throw new AlreadyPublishedError(join13(directory, name));
+  return path;
+}
+async function staleTemporaries(directory) {
+  const names = await readdir3(directory);
+  return names.filter((name) => name.startsWith(TEMPORARY_PREFIX)).sort();
+}
+var TEMPORARY_PREFIX, PRIVATE_DIR_MODE, PRIVATE_FILE_MODE, PublishUnsupportedError, AlreadyPublishedError, UNSUPPORTED;
+var init_publish = __esm({
+  "src/runtime-plugin/server/store/publish.ts"() {
+    "use strict";
+    TEMPORARY_PREFIX = ".tmp-";
+    PRIVATE_DIR_MODE = 448;
+    PRIVATE_FILE_MODE = 384;
+    PublishUnsupportedError = class extends Error {
+      constructor(directory, cause) {
+        super(`The filesystem at ${directory} cannot publish runtime state without the risk of overwriting it (hard links unavailable).`, { cause });
+        this.name = "PublishUnsupportedError";
+      }
+    };
+    AlreadyPublishedError = class extends Error {
+      constructor(path) {
+        super(`${path} is already published and is never replaced.`);
+        this.path = path;
+        this.name = "AlreadyPublishedError";
+      }
+      path;
+    };
+    UNSUPPORTED = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EXDEV", "EMLINK"]);
+  }
+});
+
+// src/runtime-plugin/server/store/project.ts
+import { randomBytes as randomBytes3, randomUUID } from "crypto";
+import { mkdir as mkdir3, readdir as readdir4, readFile as readFile4, rename as rename2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename2, join as join14 } from "path";
+import { z as z9 } from "zod";
+function runtimeRoot(roomHome) {
+  return join14(roomHome, "runtime", RUNTIME_LAYOUT_VERSION);
+}
+function eventName(sequence) {
+  return `${String(sequence).padStart(12, "0")}.json`;
+}
+function slug(root) {
+  const name = basename2(root).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+  return name === "" ? "project" : name;
+}
+var RUNTIME_LAYOUT_VERSION, EVENT_FILE, MAX_SEQUENCE_ATTEMPTS, metaSchema, ProjectStore;
+var init_project = __esm({
+  "src/runtime-plugin/server/store/project.ts"() {
+    "use strict";
+    init_schema();
+    init_publish();
+    RUNTIME_LAYOUT_VERSION = "v1";
+    EVENT_FILE = /^(\d{12})\.json$/;
+    MAX_SEQUENCE_ATTEMPTS = 64;
+    metaSchema = z9.strictObject({
+      schema: z9.literal(1),
+      projectId: z9.uuid(),
+      createdAt: z9.iso.datetime({ offset: true }),
+      canonicalRoot: z9.string().min(1),
+      gitCommonDir: z9.string().min(1)
+    });
+    ProjectStore = class _ProjectStore {
+      constructor(directory, meta, now) {
+        this.directory = directory;
+        this.meta = meta;
+        this.now = now;
+      }
+      directory;
+      meta;
+      now;
+      lastSequence = 0;
+      get eventsDirectory() {
+        return join14(this.directory, "events");
+      }
+      get cacheDirectory() {
+        return join14(this.directory, "cache");
+      }
+      get gatesDirectory() {
+        return join14(this.directory, "gates");
+      }
+      get quarantineDirectory() {
+        return join14(this.directory, "quarantine");
+      }
+      /** Opens an existing project directory; refuses one whose `meta.json` is not exactly v1. */
+      static async open(directory, now = () => /* @__PURE__ */ new Date()) {
+        const meta = metaSchema.parse(JSON.parse(await readFile4(join14(directory, "meta.json"), "utf8")));
+        return new _ProjectStore(directory, meta, now);
+      }
+      /**
+       * Binds a new project to its canonical Git common directory. Identity is a minted UUID, never
+       * a hash of a movable path; a moved repository is rebound only by an explicit operator action.
+       */
+      static async create(root, binding, now = () => /* @__PURE__ */ new Date()) {
+        const projects = join14(root, "projects");
+        await ensurePrivateDirectory(projects);
+        const projectId = randomUUID();
+        const directory = join14(projects, `${slug(binding.canonicalRoot)}-${projectId}`);
+        await ensurePrivateDirectory(directory);
+        for (const child of ["events", "cache", "gates", "quarantine"]) await ensurePrivateDirectory(join14(directory, child));
+        const meta = { schema: 1, projectId, createdAt: now().toISOString(), ...binding };
+        await publishOnce(directory, "meta.json", `${JSON.stringify(meta, null, 2)}
+`);
+        const store = new _ProjectStore(directory, meta, now);
+        await store.append({ type: "project.bound", payloadVersion: 1, actor: { source: "plugin" }, data: { ...binding } });
+        return store;
+      }
+      /** Finds the project bound to this Git common directory. Never matches by name, remote or cwd. */
+      static async find(root, gitCommonDir, now) {
+        for (const store of await _ProjectStore.list(root, now)) {
+          if (store.meta.gitCommonDir === gitCommonDir) return store;
+        }
+        return void 0;
+      }
+      static async list(root, now) {
+        const projects = join14(root, "projects");
+        let names;
+        try {
+          names = await readdir4(projects);
+        } catch {
+          return [];
+        }
+        const stores = [];
+        for (const name of names.sort()) {
+          try {
+            stores.push(await _ProjectStore.open(join14(projects, name), now));
+          } catch {
+          }
+        }
+        return stores;
+      }
+      /** Reads every event strictly. Any unreadable file pauses the project; nothing is moved. */
+      async replay() {
+        const names = (await readdir4(this.eventsDirectory)).sort();
+        const problems = [];
+        const events = [];
+        const ids = /* @__PURE__ */ new Map();
+        for (const name of names) {
+          if (name.startsWith(".tmp-")) continue;
+          const match = EVENT_FILE.exec(name);
+          if (!match) {
+            problems.push({ file: name, reason: "unexpected-file", detail: "Not a runtime event file name." });
+            continue;
+          }
+          let raw;
+          let value;
+          try {
+            raw = await readFile4(join14(this.eventsDirectory, name), "utf8");
+            value = JSON.parse(raw);
+          } catch (error) {
+            problems.push({ file: name, reason: "unreadable", detail: error instanceof Error ? error.message : String(error) });
+            continue;
+          }
+          const read = readEvent(value);
+          if (!read.ok) {
+            problems.push({ file: name, reason: read.reason, detail: read.detail });
+            continue;
+          }
+          const event = read.event;
+          if (event.sequence !== Number(match[1])) {
+            problems.push({ file: name, reason: "sequence-mismatch", detail: `File name does not match sequence ${String(event.sequence)}.` });
+            continue;
+          }
+          if (event.projectId !== this.meta.projectId) {
+            problems.push({ file: name, reason: "foreign-project", detail: `Event belongs to project ${event.projectId}.` });
+            continue;
+          }
+          const previous = ids.get(event.id);
+          if (previous !== void 0) {
+            problems.push({ file: name, reason: "duplicate-id", detail: `Event id ${event.id} is also used by ${previous}.` });
+            continue;
+          }
+          ids.set(event.id, name);
+          events.push(event);
+        }
+        const gaps = [];
+        let expected = 1;
+        for (const event of events) {
+          for (; expected < event.sequence; expected += 1) gaps.push(expected);
+          expected = event.sequence + 1;
+        }
+        const highest = names.map((name) => EVENT_FILE.exec(name)?.[1]).filter((value) => value !== void 0).map(Number);
+        this.lastSequence = Math.max(this.lastSequence, 0, ...highest);
+        return {
+          status: problems.length === 0 ? "ok" : "paused",
+          events,
+          problems,
+          gaps,
+          staleTemporaries: await staleTemporaries(this.eventsDirectory)
+        };
+      }
+      /**
+       * Validates and publishes one event at the next free sequence. A concurrent writer that took
+       * that sequence causes reallocation, never replacement.
+       */
+      async append(event) {
+        if (this.lastSequence === 0) await this.replay();
+        const base = this.lastSequence;
+        for (let attempt = 0; attempt < MAX_SEQUENCE_ATTEMPTS; attempt += 1) {
+          const sequence = base + 1 + attempt;
+          const full = validateForWrite({
+            ...event,
+            schema: EVENT_SCHEMA,
+            version: 1,
+            id: `evt_${randomBytes3(12).toString("hex")}`,
+            sequence,
+            projectId: this.meta.projectId,
+            occurredAt: this.now().toISOString()
+          });
+          try {
+            await publishOnce(this.eventsDirectory, eventName(sequence), `${JSON.stringify(full)}
+`);
+            this.lastSequence = Math.max(this.lastSequence, sequence);
+            return full;
+          } catch (error) {
+            if (!(error instanceof AlreadyPublishedError)) throw error;
+          }
+        }
+        throw new Error(`Could not allocate an event sequence in ${this.eventsDirectory}.`);
+      }
+      /** Writes one disposable derived view. Cache files may be replaced; they are never authority. */
+      async writeCache(name, content) {
+        await mkdir3(this.cacheDirectory, { recursive: true, mode: 448 });
+        const temporary = join14(this.cacheDirectory, `.tmp-${String(process.pid)}-${randomBytes3(6).toString("hex")}`);
+        await writeFile2(temporary, content, { mode: PRIVATE_FILE_MODE });
+        await rename2(temporary, join14(this.cacheDirectory, name));
+      }
+      async readCache(name) {
+        try {
+          return await readFile4(join14(this.cacheDirectory, name), "utf8");
+        } catch {
+          return void 0;
+        }
+      }
+      /** Deletes every cached view; the next replay rebuilds them. */
+      async clearCache() {
+        await rm3(this.cacheDirectory, { recursive: true, force: true });
+        await ensurePrivateDirectory(this.cacheDirectory);
+      }
+      /** Moves one named event file aside. Only an explicit operator action calls this. */
+      async quarantine(file) {
+        if (!EVENT_FILE.test(file) && !file.startsWith(".tmp-")) throw new Error(`${file} is not a runtime event file.`);
+        await ensurePrivateDirectory(this.quarantineDirectory);
+        await rename2(join14(this.eventsDirectory, file), join14(this.quarantineDirectory, file));
+      }
+    };
+  }
+});
+
+// src/runtime-state.ts
+import { readdir as readdir5 } from "fs/promises";
+import { join as join15 } from "path";
+async function inspectRuntimeState(roomHome) {
+  const root = runtimeRoot(roomHome);
+  const names = await readdir5(join15(root, "projects")).catch(() => []);
+  const blockers = [];
+  const stores = [];
+  for (const name of names.sort()) {
+    try {
+      stores.push(await ProjectStore.open(join15(root, "projects", name)));
+    } catch {
+      blockers.push({ project: name, kind: "assignment", id: name, detail: "has unreadable project metadata" });
+    }
+  }
+  for (const store of stores) {
+    const replay = await store.replay();
+    const projection = project(store.meta.projectId, replay.events);
+    if (replay.status !== "ok" || projection.violations.length > 0) {
+      blockers.push({ project: store.meta.canonicalRoot, kind: "assignment", id: store.meta.projectId, detail: "the project ledger is paused and cannot be proven quiet" });
+      continue;
+    }
+    for (const blocker of quiescence(projection.state).blockers) blockers.push({ ...blocker, project: store.meta.canonicalRoot });
+  }
+  return { root, projects: names.length, blockers };
+}
+function describeBlockers(summary, limit = 5) {
+  const shown = summary.blockers.slice(0, limit).map((blocker) => `${blocker.project}: ${blocker.kind} ${blocker.id} ${blocker.detail}`);
+  const more = summary.blockers.length > limit ? `; and ${String(summary.blockers.length - limit)} more` : "";
+  return `${shown.join("; ")}${more}`;
+}
+var init_runtime_state = __esm({
+  "src/runtime-state.ts"() {
+    "use strict";
+    init_state();
+    init_views();
+    init_project();
+  }
+});
+
 // src/commands.ts
-import { join as join12, sep as sep2 } from "path";
-import { lstat as lstat4, rm as rm3 } from "fs/promises";
+import { join as join16, sep as sep3 } from "path";
+import { lstat as lstat5, rm as rm4 } from "fs/promises";
+import { satisfies } from "semver";
 function sessionOptions(options) {
   const password = (options.env ?? process.env).PASEO_PASSWORD;
   return { ...password === void 0 ? {} : { password }, ...options.factory ? { factory: options.factory } : {} };
@@ -2282,21 +3609,47 @@ function roleProfiles(agent, roles) {
     notes: ROLE_NOTES[role]
   }));
 }
+function carrierSpec(layout) {
+  return {
+    id: CLAUDE_CARRIER_PLUGIN_ID,
+    path: claudeCarrierPluginDir(layout),
+    check: "claude.plugin",
+    running: "Claude contract carrier plugin",
+    enabledPass: "Paseo plugins are enabled for the required Claude contract carrier.",
+    enabledFail: "Claude rooms require the paseo-room trusted server plugin, but Paseo plugins are disabled. Plugins are trusted, unsandboxed code with access to the daemon machine.",
+    paseoRange: CLAUDE_CARRIER_PASEO_RANGE,
+    rangeCheck: "claude.paseo-range",
+    rangeRemedy: "Use a Paseo release inside that range, or upgrade paseo-room, then run setup again."
+  };
+}
+function runtimeSpec(layout) {
+  return {
+    id: RUNTIME_PLUGIN_ID,
+    path: runtimePluginDir(layout),
+    check: "runtime.plugin",
+    running: "Runtime coordination plugin (preview)",
+    enabledPass: "Paseo plugins are enabled for the runtime coordination plugin.",
+    enabledFail: "Runtime coordination is a trusted server plugin, but Paseo plugins are disabled. Plugins are trusted, unsandboxed code with access to the daemon machine.",
+    paseoRange: RUNTIME_PASEO_RANGE,
+    rangeCheck: "runtime.paseo-range",
+    rangeRemedy: "Use a Paseo release inside that range, or run setup without --runtime."
+  };
+}
 async function buildDesired(layout, agents, roles, build = {}) {
   const entries = [
     { kind: "dir", path: layout.roomHome },
     { kind: "dir", path: sharedRoom(layout) },
     // Earlier versions generated a default workspace protocol template here. The room ships no
     // default protocol now, so the old generated regular file is declared absent and removed.
-    { kind: "absent", path: join12(sharedRoom(layout), "WORKSPACE_PROTOCOL.md") },
+    { kind: "absent", path: join16(sharedRoom(layout), "WORKSPACE_PROTOCOL.md") },
     ...roomSkillEntries(layout, agents)
   ];
   const providers = {};
   const profiles = [];
   const checks = [];
   const binaries = {};
-  for (const id of agents) {
-    const agent = AGENTS[id];
+  for (const id2 of agents) {
+    const agent = AGENTS[id2];
     const plan = await agent.build(layout, roles, build);
     entries.push(...plan.entries);
     checks.push(...plan.checks);
@@ -2306,13 +3659,13 @@ async function buildDesired(layout, agents, roles, build = {}) {
     const collisions = plan.entries.filter((entry) => credentialPaths.has(entry.path));
     if (collisions.length > 0) {
       checks.push(fail(
-        `${id}.credentials`,
+        `${id2}.credentials`,
         `${agent.label} produced managed entries for preserve-only credential paths: ${collisions.map((entry) => entry.path).join(", ")}.`,
         "This is an adapter defect; do not apply the plan."
       ));
     }
     if (plan.binary === void 0) continue;
-    binaries[id] = plan.binary;
+    binaries[id2] = plan.binary;
     Object.assign(providers, roleProviders(layout, agent, {
       binary: plan.binary,
       ...plan.argv ? { argv: plan.argv } : {},
@@ -2320,33 +3673,42 @@ async function buildDesired(layout, agents, roles, build = {}) {
     }, roles));
     profiles.push(...roleProfiles(agent, roles));
   }
-  if (agents.every((id) => binaries[id] !== void 0)) {
+  if (agents.every((id2) => binaries[id2] !== void 0)) {
     entries.push({
       kind: "file",
-      path: join12(layout.roomHome, AUTHENTICATION_GUIDE),
+      path: join16(layout.roomHome, AUTHENTICATION_GUIDE),
       content: renderAuthenticationGuide(layout.roomHome, binaries, agents, roles)
     });
     checks.push(warn(
       "room.authentication-not-validated",
-      `Role authentication was not validated. Login instructions are managed at ${join12(layout.roomHome, AUTHENTICATION_GUIDE)}.`,
+      `Role authentication was not validated. Login instructions are managed at ${join16(layout.roomHome, AUTHENTICATION_GUIDE)}.`,
       "After setup --apply, follow that guide or run: paseo-room auth login <agent> <role>"
     ));
   }
-  const pluginPath = agents.includes("claude") ? claudeCarrierPluginDir(layout) : void 0;
-  if (pluginPath !== void 0) entries.push(...claudeCarrierEntries(layout, roles));
-  entries.push({ kind: "file", path: join12(layout.roomHome, MARKER), content: renderMarker(package_default.version, agents, roles, contractDigest(), markerMemoryContract(agents, build.memoryContract ?? true)) });
-  return { entries, providers, profiles, checks, ...pluginPath === void 0 ? {} : { pluginPath } };
+  const plugins = [];
+  if (agents.includes("claude")) {
+    plugins.push(carrierSpec(layout));
+    entries.push(...claudeCarrierEntries(layout, roles));
+  }
+  let runtime;
+  if (build.runtime === true) {
+    plugins.push(runtimeSpec(layout));
+    entries.push(...runtimePluginEntries(layout, agents, roles));
+    runtime = { enabled: true, generation: renderRuntimeManifest(agents, roles).roomGeneration, schema: 1 };
+  }
+  entries.push({ kind: "file", path: join16(layout.roomHome, MARKER), content: renderMarker(package_default.version, agents, roles, contractDigest(), markerMemoryContract(agents, build.memoryContract ?? true), runtime) });
+  return { entries, providers, profiles, checks, plugins, ...runtime === void 0 ? {} : { runtime } };
 }
 function contractProvenance(previous) {
-  const digest = contractDigest();
+  const digest3 = contractDigest();
   if (!previous) return [];
-  if (previous.contract === digest) {
-    return [pass("room.contract", `Role contract generation ${digest} matches this package.`)];
+  if (previous.contract === digest3) {
+    return [pass("room.contract", `Role contract generation ${digest3} matches this package.`)];
   }
   const held = previous.contract === void 0 ? `was installed before the room recorded its contract generation (package ${previous.version})` : `holds contract generation ${previous.contract}`;
   return [warn(
     "room.contract",
-    `This room ${held}; this package renders ${digest}. Managed role documents are rewritten by setup, and a running seat keeps the text it started with.`,
+    `This room ${held}; this package renders ${digest3}. Managed role documents are rewritten by setup, and a running seat keeps the text it started with.`,
     "Run: paseo-room setup --apply, then restart the affected seats."
   )];
 }
@@ -2369,14 +3731,14 @@ function fileDriftSummary(drifted) {
   return `${count} ${subject} missing or outdated, and ${String(removals)} of them are present but suppressed by this room.`;
 }
 function fileDriftDetail(targets) {
-  const catalogs = targets.filter((target) => target.endsWith(`${sep2}model-catalog.json`));
+  const catalogs = targets.filter((target) => target.endsWith(`${sep3}model-catalog.json`));
   if (catalogs.length === 0) return "";
   const count = catalogs.length === 1 ? "One of them is a generated Codex model catalog" : `${String(catalogs.length)} of them are generated Codex model catalogs`;
   return ` ${count}, so those seats currently lack the scrubbed catalog closure rather than only older contract text.`;
 }
 async function safeDirectory(path, checks) {
   try {
-    const stat2 = await lstat4(path);
+    const stat2 = await lstat5(path);
     if (stat2.isDirectory()) return true;
     checks.push(fail(
       "room.path-safety",
@@ -2400,10 +3762,10 @@ async function roomPathSafety(layout, agents, roles) {
   const room = sharedRoom(layout);
   const roomIsSafe = await safeDirectory(room, checks);
   if (roomIsSafe && agents.length > 0) {
-    const skills = join12(room, "skills");
+    const skills = join16(room, "skills");
     if (await safeDirectory(skills, checks)) {
       const source = roomSkillSource(layout);
-      if (await safeDirectory(source, checks)) await safeDirectory(join12(source, "references"), checks);
+      if (await safeDirectory(source, checks)) await safeDirectory(join16(source, "references"), checks);
     }
     const projections = skillProjectionRoot(layout);
     if (await safeDirectory(projections, checks)) {
@@ -2413,16 +3775,16 @@ async function roomPathSafety(layout, agents, roles) {
       }
     }
   }
-  const rolesHome = join12(layout.roomHome, "roles");
+  const rolesHome = join16(layout.roomHome, "roles");
   if (!await safeDirectory(rolesHome, checks)) return checks;
   for (const agent of agents) {
-    const agentHome = join12(rolesHome, agent);
+    const agentHome = join16(rolesHome, agent);
     if (!await safeDirectory(agentHome, checks)) continue;
     for (const role of roles) await safeDirectory(roleHome(layout, agent, role), checks);
   }
   return checks;
 }
-async function staleFrom(layout, previous, agents, roles) {
+async function staleFrom(layout, previous, agents, roles, runtime) {
   if (!previous) return NOTHING_STALE;
   const kept = new Set(agents.flatMap((agent) => roles.map((role) => providerId(agent, role))));
   const providerIds = [];
@@ -2440,110 +3802,148 @@ async function staleFrom(layout, previous, agents, roles) {
   return {
     providerIds,
     profileIds,
-    removePlugin: previous.agents.includes("claude") && !agents.includes("claude"),
+    removePlugins: [
+      ...previous.agents.includes("claude") && !agents.includes("claude") ? [carrierSpec(layout)] : [],
+      ...previous.runtime?.enabled === true && !runtime ? [runtimeSpec(layout)] : []
+    ],
     retainedDirectories
   };
 }
-function pluginPlan(desired, stale, plugins, expectedPath) {
-  const livePlugin = plugins.find((plugin) => plugin.id === CLAUDE_CARRIER_PLUGIN_ID);
-  const shouldManage = desired.pluginPath !== void 0 || stale.removePlugin;
-  if (!shouldManage) return { checks: [] };
-  if (livePlugin !== void 0 && livePlugin.path !== expectedPath) {
+function pluginPlan(spec, wanted, plugins) {
+  const livePlugin = plugins.find((plugin) => plugin.id === spec.id);
+  if (livePlugin !== void 0 && livePlugin.path !== spec.path) {
     return {
       livePlugin,
       checks: [fail(
-        "claude.plugin.path",
-        `Plugin ${CLAUDE_CARRIER_PLUGIN_ID} is registered from ${livePlugin.path}, not the room-owned path ${expectedPath}.`,
+        `${spec.check}.path`,
+        `Plugin ${spec.id} is registered from ${livePlugin.path}, not the room-owned path ${spec.path}.`,
         "Move or remove that conflicting plugin registration manually, then run setup again."
       )]
     };
   }
-  if (desired.pluginPath !== void 0) {
+  if (wanted) {
     const healthy = livePlugin?.enabled === true && livePlugin.status === "running" && livePlugin.error === void 0;
     return {
       ...livePlugin === void 0 ? {} : { livePlugin },
-      operation: { action: livePlugin === void 0 ? "create" : healthy ? "noop" : "update", kind: "plugin", target: CLAUDE_CARRIER_PLUGIN_ID },
+      operation: { action: livePlugin === void 0 ? "create" : healthy ? "noop" : "update", kind: "plugin", target: spec.id },
       checks: []
     };
   }
   return {
     ...livePlugin === void 0 ? {} : { livePlugin },
-    operation: { action: livePlugin === void 0 ? "noop" : "remove", kind: "plugin", target: CLAUDE_CARRIER_PLUGIN_ID },
+    operation: { action: livePlugin === void 0 ? "noop" : "remove", kind: "plugin", target: spec.id },
     checks: []
   };
 }
-async function planRoom(session, desired, stale, expectedPluginPath) {
-  const inspectPlugins = desired.pluginPath !== void 0 || stale.removePlugin;
+async function planRoom(session, desired, stale) {
+  const inspectPlugins = desired.plugins.length > 0 || stale.removePlugins.length > 0;
   const [live, liveProfiles, plugins] = await Promise.all([
     session.readProviders(),
     session.readProfiles(),
     inspectPlugins ? session.listPlugins() : Promise.resolve([])
   ]);
   const byId = new Map(liveProfiles.map((entry) => [String(entry.id), entry]));
-  const plugin = pluginPlan(desired, stale, plugins, expectedPluginPath);
+  const planned = [
+    ...desired.plugins.map((spec) => pluginPlan(spec, true, plugins)),
+    ...stale.removePlugins.map((spec) => pluginPlan(spec, false, plugins))
+  ];
+  const livePlugins = /* @__PURE__ */ new Map();
+  for (const plugin of planned) if (plugin.livePlugin !== void 0) livePlugins.set(plugin.livePlugin.id, plugin.livePlugin);
   return {
     liveProfiles,
-    ...plugin.livePlugin === void 0 ? {} : { livePlugin: plugin.livePlugin },
-    pluginChecks: plugin.checks,
+    livePlugins,
+    pluginChecks: planned.flatMap((plugin) => plugin.checks),
     operations: [
       ...await planEntries(desired.entries),
-      ...Object.entries(desired.providers).map(([id, provider]) => ({
-        action: !(id in live) ? "create" : providerMatches(provider, live[id]) ? "noop" : "update",
+      ...Object.entries(desired.providers).map(([id2, provider]) => ({
+        action: !(id2 in live) ? "create" : providerMatches(provider, live[id2]) ? "noop" : "update",
         kind: "provider",
-        target: id
+        target: id2
       })),
       ...desired.profiles.map((profile) => ({
         action: !byId.has(profile.id) ? "create" : profileMatches(profile, byId.get(profile.id)) ? "noop" : "update",
         kind: "profile",
         target: profile.id
       })),
-      ...stale.providerIds.filter((id) => id in live).map((id) => ({ action: "remove", kind: "provider", target: id })),
-      ...stale.profileIds.filter((id) => byId.has(id)).map((id) => ({ action: "remove", kind: "profile", target: id })),
-      ...plugin.operation === void 0 ? [] : [plugin.operation]
+      ...stale.providerIds.filter((id2) => id2 in live).map((id2) => ({ action: "remove", kind: "provider", target: id2 })),
+      ...stale.profileIds.filter((id2) => byId.has(id2)).map((id2) => ({ action: "remove", kind: "profile", target: id2 })),
+      ...planned.flatMap((plugin) => plugin.operation === void 0 ? [] : [plugin.operation])
     ]
   };
 }
-function pluginsEnabledCheck(enabled) {
-  return enabled ? pass("claude.plugin.enabled", "Paseo plugins are enabled for the required Claude contract carrier.") : fail(
-    "claude.plugin.enabled",
-    "Claude rooms require the paseo-room trusted server plugin, but Paseo plugins are disabled. Plugins are trusted, unsandboxed code with access to the daemon machine.",
+function pluginsEnabledCheck(spec, enabled) {
+  return enabled ? pass(`${spec.check}.enabled`, spec.enabledPass) : fail(
+    `${spec.check}.enabled`,
+    spec.enabledFail,
     "Review that trust boundary, enable plugins in Paseo Settings, reload Paseo, then run setup again."
   );
 }
-function pluginRuntimeCheck(plugin, expectedPath) {
+function pluginRuntimeCheck(spec, plugin) {
   if (plugin === void 0) {
-    return fail("claude.plugin.runtime", `Plugin ${CLAUDE_CARRIER_PLUGIN_ID} is not registered.`, "Run: paseo-room setup --apply");
+    return fail(`${spec.check}.runtime`, `Plugin ${spec.id} is not registered.`, "Run: paseo-room setup --apply");
   }
-  if (plugin.path !== expectedPath) {
+  if (plugin.path !== spec.path) {
     return fail(
-      "claude.plugin.runtime",
-      `Plugin ${CLAUDE_CARRIER_PLUGIN_ID} is registered from ${plugin.path}, not ${expectedPath}.`,
+      `${spec.check}.runtime`,
+      `Plugin ${spec.id} is registered from ${plugin.path}, not ${spec.path}.`,
       "Move or remove that conflicting plugin registration manually, then run setup again."
     );
   }
   if (!plugin.enabled || plugin.status !== "running" || plugin.error !== void 0) {
     const detail = plugin.error === void 0 ? `status ${plugin.status}` : `${plugin.status}: ${plugin.error}`;
-    return fail("claude.plugin.runtime", `Plugin ${CLAUDE_CARRIER_PLUGIN_ID} is not running (${detail}).`, "Run: paseo-room setup --apply");
+    return fail(`${spec.check}.runtime`, `Plugin ${spec.id} is not running (${detail}).`, "Run: paseo-room setup --apply");
   }
-  return pass("claude.plugin.runtime", `Claude contract carrier plugin is running from ${expectedPath}.`);
+  return pass(`${spec.check}.runtime`, `${spec.running} is running from ${spec.path}.`);
 }
-async function reconcilePlugin(session, desired, plan, pending, expectedPath) {
-  if (desired.pluginPath === void 0) {
-    if (plan.livePlugin !== void 0) await session.removePlugin(CLAUDE_CARRIER_PLUGIN_ID);
-    return [];
+async function reconcilePlugins(session, desired, stale, plan, pending) {
+  for (const spec of stale.removePlugins) {
+    if (plan.livePlugins.has(spec.id)) await session.removePlugin(spec.id);
   }
-  let plugin = plan.livePlugin;
-  if (plugin === void 0) {
-    plugin = await session.installPlugin(expectedPath, CLAUDE_CARRIER_PLUGIN_ID);
-  } else {
-    if (!plugin.enabled) plugin = await session.enablePlugin(CLAUDE_CARRIER_PLUGIN_ID);
-    const filesChanged = pending.some(
-      (operation) => (operation.kind === "file" || operation.kind === "dir") && operation.target.startsWith(`${expectedPath}${sep2}`)
-    );
-    const needsReload = filesChanged || plugin.status !== "running" || plugin.error !== void 0;
-    if (needsReload) plugin = await session.reloadPlugin(CLAUDE_CARRIER_PLUGIN_ID);
+  const checks = [];
+  for (const spec of desired.plugins) {
+    let plugin = plan.livePlugins.get(spec.id);
+    if (plugin === void 0) {
+      plugin = await session.installPlugin(spec.path, spec.id);
+    } else {
+      if (!plugin.enabled) plugin = await session.enablePlugin(spec.id);
+      const filesChanged = pending.some(
+        (operation) => (operation.kind === "file" || operation.kind === "dir") && operation.target.startsWith(`${spec.path}${sep3}`)
+      );
+      const needsReload = filesChanged || plugin.status !== "running" || plugin.error !== void 0;
+      if (needsReload) plugin = await session.reloadPlugin(spec.id);
+    }
+    checks.push(pluginRuntimeCheck(spec, plugin));
+  }
+  return checks;
+}
+function pluginRangeCheck(spec, version) {
+  return satisfies(version, spec.paseoRange) ? pass(spec.rangeCheck, `Paseo ${version} is inside the ${spec.running} range ${spec.paseoRange}.`) : fail(spec.rangeCheck, `${spec.running} supports Paseo ${spec.paseoRange}; the running daemon is ${version}.`, spec.rangeRemedy);
+}
+async function runtimeDeselectionCheck(layout) {
+  const summary = await inspectRuntimeState(layout.roomHome);
+  if (summary.projects === 0) return [];
+  if (summary.blockers.length > 0) {
+    return [fail(
+      "runtime.deselect",
+      `Runtime coordination still has active or uncertain work: ${describeBlockers(summary)}.`,
+      "Keep --runtime and finish, close or abandon that work first; the runtime state is preserved either way."
+    )];
   }
-  return [pluginRuntimeCheck(plugin, expectedPath)];
+  return [warn(
+    "runtime.state-retained",
+    `Runtime coordination is quiet; its recorded state for ${String(summary.projects)} project(s) stays at ${summary.root}.`,
+    "Export it with: paseo-room export --out <dir>, or keep it for a later --runtime."
+  )];
+}
+async function runtimeRemovalWarning(layout) {
+  const summary = await inspectRuntimeState(layout.roomHome).catch(() => void 0);
+  if (summary === void 0 || summary.projects === 0) return [];
+  const active = summary.blockers.length > 0 ? ` It still has active or uncertain work: ${describeBlockers(summary)}.` : "";
+  return [warn(
+    "room.remove.runtime-state",
+    `Deleting ${layout.roomHome} also deletes runtime coordination history for ${String(summary.projects)} project(s).${active}`,
+    "Export it first with: paseo-room export --out <dir>"
+  )];
 }
 function markerMemoryContract(agents, memoryContract) {
   return agents.includes("claude") ? memoryContract : void 0;
@@ -2569,23 +3969,29 @@ async function setup(options = {}) {
   const pathSafety = await roomPathSafety(layout, safetyAgents, ROLES);
   if (hasFailure(pathSafety)) return failed("setup", pathSafety);
   const compatibilityAgents = [.../* @__PURE__ */ new Set([...agents, ...previous?.agents ?? []])];
-  const daemon = await checkDaemon(layout, options.env, minimumPaseoVersion(compatibilityAgents));
+  const runtime = options.runtime === true;
+  const daemon = await checkDaemon(layout, options.env, minimumPaseoVersion(compatibilityAgents, runtime || previous?.runtime?.enabled === true));
   if (!daemon.daemon) return failed("setup", daemon.checks);
-  const desired = await buildDesired(layout, agents, ROLES, { memoryContract });
-  const stale = await staleFrom(layout, previous, agents, ROLES);
+  const version = daemon.daemon.version;
+  const desired = await buildDesired(layout, agents, ROLES, { memoryContract, runtime });
+  const stale = await staleFrom(layout, previous, agents, ROLES, runtime);
+  const runtimeChecks = [
+    ...desired.plugins.map((spec) => pluginRangeCheck(spec, version)),
+    ...stale.removePlugins.some((spec) => spec.id === RUNTIME_PLUGIN_ID) ? await runtimeDeselectionCheck(layout) : []
+  ];
   const retained = stale.retainedDirectories.length === 0 ? [] : [warn(
     "room.stale-role-homes-preserved",
     `Preserved ${String(stale.retainedDirectories.length)} deselected role homes because they may contain role-owned credentials or runtime state.`,
     `Use paseo-room remove --apply to delete the entire room after reviewing its credential warning, or remove deselected homes manually: ${stale.retainedDirectories.join(", ")}`
   )];
-  const checks = [...daemon.checks, ...desired.checks, ...retained];
+  const checks = [...daemon.checks, ...runtimeChecks, ...desired.checks, ...retained];
   if (hasFailure(checks)) return failed("setup", checks);
   return withSession(daemon.daemon, async (session) => {
-    const expectedPluginPath = claudeCarrierPluginDir(layout);
-    const plan = await planRoom(session, desired, stale, expectedPluginPath);
+    const plan = await planRoom(session, desired, stale);
     const { operations, liveProfiles } = plan;
     const pending = operations.filter((operation) => operation.action !== "noop");
-    const pluginPreconditions = desired.pluginPath === void 0 ? plan.pluginChecks : [pluginsEnabledCheck(await session.pluginsEnabled()), ...plan.pluginChecks];
+    const enabled = desired.plugins.length === 0 ? true : await session.pluginsEnabled();
+    const pluginPreconditions = [...desired.plugins.map((spec) => pluginsEnabledCheck(spec, enabled)), ...plan.pluginChecks];
     const preApplyDiagnostics = [...checks, ...pluginPreconditions, ...memoryContractDiagnostic(agents, memoryContract), ...contractProvenance(previous), ...thinkingDiagnostics(liveProfiles, desired.profiles)];
     if (hasFailure(preApplyDiagnostics) || !options.apply) {
       return {
@@ -2596,7 +4002,7 @@ async function setup(options = {}) {
         operations
       };
     }
-    const markerPath = join12(layout.roomHome, MARKER);
+    const markerPath = join16(layout.roomHome, MARKER);
     const markerEntries = desired.entries.filter((entry) => entry.path === markerPath);
     await applyEntries(desired.entries.filter((entry) => entry.path !== markerPath));
     const ids = Object.keys(desired.providers);
@@ -2608,14 +4014,15 @@ async function setup(options = {}) {
       await session.writeProfiles(appliedProfiles);
     }
     await session.refresh(ids);
-    const pluginChecks = await reconcilePlugin(session, desired, plan, pending, expectedPluginPath);
+    const pluginChecks = await reconcilePlugins(session, desired, stale, plan, pending);
     await applyEntries(markerEntries);
     const appliedMarker = {
       version: package_default.version,
       agents: [...agents],
       roles: [...ROLES],
       contract: contractDigest(),
-      ...markerMemoryContract(agents, memoryContract) === false ? { claudeMemoryContract: false } : {}
+      ...markerMemoryContract(agents, memoryContract) === false ? { claudeMemoryContract: false } : {},
+      ...desired.runtime === void 0 ? {} : { runtime: desired.runtime }
     };
     const appliedChecks = [
       ...checks,
@@ -2647,17 +4054,23 @@ async function verify(options = {}) {
   if (invalid.length > 0) return failed("verify", invalid);
   const pathSafety = await roomPathSafety(layout, marker.agents, marker.roles);
   if (hasFailure(pathSafety)) return failed("verify", pathSafety);
-  const daemon = await checkDaemon(layout, options.env, minimumPaseoVersion(marker.agents));
+  const runtime = marker.runtime?.enabled === true;
+  const daemon = await checkDaemon(layout, options.env, minimumPaseoVersion(marker.agents, runtime));
   if (!daemon.daemon) return failed("verify", daemon.checks);
+  const version = daemon.daemon.version;
   const desired = await buildDesired(layout, marker.agents, marker.roles, {
-    // The room's own recorded choice, so verify compares against what setup wrote.
-    memoryContract: marker.claudeMemoryContract ?? true
+    // The room's own recorded choices, so verify compares against what setup wrote.
+    memoryContract: marker.claudeMemoryContract ?? true,
+    runtime
   });
-  const checks = [...daemon.checks, ...desired.checks];
-  if (hasFailure(checks)) return failed("verify", checks);
+  const runtimeChecks = [
+    ...desired.plugins.map((spec) => pluginRangeCheck(spec, version)),
+    ...runtime ? [marker.runtime?.generation === desired.runtime?.generation ? pass("runtime.generation", `Runtime manifest generation ${String(desired.runtime?.generation)} matches this package.`) : fail("runtime.generation", `This room was set up with runtime generation ${String(marker.runtime?.generation)}; this package generates ${String(desired.runtime?.generation)}.`, "Run: paseo-room setup --runtime --apply")] : []
+  ];
+  const checks = [...daemon.checks, ...runtimeChecks, ...desired.checks];
+  if (hasFailure(daemon.checks) || hasFailure(desired.checks)) return failed("verify", checks);
   return withSession(daemon.daemon, async (session) => {
-    const expectedPluginPath = claudeCarrierPluginDir(layout);
-    const plan = await planRoom(session, desired, NOTHING_STALE, expectedPluginPath);
+    const plan = await planRoom(session, desired, NOTHING_STALE);
     const { operations, liveProfiles } = plan;
     const drifted = operations.filter((operation) => operation.action !== "noop");
     const count = (kind) => drifted.filter((operation) => operation.kind === kind).length;
@@ -2665,11 +4078,12 @@ async function verify(options = {}) {
     const profiles = count("profile");
     const driftedFiles = drifted.filter((operation) => !["provider", "profile", "plugin"].includes(operation.kind));
     const files = driftedFiles.length;
-    const pluginChecks = desired.pluginPath === void 0 ? [] : [
-      pluginsEnabledCheck(await session.pluginsEnabled()),
-      ...plan.pluginChecks,
-      pluginRuntimeCheck(plan.livePlugin, expectedPluginPath)
-    ];
+    const enabled = desired.plugins.length === 0 ? true : await session.pluginsEnabled();
+    const pluginChecks = desired.plugins.flatMap((spec) => [
+      pluginsEnabledCheck(spec, enabled),
+      ...plan.pluginChecks.filter((check) => check.id.startsWith(`${spec.check}.`)),
+      pluginRuntimeCheck(spec, plan.livePlugins.get(spec.id))
+    ]);
     const all = [
       ...checks,
       files === 0 ? pass("room.files", "Every managed role file matches the current definition.") : fail("room.files", `${fileDriftSummary(driftedFiles)}${fileDriftDetail(driftedFiles.map((operation) => operation.target))}`, "Run: paseo-room setup --apply"),
@@ -2702,22 +4116,26 @@ async function remove(options = {}) {
   if (invalid.length > 0) return failed("remove", invalid);
   const ids = marker.agents.flatMap((agent) => marker.roles.map((role) => providerId(agent, role)));
   const profiles = new Set(marker.agents.flatMap((agent) => marker.roles.map((role) => profileId(agent, role))));
-  const hasClaude = marker.agents.includes("claude");
+  const plugins = [
+    ...marker.agents.includes("claude") ? [carrierSpec(layout)] : [],
+    ...marker.runtime?.enabled === true ? [runtimeSpec(layout)] : []
+  ];
   const operations = [
-    ...ids.map((id) => ({ action: "remove", kind: "provider", target: id })),
-    ...[...profiles].map((id) => ({ action: "remove", kind: "profile", target: id })),
-    ...hasClaude ? [{ action: "remove", kind: "plugin", target: CLAUDE_CARRIER_PLUGIN_ID }] : [],
+    ...ids.map((id2) => ({ action: "remove", kind: "provider", target: id2 })),
+    ...[...profiles].map((id2) => ({ action: "remove", kind: "profile", target: id2 })),
+    ...plugins.map((spec) => ({ action: "remove", kind: "plugin", target: spec.id })),
     { action: "remove", kind: "dir", target: layout.roomHome }
   ];
   const credentialWarning = warn(
     "room.remove.credentials",
     `Deleting ${layout.roomHome} will delete role-owned credential files stored inside it. Native OS keyring entries are not inspected or deleted and may remain. Operator agent-home credentials are untouched.`
   );
+  const runtimeWarnings = await runtimeRemovalWarning(layout);
   if (!options.apply) {
-    return { command: "remove", outcome: "changes-planned", changed: false, checks: [credentialWarning], operations };
+    return { command: "remove", outcome: "changes-planned", changed: false, checks: [credentialWarning, ...runtimeWarnings], operations };
   }
   const daemon = await checkDaemon(layout, options.env);
-  const checks = [credentialWarning];
+  const checks = [credentialWarning, ...runtimeWarnings];
   if (!daemon.daemon) {
     return failed("remove", [
       credentialWarning,
@@ -2731,13 +4149,15 @@ async function remove(options = {}) {
   }
   try {
     await withSession(daemon.daemon, async (session) => {
-      if (hasClaude) {
-        const plugin = (await session.listPlugins()).find((entry) => entry.id === CLAUDE_CARRIER_PLUGIN_ID);
-        const expectedPath = claudeCarrierPluginDir(layout);
-        if (plugin !== void 0 && plugin.path !== expectedPath) {
-          throw new Error(`refusing to remove foreign plugin path ${plugin.path}`);
+      if (plugins.length > 0) {
+        const live2 = await session.listPlugins();
+        for (const spec of plugins) {
+          const plugin = live2.find((entry) => entry.id === spec.id);
+          if (plugin !== void 0 && plugin.path !== spec.path) throw new Error(`refusing to remove foreign plugin path ${plugin.path}`);
+        }
+        for (const spec of plugins) {
+          if (live2.some((entry) => entry.id === spec.id)) await session.removePlugin(spec.id);
         }
-        if (plugin !== void 0) await session.removePlugin(CLAUDE_CARRIER_PLUGIN_ID);
       }
       await session.removeProviders(ids);
       const live = await session.readProfiles();
@@ -2756,7 +4176,7 @@ async function remove(options = {}) {
     ]);
   }
   try {
-    await rm3(layout.roomHome, { recursive: true, force: true });
+    await rm4(layout.roomHome, { recursive: true, force: true });
   } catch (error) {
     const detail = error instanceof Error ? error.message : "unknown filesystem error";
     checks.push(fail(
@@ -2787,9 +4207,11 @@ var init_commands = __esm({
     init_instructions();
     init_skills();
     init_room();
+    init_runtime();
+    init_runtime_state();
     init_roles();
     AGENTS = { codex: codexAgent, claude: claudeAgent, pi: piAgent };
-    NOTHING_STALE = { providerIds: [], profileIds: [], removePlugin: false, retainedDirectories: [] };
+    NOTHING_STALE = { providerIds: [], profileIds: [], removePlugins: [], retainedDirectories: [] };
   }
 });
 
@@ -2840,7 +4262,15 @@ async function runWizard(prompts, emit, write, options = {}, onAction) {
     if (typeof carrier === "symbol") return cancelled();
     claudeMemoryContract = carrier === "both";
   }
-  const setupOptions = { ...options, agents, claudeMemoryContract };
+  const coordination = await prompts.select({
+    message: "Runtime coordination (preview): track assignments, Peer reports and writer ownership through a trusted Paseo plugin?",
+    options: [
+      { value: "off", label: "No \u2014 keep the room as it is (default)" },
+      { value: "runtime", label: "Yes \u2014 install the paseo-room-runtime plugin (trusted, unsandboxed code)" }
+    ]
+  });
+  if (typeof coordination === "symbol") return cancelled();
+  const setupOptions = { ...options, agents, claudeMemoryContract, ...coordination === "runtime" ? { runtime: true } : {} };
   const preview = await setup(setupOptions);
   const status = emit(preview);
   if (preview.outcome !== "changes-planned") return status;
@@ -2866,9 +4296,105 @@ var init_wizard = __esm({
 init_package();
 init_auth();
 init_commands();
-init_fsops();
 import { Command, CommanderError, InvalidArgumentError } from "commander";
 
+// src/export.ts
+init_package();
+init_layout();
+init_result();
+init_schema();
+init_project();
+import { copyFile, mkdir as mkdir4, readdir as readdir6, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { join as join17, resolve as resolve4 } from "path";
+var LIMITATION = "Briefs, answers, reports and gate commands are stored as written and cannot be proven secret-free; review the export before sharing it.";
+async function isEmptyOrAbsent(path) {
+  try {
+    return (await readdir6(path)).length === 0;
+  } catch {
+    return true;
+  }
+}
+async function exportRuntime(options = {}) {
+  const layout = resolveLayout(options, options.env);
+  const root = runtimeRoot(layout.roomHome);
+  let projects;
+  try {
+    projects = (await readdir6(join17(root, "projects"))).sort();
+  } catch {
+    projects = [];
+  }
+  if (projects.length === 0) {
+    return failed("export", [fail("export.nothing", `No runtime state was found under ${root}.`, "Runtime coordination records state only after setup --runtime and a first assignment.")]);
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const destination = resolve4(options.out ?? join17(root, "exports", stamp));
+  if (!await isEmptyOrAbsent(destination)) {
+    return failed("export", [fail("export.destination", `${destination} already exists and is not empty.`, "Choose a new or empty --out directory.")]);
+  }
+  const operations = [{ action: "create", kind: "dir", target: destination }];
+  const summary = [];
+  const copies = [];
+  for (const name of projects) {
+    const source = join17(root, "projects", name);
+    const target = join17(destination, "projects", name);
+    let meta;
+    try {
+      meta = JSON.parse(await readFile5(join17(source, "meta.json"), "utf8"));
+    } catch {
+      meta = {};
+    }
+    const entry = { projectId: meta.projectId ?? name, canonicalRoot: meta.canonicalRoot ?? "unknown", events: 0, omitted: [], gateOutputs: 0 };
+    copies.push([join17(source, "meta.json"), join17(target, "meta.json")]);
+    for (const file of (await readdir6(join17(source, "events")).catch(() => [])).sort()) {
+      if (file.startsWith(".tmp-")) continue;
+      let valid2;
+      try {
+        valid2 = readEvent(JSON.parse(await readFile5(join17(source, "events", file), "utf8"))).ok;
+      } catch {
+        valid2 = false;
+      }
+      if (valid2) {
+        entry.events += 1;
+        copies.push([join17(source, "events", file), join17(target, "events", file)]);
+      } else entry.omitted.push(file);
+    }
+    for (const file of (await readdir6(join17(source, "gates")).catch(() => [])).sort()) {
+      if (file.endsWith(".result.json")) copies.push([join17(source, "gates", file), join17(target, "gates", file)]);
+      else if (file.endsWith(".log") && options.includeGateOutput === true) {
+        entry.gateOutputs += 1;
+        copies.push([join17(source, "gates", file), join17(target, "gates", file)]);
+      }
+    }
+    summary.push(entry);
+  }
+  operations.push(...copies.map(([, target]) => ({ action: "create", kind: "file", target })));
+  operations.push({ action: "create", kind: "file", target: join17(destination, "summary.json") });
+  const checks = [
+    warn("export.limitation", LIMITATION),
+    ...options.includeGateOutput === true ? [warn("export.gate-output", "Gate output tails are included; they are best-effort masked only.")] : [],
+    ...summary.filter((entry) => entry.omitted.length > 0).map((entry) => warn("export.omitted", `Project ${entry.projectId}: ${String(entry.omitted.length)} unreadable event file(s) were left out by name: ${entry.omitted.join(", ")}.`))
+  ];
+  if (!options.apply) return { command: "export", outcome: "changes-planned", changed: false, checks, operations };
+  await mkdir4(destination, { recursive: true, mode: 448 });
+  for (const [from, to] of copies) {
+    await mkdir4(join17(to, ".."), { recursive: true, mode: 448 });
+    await copyFile(from, to);
+  }
+  await writeFile3(join17(destination, "summary.json"), `${JSON.stringify({
+    schema: 1,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    packageVersion: package_default.version,
+    gateOutputIncluded: options.includeGateOutput === true,
+    limitation: LIMITATION,
+    projects: summary
+  }, null, 2)}
+`, { mode: 384 });
+  return { command: "export", outcome: "ok", changed: true, checks: [...checks, pass("export.written", `Exported ${String(summary.length)} project(s) to ${destination}.`)], operations };
+}
+
+// src/cli.ts
+init_fsops();
+
 // src/render.ts
 function renderJson(result) {
   return `${JSON.stringify({ schemaVersion: 2, ...result }, null, 2)}
@@ -2901,7 +4427,7 @@ init_roles();
 init_prompts();
 init_skills();
 function collectAgent(value, previous) {
-  const agent = AGENT_IDS.find((id) => id === value);
+  const agent = AGENT_IDS.find((id2) => id2 === value);
   if (!agent) throw new InvalidArgumentError(`Unknown agent: ${value}`);
   const seated = previous ?? [];
   return seated.includes(agent) ? seated : [...seated, agent];
@@ -2920,7 +4446,8 @@ function optionsFrom(raw, base) {
     ...agents ? { agents } : {},
     ...raw.apply === true ? { apply: true } : {},
     // Commander defaults a --no- flag to true, so only an explicit opt-out is carried.
-    ...raw.claudeMemoryContract === false ? { claudeMemoryContract: false } : {}
+    ...raw.claudeMemoryContract === false ? { claudeMemoryContract: false } : {},
+    ...raw.runtime === true ? { runtime: true } : {}
   };
 }
 function failedFromThrown(command, error) {
@@ -2950,7 +4477,7 @@ function failedFromThrown(command, error) {
 }
 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;
+  const redact = (text3) => password ? text3.split(password).join("[redacted]") : text3;
   let json = false;
   const emit = (result) => {
     output.stdout(redact(json ? renderJson(result) : renderHuman(result)));
@@ -2969,8 +4496,8 @@ async function runCli(argv, output, context = {}) {
       return await runWizard2(
         context.prompts ?? terminalPrompts2,
         emit,
-        (text) => {
-          output.stdout(text);
+        (text3) => {
+          output.stdout(text3);
         },
         base,
         (action) => {
@@ -2981,10 +4508,10 @@ async function runCli(argv, output, context = {}) {
       return emit(failedFromThrown(wizardCommand, error));
     }
   }
-  const program = new Command().name("paseo-room").description("Configure Codex/Claude/Pi role homes in $HOME and register them with your local Paseo daemon.").version(package_default.version).usage("<setup|verify|remove> [options]\n       auth login <codex|claude|pi> <supervisor|lead|peer> [options]").argument("<command>", "setup | verify | remove | auth").argument("[command-arguments...]", "auth login <agent> <role>").option("--agent <agent>", "codex, claude, or pi; repeat to combine (default: codex)", collectAgent).option("--apply", "actually make the changes (default: dry run)").option("--json", "machine-readable output").option("--no-claude-memory-contract", "omit the role contract from Claude role CLAUDE.md files, leaving the room plugin as the only Claude carrier").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("--pi-home <path>", "source Pi config (default: ~/.pi/agent)").option("--codex-bin <path>", "Codex executable (default: found on PATH)").option("--claude-bin <path>", "Claude Code executable (default: found on PATH)").option("--pi-bin <path>", "Pi 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);
+  const program = new Command().name("paseo-room").description("Configure Codex/Claude/Pi role homes in $HOME and register them with your local Paseo daemon.").version(package_default.version).usage("<setup|verify|remove|export> [options]\n       auth login <codex|claude|pi> <supervisor|lead|peer> [options]").argument("<command>", "setup | verify | remove | export | auth").argument("[command-arguments...]", "auth login <agent> <role>").option("--agent <agent>", "codex, claude, or pi; repeat to combine (default: codex)", collectAgent).option("--apply", "actually make the changes (default: dry run)").option("--json", "machine-readable output").option("--no-claude-memory-contract", "omit the role contract from Claude role CLAUDE.md files, leaving the room plugin as the only Claude carrier").option("--runtime", "opt in to runtime coordination (preview): installs the trusted paseo-room-runtime plugin; omit it to deselect").option("--out <dir>", "export: destination directory (default: a new directory under the room's runtime exports)").option("--include-gate-output", "export: also copy bounded gate output tails (best-effort masked)").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("--pi-home <path>", "source Pi config (default: ~/.pi/agent)").option("--codex-bin <path>", "Codex executable (default: found on PATH)").option("--claude-bin <path>", "Claude Code executable (default: found on PATH)").option("--pi-bin <path>", "Pi executable (default: found on PATH)").option("--paseo-bin <path>", "Paseo executable (default: found on PATH)").configureOutput({ writeOut: (text3) => {
+    output.stdout(text3);
+  }, writeErr: (text3) => {
+    output.stderr(text3);
   } }).exitOverride();
   let command;
   let commandArguments;
@@ -3004,10 +4531,24 @@ async function runCli(argv, output, context = {}) {
   try {
     if (raw.claudeMemoryContract === false && (command === "verify" || command === "remove")) {
       output.stderr(`paseo-room ${command}: --no-claude-memory-contract is a setup choice recorded in the room marker; ${command} reads it from there.
+`);
+      return 2;
+    }
+    if ((raw.out !== void 0 || raw.includeGateOutput === true) && command !== "export") {
+      output.stderr(`paseo-room ${command}: --out and --include-gate-output only apply to export.
+`);
+      return 2;
+    }
+    if (raw.runtime === true && (command === "verify" || command === "remove" || command === "export")) {
+      output.stderr(`paseo-room ${command}: --runtime is a setup choice recorded in the room marker; ${command} reads it from there.
 `);
       return 2;
     }
     if (command === "auth") {
+      if (raw.runtime === true) {
+        output.stderr("paseo-room auth login only authenticates a role and does not use --runtime.\n");
+        return 2;
+      }
       if (raw.claudeMemoryContract === false) {
         output.stderr("paseo-room auth login only authenticates a role and does not use --no-claude-memory-contract.\n");
         return 2;
@@ -3042,21 +4583,28 @@ async function runCli(argv, output, context = {}) {
     if (command === "setup") return emit(await setup(options));
     if (command === "verify") return emit(await verify(options));
     if (command === "remove") return emit(await remove(options));
+    if (command === "export") {
+      return emit(await exportRuntime({
+        ...options,
+        ...typeof raw.out === "string" && raw.out.trim() !== "" ? { out: raw.out.trim() } : {},
+        ...raw.includeGateOutput === true ? { includeGateOutput: true } : {}
+      }));
+    }
   } catch (error) {
     return emit(failedFromThrown(command, error));
   }
-  output.stderr(`paseo-room: unknown command "${command}". Try: setup, verify, remove, or auth login.
+  output.stderr(`paseo-room: unknown command "${command}". Try: setup, verify, remove, export, or auth login.
 `);
   return 2;
 }
 
 // src/index.ts
 process.exitCode = await runCli(process.argv.slice(2), {
-  stdout: (text) => {
-    process.stdout.write(text);
+  stdout: (text3) => {
+    process.stdout.write(text3);
   },
-  stderr: (text) => {
-    process.stderr.write(text);
+  stderr: (text3) => {
+    process.stderr.write(text3);
   }
 });
 //# sourceMappingURL=index.js.map