paseo-room 0.4.1 → 0.6.0

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "paseo-room",
-      version: "0.4.1",
+      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/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,15 +163,9 @@ function preservedCredentialCheck(input) {
 function presentNames(names, supported) {
   return supported.filter((name) => names.has(name));
 }
-function configuredByNamesCheck(id, agent, role, names) {
+function ambientNamesCheck(id2, agent, role, names) {
   return warn(
-    `${id}.configured-structurally`,
-    `${agent} ${role} auth: configured structurally; ${names.join(", ")} ${names.length === 1 ? "is" : "are"} present by name. Values, token validity, and freshness were not checked.`
-  );
-}
-function ambientNamesCheck(id, 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.`
   );
 }
@@ -220,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).`
       ));
     }
   }
@@ -450,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" };
@@ -472,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) {
@@ -513,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()
     });
   }
 });
@@ -683,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 {
@@ -710,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) {
@@ -765,18 +771,11 @@ function validateHeadOrCapsule(source, kind) {
   }
   return trimmed;
 }
-function validateSection(source) {
-  const trimmed = source.trimEnd();
-  if (!trimmed.trim()) throw new Error("is empty.");
-  const lines = trimmed.split("\n");
-  const heading = lines.shift() ?? "";
-  if (!/^## \S.*$/.test(heading) || headingCount(trimmed, 2) !== 1) {
-    throw new Error("section must begin with exactly one H2 heading.");
-  }
-  if (lines.some((line) => /^#{1,6}\s/.test(line))) {
+function renderSection(heading, bodyLines) {
+  if (bodyLines.some((line) => /^#{1,6}\s/.test(line))) {
     throw new Error("section must not contain additional Markdown headings.");
   }
-  const body = lines.join("\n").trim();
+  const body = bodyLines.join("\n").trim();
   if (!body) throw new Error("section must contain at least one non-empty statement.");
   const statements = body.split(/\n\s*\n/).map(
     (statement) => statement.split("\n").map((line) => line.trim()).join(" ")
@@ -787,6 +786,40 @@ function validateSection(source) {
   return `${heading}
 ${statements.map((statement) => `- ${statement}`).join("\n")}`;
 }
+function validateSection(source) {
+  const trimmed = source.trimEnd();
+  if (!trimmed.trim()) throw new Error("is empty.");
+  const lines = trimmed.split("\n");
+  const heading = lines.shift() ?? "";
+  if (!/^## \S.*$/.test(heading) || headingCount(trimmed, 2) !== 1) {
+    throw new Error("section must begin with exactly one H2 heading.");
+  }
+  return renderSection(heading, lines);
+}
+function splitSections(lines) {
+  const preface = [];
+  const sections = [];
+  for (const line of lines) {
+    if (/^## \S.*$/.test(line)) {
+      sections.push({ heading: line, lines: [] });
+      continue;
+    }
+    const current2 = sections.at(-1);
+    if (current2 === void 0) preface.push(line);
+    else current2.lines.push(line);
+  }
+  return { preface, sections };
+}
+function validateBody(source) {
+  const trimmed = source.trimEnd();
+  if (!trimmed.trim()) throw new Error("is empty.");
+  const { preface, sections } = splitSections(trimmed.split("\n"));
+  if (sections.length === 0) throw new Error("role body must contain at least one H2 section.");
+  if (preface.some((line) => line.trim())) {
+    throw new Error("role body must not contain content above its first H2 heading.");
+  }
+  return sections.map((section) => renderSection(section.heading, section.lines)).join("\n\n");
+}
 function loadPromptAsset(group, key) {
   const logicalAsset = `${group}.${String(key)}`;
   const cached = cache.get(logicalAsset);
@@ -796,7 +829,7 @@ function loadPromptAsset(group, key) {
   try {
     const source = readFileSync(assetUrl, "utf8");
     if (source.includes("\uFFFD")) throw new Error("is not valid UTF-8 text.");
-    const validated = asset.kind === "section" ? validateSection(source) : validateHeadOrCapsule(source, asset.kind);
+    const validated = validate(source, asset.kind);
     cache.set(logicalAsset, validated);
     return validated;
   } catch (error) {
@@ -805,6 +838,16 @@ function loadPromptAsset(group, key) {
     throw new PromptAssetError(logicalAsset, assetUrl, detail, { cause: error });
   }
 }
+function validate(source, kind) {
+  switch (kind) {
+    case "section":
+      return validateSection(source);
+    case "body":
+      return validateBody(source);
+    default:
+      return validateHeadOrCapsule(source, kind);
+  }
+}
 var PROMPT_ASSETS, PromptAssetError, cache;
 var init_prompts = __esm({
   "src/room/prompts.ts"() {
@@ -813,38 +856,15 @@ var init_prompts = __esm({
       documents: {
         supervisor: { path: "documents/supervisor.md", kind: "head" },
         lead: { path: "documents/lead.md", kind: "head" },
-        peer: { path: "documents/peer.md", kind: "head" },
-        workspace: { path: "documents/workspace.md", kind: "head" }
+        peer: { path: "documents/peer.md", kind: "head" }
       },
       contract: {
-        humanAuthority: { path: "contract/shared/human-authority.md", kind: "section" },
-        workspaceProtocolPrecedence: { path: "contract/shared-supervisor-lead/workspace-protocol-precedence.md", kind: "section" },
-        evidenceAndEventWaiting: { path: "contract/shared/evidence-and-event-waiting.md", kind: "section" },
-        scopeAndUnrelatedWork: { path: "contract/shared/scope-and-unrelated-work.md", kind: "section" },
-        directiveIntegrity: { path: "contract/supervisor/directive-integrity.md", kind: "section" },
-        technicalNonInterference: { path: "contract/supervisor/technical-non-interference.md", kind: "section" },
-        leadDiscoveryAndRecovery: { path: "contract/supervisor/lead-discovery-and-recovery.md", kind: "section" },
-        observationAndAdvice: { path: "contract/supervisor/observation-and-advice.md", kind: "section" },
-        escalationBoundaries: { path: "contract/supervisor/escalation-boundaries.md", kind: "section" },
-        projectTechnicalOwnership: { path: "contract/lead/project-technical-ownership.md", kind: "section" },
-        movingWriteOwnership: { path: "contract/lead/moving-write-ownership.md", kind: "section" },
-        completePeerBrief: { path: "contract/lead/complete-peer-brief.md", kind: "section" },
-        challengeSignals: { path: "contract/shared-lead-peer/challenge-signals.md", kind: "section" },
-        technicalAcceptance: { path: "contract/lead/technical-acceptance.md", kind: "section" },
-        independentReview: { path: "contract/lead/independent-review.md", kind: "section" },
-        peerSeatLifecycle: { path: "contract/lead/peer-seat-lifecycle.md", kind: "section" },
-        boundedOutcome: { path: "contract/peer/bounded-outcome.md", kind: "section" },
-        independentJudgment: { path: "contract/peer/independent-judgment.md", kind: "section" },
-        assignmentScope: { path: "contract/peer/assignment-scope.md", kind: "section" },
-        noOrchestration: { path: "contract/peer/no-orchestration.md", kind: "section" },
-        reproducibleHandoff: { path: "contract/peer/reproducible-handoff.md", kind: "section" },
-        noSelfAcceptance: { path: "contract/peer/no-self-acceptance.md", kind: "section" }
-      },
-      workspace: {
-        topology: { path: "workspace/topology.md", kind: "section" },
-        verification: { path: "workspace/verification.md", kind: "section" },
-        review: { path: "workspace/review.md", kind: "section" },
-        repositoryConventions: { path: "workspace/repository-conventions.md", kind: "section" }
+        sharedAuthority: { path: "contract/shared-authority.md", kind: "body" },
+        sharedSeatIdentity: { path: "contract/shared-seat-identity.md", kind: "section" },
+        challengeSignals: { path: "contract/challenge-signals.md", kind: "section" },
+        supervisor: { path: "contract/supervisor.md", kind: "body" },
+        lead: { path: "contract/lead.md", kind: "body" },
+        peer: { path: "contract/peer.md", kind: "body" }
       },
       pi: {
         communicationStyle: { path: "pi/communication-style.md", kind: "capsule" },
@@ -868,24 +888,12 @@ var init_prompts = __esm({
 // src/room/instructions.ts
 import { createHash } from "crypto";
 function instructionKeys(role) {
-  return [...SHARED_KEYS[role], ...ROLE_KEYS[role]];
-}
-function protocolKeys(role) {
-  return PROTOCOL_KEYS[role];
-}
-function protocol(keys) {
-  if (keys.length === 0) return [];
-  return [
-    loadPromptAsset("documents", "workspace"),
-    ...keys.map((key) => loadPromptAsset("workspace", key))
-  ];
+  return [...SHARED_KEYS[role], ROLE_KEYS[role]];
 }
 function renderInstructions(kind) {
-  if (kind === "workspace") return protocol(ALL_PROTOCOL_KEYS).join("\n\n") + "\n";
   return [
     loadPromptAsset("documents", kind),
-    ...instructionKeys(kind).map((key) => loadPromptAsset("contract", key)),
-    ...protocol(protocolKeys(kind))
+    ...instructionKeys(kind).map((key) => loadPromptAsset("contract", key))
   ].join("\n\n") + "\n";
 }
 function contractDigest() {
@@ -893,68 +901,23 @@ function contractDigest() {
   for (const kind of INSTRUCTION_KINDS) hash.update(`${kind}\0${renderInstructions(kind)}\0`);
   return `sha256:${hash.digest("hex").slice(0, 16)}`;
 }
-var AUTHORITY_KEYS, PROTOCOL_READER_KEYS, SHARED_KEYS, ROLE_KEYS, ALL_PROTOCOL_KEYS, PROTOCOL_KEYS, INSTRUCTION_KINDS;
+var SHARED_KEYS, ROLE_KEYS, INSTRUCTION_KINDS;
 var init_instructions = __esm({
   "src/room/instructions.ts"() {
     "use strict";
     init_roles();
     init_prompts();
-    AUTHORITY_KEYS = [
-      "humanAuthority",
-      "evidenceAndEventWaiting",
-      "scopeAndUnrelatedWork"
-    ];
-    PROTOCOL_READER_KEYS = [
-      "humanAuthority",
-      "workspaceProtocolPrecedence",
-      "evidenceAndEventWaiting",
-      "scopeAndUnrelatedWork"
-    ];
     SHARED_KEYS = {
-      supervisor: PROTOCOL_READER_KEYS,
-      lead: PROTOCOL_READER_KEYS,
-      peer: AUTHORITY_KEYS
+      supervisor: ["sharedAuthority", "sharedSeatIdentity"],
+      lead: ["sharedAuthority", "sharedSeatIdentity", "challengeSignals"],
+      peer: ["sharedAuthority", "challengeSignals"]
     };
     ROLE_KEYS = {
-      supervisor: [
-        "directiveIntegrity",
-        "technicalNonInterference",
-        "leadDiscoveryAndRecovery",
-        "observationAndAdvice",
-        "escalationBoundaries"
-      ],
-      lead: [
-        "projectTechnicalOwnership",
-        "movingWriteOwnership",
-        "completePeerBrief",
-        "challengeSignals",
-        "technicalAcceptance",
-        "independentReview",
-        "peerSeatLifecycle"
-      ],
-      // Peer needs Challenge Signals as well as its own obligations.
-      peer: [
-        "challengeSignals",
-        "boundedOutcome",
-        "independentJudgment",
-        "assignmentScope",
-        "noOrchestration",
-        "reproducibleHandoff",
-        "noSelfAcceptance"
-      ]
-    };
-    ALL_PROTOCOL_KEYS = [
-      "topology",
-      "verification",
-      "review",
-      "repositoryConventions"
-    ];
-    PROTOCOL_KEYS = {
-      supervisor: ALL_PROTOCOL_KEYS,
-      lead: ALL_PROTOCOL_KEYS,
-      peer: []
+      supervisor: "supervisor",
+      lead: "lead",
+      peer: "peer"
     };
-    INSTRUCTION_KINDS = [...ROLES, "workspace"];
+    INSTRUCTION_KINDS = [...ROLES];
   }
 });
 
@@ -1011,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.`
   );
@@ -1040,14 +1003,39 @@ function isPaseoSkill(name) {
 function receivesExecutableResources(role) {
   return role !== "peer";
 }
-async function skillNames(path, reserved) {
+function receivesRoomSkill(role) {
+  return role === "lead";
+}
+async function skillNames(path, reserved, keep) {
   try {
-    return (await readdir2(path)).filter((name) => !isPaseoSkill(name) && !reserved.has(name)).sort();
+    return (await readdir2(path)).filter((name) => keep(name) && !reserved.has(name.toLowerCase())).sort();
   } catch (error) {
     if (error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
     throw error;
   }
 }
+async function skillsProjection(input, path, alias, present, reserved) {
+  const roomSkill = receivesRoomSkill(input.role) ? input.roomSkill : void 0;
+  const projectsChildren = !receivesExecutableResources(input.role) || roomSkill !== void 0;
+  if (!projectsChildren) return void 0;
+  const reservedNames = new Set([...reserved].map((name) => name.toLowerCase()));
+  const keep = roomSkill === void 0 ? (name) => !isPaseoSkill(name) : (name) => name.toLowerCase() !== roomSkill.name.toLowerCase();
+  const operator = present.has(path) ? await skillNames(path, reservedNames, keep) : [];
+  const children = roomSkill === void 0 ? operator : [...operator, roomSkill.name];
+  const projection = input.role === "lead" ? input.leadSkillProjection : alias;
+  return [
+    {
+      kind: "managed-dir",
+      path: projection,
+      children,
+      ...input.role === "peer" ? { legacyLink: path } : {},
+      ...reserved.size === 0 ? {} : { reserved: [...reserved] }
+    },
+    ...operator.map((child) => ({ kind: "link", path: join6(projection, child), target: join6(path, child) })),
+    ...roomSkill === void 0 ? [] : [{ kind: "link", path: join6(projection, roomSkill.name), target: roomSkill.source }],
+    ...input.role === "lead" ? [{ kind: "link", path: alias, target: projection }] : []
+  ];
+}
 async function roleResourceEntries(input) {
   const present = new Set(input.shared);
   const executable = new Set(input.executable);
@@ -1056,21 +1044,14 @@ async function roleResourceEntries(input) {
   for (const name of input.names) {
     const path = join6(input.home, name);
     const alias = join6(input.target, name);
-    if (!receivesExecutableResources(input.role)) {
-      if (executable.has(name)) continue;
-      if (name === SKILLS) {
-        const children = present.has(path) ? await skillNames(path, reserved) : [];
-        entries.push({
-          kind: "managed-dir",
-          path: alias,
-          children,
-          legacyLink: path,
-          ...reserved.size === 0 ? {} : { reserved: [...reserved] }
-        });
-        for (const child of children) entries.push({ kind: "link", path: join6(alias, child), target: join6(path, child) });
+    if (name === SKILLS) {
+      const projection = await skillsProjection(input, path, alias, present, reserved);
+      if (projection !== void 0) {
+        entries.push(...projection);
         continue;
       }
     }
+    if (!receivesExecutableResources(input.role) && executable.has(name)) continue;
     if (!present.has(path)) continue;
     entries.push({ kind: "link", path: alias, target: path });
   }
@@ -1084,9 +1065,99 @@ var init_resources = __esm({
   }
 });
 
+// src/room/skills.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join7 } from "path";
+function validateSkillAsset(path, source) {
+  if (source.includes("\uFFFD")) throw new Error("is not valid UTF-8 text.");
+  if (!source.trim()) throw new Error("is empty.");
+  if (path === "SKILL.md") {
+    const frontmatter = /^---\n([\s\S]*?)\n---\n/.exec(source)?.[1];
+    if (frontmatter === void 0) throw new Error("must begin with YAML frontmatter.");
+    const declaredName = /^name: (.+)$/m.exec(frontmatter)?.[1];
+    if (declaredName !== ROOM_SKILL_NAME) {
+      throw new Error(`frontmatter name must be ${ROOM_SKILL_NAME}.`);
+    }
+    if (!/^description: \S.+$/m.test(frontmatter)) {
+      throw new Error("frontmatter must contain a non-empty single-line description.");
+    }
+  }
+  if (path === "references/workspace-protocol-template.md" && !source.startsWith("# Workspace protocol template (scaffold)\n")) {
+    throw new Error("must begin with the workspace protocol scaffold heading.");
+  }
+  return source;
+}
+function loadSkillAsset(path) {
+  const cached = cache2.get(path);
+  if (cached !== void 0) return cached;
+  const logicalAsset = `${ROOM_SKILL_NAME}/${path}`;
+  const assetUrl = new URL(`./skills/${ROOM_SKILL_NAME}/${path}`, import.meta.url);
+  try {
+    const validated = validateSkillAsset(path, readFileSync2(assetUrl, "utf8"));
+    cache2.set(path, validated);
+    return validated;
+  } catch (error) {
+    if (error instanceof SkillAssetError) throw error;
+    const detail = error instanceof Error ? error.message : "could not be read.";
+    throw new SkillAssetError(logicalAsset, assetUrl, detail, { cause: error });
+  }
+}
+function roomSkillSource(layout) {
+  return join7(sharedRoom(layout), "skills", ROOM_SKILL_NAME);
+}
+function skillProjectionRoot(layout) {
+  return join7(sharedRoom(layout), "skill-projections");
+}
+function agentSkillProjectionRoot(layout, agent) {
+  return join7(skillProjectionRoot(layout), agent);
+}
+function leadSkillProjection(layout, agent) {
+  return join7(agentSkillProjectionRoot(layout, agent), "lead");
+}
+function roomSkillEntries(layout, agents) {
+  const root = roomSkillSource(layout);
+  return [
+    { kind: "dir", path: join7(sharedRoom(layout), "skills") },
+    { kind: "dir", path: skillProjectionRoot(layout) },
+    ...agents.map((agent) => ({ kind: "dir", path: agentSkillProjectionRoot(layout, agent) })),
+    { kind: "managed-dir", path: root, children: ["SKILL.md", ...SKILL_DIRECTORIES] },
+    {
+      kind: "managed-dir",
+      path: join7(root, "references"),
+      children: SKILL_FILES.filter((path) => path.startsWith("references/")).map((path) => path.slice("references/".length))
+    },
+    ...SKILL_FILES.map((path) => ({
+      kind: "file",
+      path: join7(root, path),
+      content: loadSkillAsset(path)
+    }))
+  ];
+}
+var ROOM_SKILL_NAME, SKILL_DIRECTORIES, SKILL_FILES, SkillAssetError, cache2;
+var init_skills = __esm({
+  "src/room/skills.ts"() {
+    "use strict";
+    init_layout();
+    ROOM_SKILL_NAME = "paseo-project-onboarding";
+    SKILL_DIRECTORIES = ["references"];
+    SKILL_FILES = ["SKILL.md", "references/workspace-protocol-template.md"];
+    SkillAssetError = class extends Error {
+      logicalAsset;
+      assetUrl;
+      constructor(logicalAsset, assetUrl, detail, options) {
+        super(`Skill asset ${logicalAsset} at ${assetUrl.pathname} ${detail} Reinstall paseo-room and try again.`, options);
+        this.name = "SkillAssetError";
+        this.logicalAsset = logicalAsset;
+        this.assetUrl = assetUrl;
+      }
+    };
+    cache2 = /* @__PURE__ */ new Map();
+  }
+});
+
 // src/agents/claude.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function asObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
 }
@@ -1105,17 +1176,21 @@ async function readStateIfPresent(path) {
     throw error;
   }
 }
-function renderRoleSettings(source, role, secureStorageDir) {
-  const settings = readObject(source);
-  settings.env = {
-    ...asObject(settings.env),
-    ...CONTROL_PLANE_ENV,
-    PASEO_ROOM_ROLE: role,
-    ...secureStorageDir === void 0 ? {} : { [SECURE_STORAGE_ENV]: secureStorageDir }
+function renderRoleSettings(role, secureStorageDir) {
+  const settings = {
+    // Claude applies settings.env after the launch environment, so repeat provider closures here.
+    env: {
+      ...CONTROL_PLANE_ENV,
+      PASEO_ROOM_ROLE: role,
+      ...secureStorageDir === void 0 ? {} : { [SECURE_STORAGE_ENV]: secureStorageDir }
+    },
+    // Provider disallowedTools is not sufficient alone; the isolated home carries the same list.
+    permissions: { deny: DISALLOWED_TOOLS },
+    // These restrictive settings cannot be weakened by another settings scope.
+    disableAgentView: true,
+    disableWorkflows: true,
+    crossSessionInbound: "refuse"
   };
-  settings.disableAgentView = true;
-  settings.disableWorkflows = true;
-  settings.crossSessionInbound = "refuse";
   return JSON.stringify(settings, null, 2) + "\n";
 }
 function renderRoleState(source) {
@@ -1132,41 +1207,31 @@ function renderRoleMemory(source, role, contract = true) {
 
 ${renderInstructions(role)}` : renderInstructions(role);
 }
-function claudeAuthMethodNames(settingsSource, envNames) {
-  const settings = readObject(settingsSource);
-  const settingsEnv = asObject(settings.env);
-  const names = new Set(presentNames(envNames, AUTH_ENV));
-  for (const name of AUTH_ENV) if (Object.hasOwn(settingsEnv, name)) names.add(name);
-  if (Object.hasOwn(settings, "apiKeyHelper")) names.add("apiKeyHelper");
-  return [...names];
-}
-async function claudeCredentialDiagnostic(layout, role, settingsSource, platform = process.platform, binary = "claude") {
+async function claudeCredentialDiagnostic(layout, role, platform = process.platform, binary = "claude") {
   const home = roleHome(layout, "claude", role);
-  const path = join7(home, ".credentials.json");
+  const path = join8(home, ".credentials.json");
   const roleEnvironment = { CLAUDE_CONFIG_DIR: home, [SECURE_STORAGE_ENV]: home };
   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 configured = claudeAuthMethodNames(settingsSource, /* @__PURE__ */ new Set());
-  if (configured.length > 0) return { path, checks: [configuredByNamesCheck(id, "Claude", role, configured)] };
   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 configured environment/static auth method was detected. Authentication was not attempted.`,
+    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}.`
   }] };
 }
@@ -1181,7 +1246,7 @@ function mcpDriftCheck(role, home, path, divergence) {
     `If this role should have the same servers, add them with: CLAUDE_CONFIG_DIR=${home} claude mcp add ... \u2014 or delete ${path} and run setup --apply to reseed it from your current Claude state, which discards that role's other runtime state.`
   );
 }
-var SHARED, EXECUTABLE, RUNTIME_SKILLS, MCP_KEY, AUTH_ENV, CONTROL_PLANE_ENV, SECURE_STORAGE_ENV, SEEDED_KEYS, claudeAgent;
+var SHARED, EXECUTABLE, RUNTIME_SKILLS, MCP_KEY, AUTH_ENV, CONTROL_PLANE_ENV, DISALLOWED_TOOLS, SECURE_STORAGE_ENV, SEEDED_KEYS, claudeAgent;
 var init_claude = __esm({
   "src/agents/claude.ts"() {
     "use strict";
@@ -1193,6 +1258,7 @@ var init_claude = __esm({
     init_which();
     init_mcp();
     init_resources();
+    init_skills();
     SHARED = [
       "skills",
       "plugins",
@@ -1218,6 +1284,22 @@ var init_claude = __esm({
       CLAUDE_CODE_DISABLE_AGENT_VIEW: "1",
       CLAUDE_CODE_DISABLE_WORKFLOWS: "1"
     };
+    DISALLOWED_TOOLS = [
+      "Task",
+      "Agent",
+      "Workflow",
+      "ListAgents",
+      "SendMessage",
+      "TeamCreate",
+      "TeamDelete",
+      "TaskCreate",
+      "TaskGet",
+      "TaskList",
+      "TaskUpdate",
+      "CronCreate",
+      "CronDelete",
+      "CronList"
+    ];
     SECURE_STORAGE_ENV = "CLAUDE_SECURESTORAGE_CONFIG_DIR";
     SEEDED_KEYS = ["hasCompletedOnboarding", "theme", "installMethod", "userID", MCP_KEY];
     claudeAgent = {
@@ -1230,24 +1312,7 @@ var init_claude = __esm({
       // Keep the legacy Task name and block current native orchestration,
       // shared task/cron coordination, and cross-session paths. Paseo alone owns
       // agent lifecycle and coordination.
-      pins: {
-        disallowedTools: [
-          "Task",
-          "Agent",
-          "Workflow",
-          "ListAgents",
-          "SendMessage",
-          "TeamCreate",
-          "TeamDelete",
-          "TaskCreate",
-          "TaskGet",
-          "TaskList",
-          "TaskUpdate",
-          "CronCreate",
-          "CronDelete",
-          "CronList"
-        ]
-      },
+      pins: { disallowedTools: DISALLOWED_TOOLS },
       async build(layout, roles, options = {}) {
         const home = layout.agentHome.claude;
         const binary = await which(layout.bin.claude, layout.searchPath);
@@ -1258,8 +1323,7 @@ var init_claude = __esm({
           return { entries: [], checks: [fail("claude.home", `No Claude config directory at ${home}.`, "Run claude once to initialise it, or pass --claude-home.")] };
         }
         const checks = [pass("claude.home", `Claude Code found at ${binary} using ${home}.`)];
-        const settingsSource = await readIfPresent(join7(home, "settings.json"));
-        const memorySource = await readIfPresent(join7(home, "CLAUDE.md"));
+        const memorySource = await readIfPresent(join8(home, "CLAUDE.md"));
         let stateSource;
         let operatorServers;
         try {
@@ -1279,9 +1343,10 @@ var init_claude = __esm({
         const credentials = [];
         const providerEnv = {};
         const drift = [];
+        const roomSkill = { name: ROOM_SKILL_NAME, source: roomSkillSource(layout) };
         for (const role of roles) {
           const target = roleHome(layout, "claude", role);
-          const statePath = join7(target, ".claude.json");
+          const statePath = join8(target, ".claude.json");
           let roleStateSource;
           let roleServers;
           try {
@@ -1301,13 +1366,23 @@ var init_claude = __esm({
             if (divergence) drift.push(mcpDriftCheck(role, target, statePath, divergence));
           }
           entries.push({ kind: "dir", path: target });
-          const memoryPath = join7(target, "CLAUDE.md");
+          const memoryPath = join8(target, "CLAUDE.md");
           const memory = renderRoleMemory(memorySource, role, options.memoryContract ?? true);
           entries.push(memory === void 0 ? { kind: "absent", path: memoryPath } : { kind: "file", path: memoryPath, content: memory });
-          entries.push({ kind: "file", path: join7(target, "settings.json"), content: renderRoleSettings(settingsSource, role, target) });
+          entries.push({ kind: "file", path: join8(target, "settings.json"), content: renderRoleSettings(role, target) });
           entries.push({ kind: "file", path: statePath, content: renderRoleState(stateSource), once: true });
-          entries.push(...await roleResourceEntries({ role, target, home, names: SHARED, shared, executable: EXECUTABLE, reservedSkills: RUNTIME_SKILLS }));
-          credentials.push(await claudeCredentialDiagnostic(layout, role, settingsSource, process.platform, binary));
+          entries.push(...await roleResourceEntries({
+            role,
+            target,
+            home,
+            names: SHARED,
+            shared,
+            executable: EXECUTABLE,
+            reservedSkills: RUNTIME_SKILLS,
+            roomSkill,
+            leadSkillProjection: leadSkillProjection(layout, "claude")
+          }));
+          credentials.push(await claudeCredentialDiagnostic(layout, role, process.platform, binary));
           providerEnv[role] = { [SECURE_STORAGE_ENV]: target };
         }
         return { entries, credentials, checks: [...checks, ...drift], binary, providerEnv };
@@ -1317,7 +1392,7 @@ var init_claude = __esm({
 });
 
 // src/agents/codex.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { parse, stringify } from "smol-toml";
 function table(parent, key) {
   const value = parent[key];
@@ -1374,18 +1449,18 @@ function codexCredentialStore(config) {
 }
 async function credentialDiagnostic(layout, role, store, binary) {
   const home = roleHome(layout, "codex", role);
-  const path = join8(home, "auth.json");
+  const path = join9(home, "auth.json");
   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}.`
@@ -1394,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}.`
@@ -1403,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}.`
@@ -1423,6 +1498,7 @@ var init_codex = __esm({
     init_which();
     init_mcp();
     init_resources();
+    init_skills();
     SHARED2 = ["AGENTS.md", "skills", "plugins", "hooks.json"];
     EXECUTABLE2 = ["plugins", "hooks.json"];
     CATALOG = "model-catalog.json";
@@ -1441,7 +1517,7 @@ var init_codex = __esm({
         if (!binary) {
           return { entries: [], checks: [fail("codex.bin", "Codex executable not found.", "Install Codex, or pass --codex-bin /path/to/codex.")] };
         }
-        const configPath = join8(home, "config.toml");
+        const configPath = join9(home, "config.toml");
         const raw = await readIfPresent(configPath);
         if (raw === void 0) {
           return { entries: [], checks: [fail("codex.home", `No config.toml in ${home}.`, "Run codex once to initialise it, or pass --codex-home.")] };
@@ -1489,19 +1565,29 @@ var init_codex = __esm({
         }
         checks.push(pass("codex.catalog", evidence2.markers === 0 ? `Codex model catalog captured from ${capture}; it declared no multi_agent_version field, and each role home gets that generated copy instead of Codex's built-in catalog.` : `Codex model catalog captured from ${capture}; ${String(evidence2.markers)} multi_agent_version field(s) are nulled in the generated copy in each role home.`));
         const shared = await existingPaths(home, SHARED2);
+        const roomSkill = { name: ROOM_SKILL_NAME, source: roomSkillSource(layout) };
         for (const role of roles) {
           const target = roleHome(layout, "codex", role);
-          const catalogPath = join8(target, CATALOG);
+          const catalogPath = join9(target, CATALOG);
           const roleDocument = renderInstructions(role);
           entries.push({ kind: "dir", path: target });
-          entries.push({ kind: "file", path: join8(target, "role-instructions.md"), content: roleDocument });
+          entries.push({ kind: "file", path: join9(target, "role-instructions.md"), content: roleDocument });
           entries.push({
             kind: "file",
-            path: join8(target, "config.toml"),
+            path: join9(target, "config.toml"),
             content: renderRoleConfig(source, { roleDocument, catalogPath })
           });
           entries.push({ kind: "file", path: catalogPath, content: catalogSource });
-          entries.push(...await roleResourceEntries({ role, target, home, names: SHARED2, shared, executable: EXECUTABLE2 }));
+          entries.push(...await roleResourceEntries({
+            role,
+            target,
+            home,
+            names: SHARED2,
+            shared,
+            executable: EXECUTABLE2,
+            roomSkill,
+            leadSkillProjection: leadSkillProjection(layout, "codex")
+          }));
           credentials.push(await credentialDiagnostic(layout, role, store, binary));
         }
         return { entries, credentials, checks, binary };
@@ -1514,7 +1600,7 @@ var init_codex = __esm({
 import { spawn as spawn2 } from "child_process";
 import { mkdtemp, readFile as readFile3, realpath, rm as rm2, stat } from "fs/promises";
 import { tmpdir } from "os";
-import { isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute2, join as join10, resolve as resolve3 } from "path";
 function asObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : void 0;
 }
@@ -1538,12 +1624,12 @@ function adapterFailure(home, detail) {
   return fail(
     "pi.adapter",
     detail,
-    `Install ${PACKAGE_NAME} in ${join9(home, "npm")} with Pi yourself, then run setup again.`
+    `Install ${PACKAGE_NAME} in ${join10(home, "npm")} with Pi yourself, then run setup again.`
   );
 }
 async function resolvePiAdapter(home) {
-  const packageRoot = join9(home, "npm", "node_modules", PACKAGE_NAME);
-  const manifestPath = join9(packageRoot, "package.json");
+  const packageRoot = join10(home, "npm", "node_modules", PACKAGE_NAME);
+  const manifestPath = join10(packageRoot, "package.json");
   try {
     const [canonicalRoot, manifestStat, raw] = await Promise.all([
       realpath(packageRoot),
@@ -1608,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;
@@ -1640,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", () => {
     });
@@ -1651,7 +1737,7 @@ function runProbeProcess(executable, adapterEntry, env, options, cwd) {
   });
 }
 async function runProbe(executable, adapterEntry, env, options) {
-  const createdCwd = await mkdtemp(join9(tmpdir(), "paseo-room-pi-probe-"));
+  const createdCwd = await mkdtemp(join10(tmpdir(), "paseo-room-pi-probe-"));
   const cwd = await realpath(createdCwd);
   try {
     return await runProbeProcess(executable, adapterEntry, {
@@ -1728,15 +1814,15 @@ async function readPiOptional(path) {
 }
 async function piCredentialDiagnostic(layout, role, binary = "pi") {
   const home = roleHome(layout, "pi", role);
-  const path = join9(home, "auth.json");
+  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,
@@ -1746,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.`
@@ -1768,6 +1854,7 @@ var init_pi = __esm({
     init_which();
     init_mcp();
     init_resources();
+    init_skills();
     PACKAGE_NAME = "pi-mcp-adapter";
     PROBE_ID = "paseo-room-pi-mcp-probe";
     PROBE_TIMEOUT_MS = 1e4;
@@ -1824,7 +1911,7 @@ var init_pi = __esm({
           PI_OFFLINE: "1"
         });
         if (capability.status === "fail") return { entries: [], checks: [resolved.check, capability] };
-        const settingsPath = join9(home, "settings.json");
+        const settingsPath = join10(home, "settings.json");
         let settings;
         try {
           settings = renderPiSettings(await readPiOptional(settingsPath));
@@ -1842,7 +1929,7 @@ var init_pi = __esm({
             ]
           };
         }
-        const operatorAppendPath = join9(home, "APPEND_SYSTEM.md");
+        const operatorAppendPath = join10(home, "APPEND_SYSTEM.md");
         let operatorAppend;
         try {
           operatorAppend = await readPiOptional(operatorAppendPath);
@@ -1861,7 +1948,7 @@ var init_pi = __esm({
           };
         }
         const shared = await existingPaths(home, SHARED3);
-        const mcpPath = join9(home, MCP_FILE);
+        const mcpPath = join10(home, MCP_FILE);
         let servers;
         try {
           servers = jsonServerTable(await readPiOptional(mcpPath), MCP_KEYS);
@@ -1884,13 +1971,23 @@ var init_pi = __esm({
         const entries = [];
         const credentials = [];
         const argv = {};
+        const roomSkill = { name: ROOM_SKILL_NAME, source: roomSkillSource(layout) };
         for (const role of roles) {
           const target = roleHome(layout, "pi", role);
-          const appendPath = join9(target, "APPEND_SYSTEM.md");
+          const appendPath = join10(target, "APPEND_SYSTEM.md");
           entries.push({ kind: "dir", path: target });
-          entries.push({ kind: "file", path: join9(target, "settings.json"), content: settings });
+          entries.push({ kind: "file", path: join10(target, "settings.json"), content: settings });
           entries.push({ kind: "file", path: appendPath, content: renderPiAppend(operatorAppend, role) });
-          entries.push(...await roleResourceEntries({ role, target, home, names: SHARED3, shared, executable: EXECUTABLE3 }));
+          entries.push(...await roleResourceEntries({
+            role,
+            target,
+            home,
+            names: SHARED3,
+            shared,
+            executable: EXECUTABLE3,
+            roomSkill,
+            leadSkillProjection: leadSkillProjection(layout, "pi")
+          }));
           credentials.push(await piCredentialDiagnostic(layout, role, binary));
           argv[role] = ["--no-extensions", "--extension", resolved.adapter.entry, "--no-approve", "--append-system-prompt", appendPath];
         }
@@ -1909,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());
@@ -1919,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")] };
@@ -1928,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.")] };
   }
@@ -1959,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() {
@@ -1987,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(),
@@ -1997,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 {
@@ -2030,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] });
@@ -2100,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({
@@ -2116,20 +2224,29 @@ var init_paseo = __esm({
 });
 
 // src/plugin.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join11 } from "path";
 function loadAsset(path) {
-  return readFileSync2(new URL(`./plugin-assets/${path}`, import.meta.url), "utf8");
+  return readFileSync3(new URL(`./plugin-assets/${path}`, import.meta.url), "utf8");
 }
 function claudeCarrierPluginDir(layout) {
-  return join10(layout.roomHome, "plugin");
+  return join11(layout.roomHome, "plugin");
+}
+function typescriptTemplateLiteral(value) {
+  const escaped = value.replaceAll("\\", "\\\\").replaceAll("`", "\\`").replaceAll("${", "\\${");
+  return `\`${escaped}\``;
 }
 function renderClaudeCarrierContract(roles) {
-  const contracts = Object.fromEntries(roles.map((role) => [providerId("claude", role), renderInstructions(role)]));
+  const entries = roles.map((role) => {
+    const id2 = JSON.stringify(providerId("claude", role));
+    return `  ${id2}: ${typescriptTemplateLiteral(renderInstructions(role))},`;
+  });
   return [
     "/** Generated by paseo-room. The Markdown prompt assets remain authoritative. */",
     `export const GENERATION = ${JSON.stringify(contractDigest())};`,
-    `export const CONTRACT: Readonly<Record<string, string>> = ${JSON.stringify(contracts, null, 2)};`,
+    "export const CONTRACT: Readonly<Record<string, string>> = {",
+    ...entries,
+    "};",
     ""
   ].join("\n");
 }
@@ -2137,18 +2254,19 @@ function claudeCarrierEntries(layout, roles) {
   const root = claudeCarrierPluginDir(layout);
   return [
     { kind: "dir", path: root },
-    { kind: "dir", path: join10(root, "server") },
-    ...STATIC_ASSETS.map((path) => ({ kind: "file", path: join10(root, path), content: loadAsset(path) })),
-    { kind: "file", path: join10(root, "server", "contract.ts"), content: renderClaudeCarrierContract(roles) }
+    { kind: "dir", path: join11(root, "server") },
+    ...STATIC_ASSETS.map((path) => ({ kind: "file", path: join11(root, path), content: loadAsset(path) })),
+    { 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",
@@ -2159,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 join11, 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 } : {} };
@@ -2188,18 +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) },
-    { kind: "file", path: join11(sharedRoom(layout), "WORKSPACE_PROTOCOL.md"), content: renderInstructions("workspace") }
+    // 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: 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);
@@ -2209,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 } : {},
@@ -2223,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: join11(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 ${join11(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: join11(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."
   )];
 }
@@ -2272,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",
@@ -2300,17 +3759,32 @@ async function safeDirectory(path, checks) {
 async function roomPathSafety(layout, agents, roles) {
   const checks = [];
   if (!await safeDirectory(layout.roomHome, checks)) return checks;
-  await safeDirectory(sharedRoom(layout), checks);
-  const rolesHome = join11(layout.roomHome, "roles");
+  const room = sharedRoom(layout);
+  const roomIsSafe = await safeDirectory(room, checks);
+  if (roomIsSafe && agents.length > 0) {
+    const skills = join16(room, "skills");
+    if (await safeDirectory(skills, checks)) {
+      const source = roomSkillSource(layout);
+      if (await safeDirectory(source, checks)) await safeDirectory(join16(source, "references"), checks);
+    }
+    const projections = skillProjectionRoot(layout);
+    if (await safeDirectory(projections, checks)) {
+      for (const agent of agents) {
+        const agentRoot = agentSkillProjectionRoot(layout, agent);
+        if (await safeDirectory(agentRoot, checks)) await safeDirectory(leadSkillProjection(layout, agent), checks);
+      }
+    }
+  }
+  const rolesHome = join16(layout.roomHome, "roles");
   if (!await safeDirectory(rolesHome, checks)) return checks;
   for (const agent of agents) {
-    const agentHome = join11(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 = [];
@@ -2328,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 [pluginRuntimeCheck(plugin, expectedPath)];
+  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 [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;
@@ -2457,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 {
@@ -2484,7 +4002,7 @@ async function setup(options = {}) {
         operations
       };
     }
-    const markerPath = join11(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);
@@ -2496,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,
@@ -2535,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;
@@ -2553,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"),
@@ -2590,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,
@@ -2619,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();
@@ -2644,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(
@@ -2673,10 +4205,13 @@ var init_commands = __esm({
     init_plugin();
     init_result();
     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: [] };
   }
 });
 
@@ -2727,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;
@@ -2753,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)}
@@ -2786,8 +4425,9 @@ function renderHuman(result) {
 init_result();
 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];
@@ -2806,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) {
@@ -2817,6 +4458,13 @@ function failedFromThrown(command, error) {
       "Reinstall paseo-room, then try again."
     )]);
   }
+  if (error instanceof SkillAssetError) {
+    return failed(command, [fail(
+      `${command}.skill-asset`,
+      error.message,
+      "Reinstall paseo-room, then try again."
+    )]);
+  }
   if (error instanceof ManagedPathError) {
     return failed(command, [fail(`${command}.managed-path`, error.message, error.fix)]);
   }
@@ -2829,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)));
@@ -2848,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) => {
@@ -2860,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;
@@ -2883,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;
@@ -2921,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