paseo-room 0.6.0 → 0.7.0

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "paseo-room",
-      version: "0.6.0",
+      version: "0.7.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",
@@ -51,7 +51,8 @@ var init_package = __esm({
         "test:package": "vitest run --config vitest.package.config.ts",
         build: `tsup && node --input-type=module -e "import { cpSync, rmSync } from 'node:fs'; for (const [source, target] of [['src/room/prompts', 'dist/prompts'], ['src/room/skills', 'dist/skills'], ['src/plugin-assets', 'dist/plugin-assets'], ['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"
+        verify: "npm run typecheck && npm run lint && npm test && npm run build && npm run test:package",
+        "attention:eval": "node --experimental-transform-types --no-warnings --import ./scripts/ts-resolve.mjs scripts/attention-eval.ts"
       },
       dependencies: {
         "@clack/prompts": "^1.8.0",
@@ -1546,9 +1547,9 @@ var init_codex = __esm({
         let catalogSource;
         let evidence2;
         try {
-          const parsed = JSON.parse(models.stdout);
-          evidence2 = catalogEvidence(parsed);
-          catalogSource = renderCatalog(parsed);
+          const parsed2 = JSON.parse(models.stdout);
+          evidence2 = catalogEvidence(parsed2);
+          catalogSource = renderCatalog(parsed2);
         } catch {
           return { entries: [], checks: [...checks, fail(
             "codex.catalog",
@@ -1605,8 +1606,8 @@ function asObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? { ...value } : void 0;
 }
 function renderPiSettings(source) {
-  const parsed = source === void 0 ? {} : JSON.parse(source);
-  const settings = asObject2(parsed);
+  const parsed2 = source === void 0 ? {} : JSON.parse(source);
+  const settings = asObject2(parsed2);
   if (!settings) throw new Error("Pi settings must be a JSON object.");
   delete settings.packages;
   delete settings.extensions;
@@ -1772,13 +1773,13 @@ async function probePiMcp(executable, adapterEntry, env, options = {}) {
   }
   const correlated = [];
   for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
-    let parsed;
+    let parsed2;
     try {
-      parsed = JSON.parse(line);
+      parsed2 = JSON.parse(line);
     } catch {
       return probeFailure("Pi capability probe returned malformed JSONL.");
     }
-    const event = asObject2(parsed);
+    const event = asObject2(parsed2);
     if (!event) return probeFailure("Pi capability probe returned malformed JSONL.");
     if (event.type === "response" && event.id === PROBE_ID) correlated.push(event);
   }
@@ -2017,11 +2018,11 @@ function normalizeUrl(listen) {
   return `ws://${local}:${port}`;
 }
 function assessStatus(raw, minimumVersion = MINIMUM_VERSION, cliVersion) {
-  const parsed = statusSchema.safeParse(raw);
-  if (!parsed.success) {
+  const parsed2 = statusSchema.safeParse(raw);
+  if (!parsed2.success) {
     return { checks: [fail("paseo.status", "Paseo status output was not understood.", "Upgrade Paseo, then run: paseo daemon status --json")] };
   }
-  const status = parsed.data;
+  const status = parsed2.data;
   if (status.localDaemon !== "running") {
     return { checks: [fail("paseo.daemon", `Paseo daemon is ${status.localDaemon}.`, "Start it with: paseo daemon start")] };
   }
@@ -2289,7 +2290,7 @@ var init_policy = __esm({
     "use strict";
     RUNTIME_ROLES = ["supervisor", "lead", "peer"];
     RUNTIME_AGENTS = ["codex", "claude", "pi"];
-    SUPERVISOR_OPERATIONS = ["room_status", "runtime_findings", "message_lead"];
+    SUPERVISOR_OPERATIONS = ["room_status", "runtime_findings", "message_lead", "attention_feedback"];
     LEAD_OPERATIONS = [
       "assignment_create",
       "assignment_dispatch",
@@ -2300,7 +2301,9 @@ var init_policy = __esm({
       "assignment_abandon",
       "assignment_close",
       "assignment_status",
-      "gate_run"
+      "gate_run",
+      "workspace_close",
+      "lease_reclaim"
     ];
     PEER_REPORTING_TOOLS = ["ask", "handoff"];
     RUNTIME_CAPABILITIES = [
@@ -2464,12 +2467,191 @@ var init_runtime = __esm({
   }
 });
 
+// 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, MAX_WORKTREE_LEASES;
+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();
+    MAX_WORKTREE_LEASES = 3;
+  }
+});
+
+// src/runtime-plugin/server/domain/scope.ts
+function normalizeScope(raw) {
+  return raw.normalize("NFC").replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+}
+function refusal(raw, text3) {
+  if (utf8Bytes(raw) > MAX_STRING_BYTES) return `longer than ${String(MAX_STRING_BYTES)} bytes`;
+  if (text3 === "") return "empty";
+  if (text3.includes("\\")) return "contains a backslash";
+  if (text3.startsWith("/")) return "is absolute";
+  if (text3.startsWith("!")) return "is a negation";
+  if (/[{}]/.test(text3)) return "uses brace expansion";
+  if (/[[\]]/.test(text3)) return "uses a character class";
+  if (text3.split("/").some((segment) => segment === "." || segment === "..")) return "has a . or .. segment";
+  return void 0;
+}
+function parseScope(raw) {
+  const text3 = normalizeScope(raw);
+  const reason3 = refusal(raw, text3);
+  if (reason3 !== void 0) return { ok: false, item: raw, reason: reason3 };
+  const segments = text3.split("/").map((segment) => /^\*+$/.test(segment) && segment.length > 1 ? GLOBSTAR : segment.replace(/\*{2,}/g, "*"));
+  if (segments.at(-1) !== GLOBSTAR) segments.push(GLOBSTAR);
+  return { ok: true, entry: { text: text3, segments } };
+}
+function parseScopes(raws) {
+  if (raws.length === 0) return { ok: true, entries: [WHOLE_REPOSITORY] };
+  const entries = [];
+  for (const raw of raws) {
+    const parsed2 = parseScope(raw);
+    if (!parsed2.ok) return parsed2;
+    entries.push(parsed2.entry);
+  }
+  return { ok: true, entries };
+}
+function fold(value) {
+  return codePoints(value).map((point) => {
+    const lower = point.toLowerCase();
+    return codePoints(lower).length === 1 ? lower : point;
+  });
+}
+function segmentMatches(pattern, literal) {
+  let row = new Array(literal.length + 1).fill(false);
+  row[literal.length] = true;
+  for (let i = pattern.length - 1; i >= 0; i--) {
+    const next = new Array(literal.length + 1).fill(false);
+    for (let j = literal.length; j >= 0; j--) {
+      const token = pattern[i];
+      if (token === "*") next[j] = (row[j] ?? false) || j < literal.length && (next[j + 1] ?? false);
+      else next[j] = j < literal.length && (token === "?" || token === literal[j]) && (row[j + 1] ?? false);
+    }
+    row = next;
+  }
+  return row[0] ?? false;
+}
+function fixedEnds(pattern) {
+  const wildcards = pattern.flatMap((point, index) => point === "*" || point === "?" ? [index] : []);
+  return { prefix: pattern.slice(0, wildcards[0]), suffix: pattern.slice((wildcards.at(-1) ?? pattern.length) + 1) };
+}
+function segmentsIntersect(a, b) {
+  const left = fold(a);
+  const right = fold(b);
+  const leftPattern = isPattern(a);
+  const rightPattern = isPattern(b);
+  if (!leftPattern && !rightPattern) return left.join("") === right.join("");
+  if (!rightPattern) return segmentMatches(left, right);
+  if (!leftPattern) return segmentMatches(right, left);
+  const l = fixedEnds(left);
+  const r = fixedEnds(right);
+  const suffixesAgree = agree([...l.suffix].reverse(), [...r.suffix].reverse());
+  return agree(l.prefix, r.prefix) && suffixesAgree;
+}
+function sequencesIntersect(a, b) {
+  const width = b.length + 1;
+  const table2 = new Uint8Array((a.length + 1) * width);
+  const at = (i, j) => table2[i * width + j] === 1;
+  for (let i = a.length; i >= 0; i--) {
+    for (let j = b.length; j >= 0; j--) {
+      let value;
+      if (i === a.length && j === b.length) value = true;
+      else if (i === a.length) value = b[j] === GLOBSTAR && at(i, j + 1);
+      else if (j === b.length) value = a[i] === GLOBSTAR && at(i + 1, j);
+      else if (a[i] === GLOBSTAR || b[j] === GLOBSTAR) value = at(i + 1, j) || at(i, j + 1);
+      else value = segmentsIntersect(a[i] ?? "", b[j] ?? "") && at(i + 1, j + 1);
+      table2[i * width + j] = value ? 1 : 0;
+    }
+  }
+  return at(0, 0);
+}
+function overlaps(a, b) {
+  return sequencesIntersect(a.segments, b.segments);
+}
+function firstOverlap(as, bs) {
+  for (const a of as) for (const b of bs) if (overlaps(a, b)) return [a, b];
+  return void 0;
+}
+function reaches(scope, serialPath) {
+  return overlaps(scope, serialPath);
+}
+var GLOBSTAR, WHOLE_REPOSITORY, codePoints, isPattern, agree;
+var init_scope = __esm({
+  "src/runtime-plugin/server/domain/scope.ts"() {
+    "use strict";
+    init_limits();
+    GLOBSTAR = "**";
+    WHOLE_REPOSITORY = { text: GLOBSTAR, segments: [GLOBSTAR] };
+    codePoints = (value) => Array.from(value);
+    isPattern = (segment) => segment.includes("*") || segment.includes("?");
+    agree = (a, b) => a.every((point, index) => index >= b.length || point === b[index]);
+  }
+});
+
 // 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 };
+  return { projectId, assignments: /* @__PURE__ */ new Map(), ownership: /* @__PURE__ */ new Map(), workspaces: /* @__PURE__ */ new Map(), notices: /* @__PURE__ */ new Map(), lastSequence: 0 };
+}
+function activeWriter(state, except) {
+  for (const owner of state.ownership.values()) if (owner.state !== "released" && owner.assignmentId !== except) return owner;
+  return void 0;
+}
+function leadWorkspaceWriter(state, except) {
+  for (const owner of state.ownership.values()) {
+    if (owner.state !== "released" && owner.lease === void 0 && owner.assignmentId !== except) return owner;
+  }
+  return void 0;
 }
-function activeWriter(state) {
-  for (const owner of state.ownership.values()) if (owner.state !== "released") return owner;
+function activeLeases(state, except) {
+  return [...state.ownership.values()].filter((owner) => owner.lease !== void 0 && owner.state !== "released" && owner.assignmentId !== except);
+}
+function parsed(raws, empty) {
+  if (raws.length === 0 && empty === "none") return [];
+  const result = parseScopes(raws);
+  return result.ok ? result.entries : `${result.item} ${result.reason}`;
+}
+function leaseCollision(state, assignmentId, request) {
+  const exclusive = leadWorkspaceWriter(state, assignmentId);
+  if (exclusive !== void 0) return { code: "writer_exclusive", message: `Assignment ${exclusive.assignmentId} writes in Lead's workspace (${exclusive.state}); it excludes every other writer.` };
+  const leases = activeLeases(state, assignmentId);
+  const uncertain = leases.find((lease) => lease.state === "uncertain");
+  if (uncertain !== void 0) return { code: "writer_uncertain", message: `The writer of ${uncertain.assignmentId} is uncertain; no new writer starts until it is proven stopped.` };
+  if (leases.length >= MAX_WORKTREE_LEASES) return { code: "lease_cap", message: `${String(MAX_WORKTREE_LEASES)} worktree leases are already held in this project.` };
+  const mine = parsed(request.scopes, "whole");
+  if (typeof mine === "string") return { code: "scope_not_canonical", message: `writeScope item ${mine}.` };
+  const serial = parsed(request.serialOnly, "none");
+  if (typeof serial === "string") return { code: "scope_not_canonical", message: `serialOnly item ${serial}.` };
+  const others = leases.map((lease) => ({ lease, scopes: parsed(lease.lease.scopes, "whole"), serial: parsed(lease.lease.serialOnly, "none") }));
+  for (const other of others) {
+    if (typeof other.scopes === "string" || typeof other.serial === "string") {
+      return { code: "scope_overlap", message: `The scopes of ${other.lease.assignmentId} cannot be compared.` };
+    }
+    const overlap = firstOverlap(mine, other.scopes);
+    if (overlap !== void 0) return { code: "scope_overlap", message: `${overlap[0].text} overlaps ${overlap[1].text} held by ${other.lease.assignmentId}.` };
+  }
+  const union = [...serial, ...others.flatMap((other) => typeof other.serial === "string" ? [] : other.serial)];
+  for (const path of union) {
+    if (!mine.some((scope) => reaches(scope, path))) continue;
+    const holder = others.find((other) => typeof other.scopes !== "string" && other.scopes.some((scope) => reaches(scope, path)));
+    if (holder !== void 0) return { code: "serial_path", message: `${path.text} is serial-only and ${holder.lease.assignmentId} already writes under it.` };
+  }
   return void 0;
 }
 function need(condition, message) {
@@ -2511,11 +2693,13 @@ function checkEvent(state, event) {
   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.");
+      return inState(assignment2, ["draft"], "dispatch") ?? need(state.ownershipConflict === void 0, "Dispatch is paused by a Lead ownership conflict.") ?? need(!writable || leadWorkspaceWriter(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.");
+      return need(writable, "A read-only assignment reserves no writer ownership.") ?? inState(assignment2, ["dispatching"], "reserve ownership") ?? need(leadWorkspaceWriter(state) === void 0, "Another writer still owns this project.");
+    case "agent.create-requested": {
+      const lease = owner?.lease;
+      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.") ?? need(!writable || lease !== void 0 || activeWriter(state, assignment2.id) === void 0, "Another writer still owns this project.") ?? need(lease === void 0 || state.workspaces.get(assignment2.id)?.create === "succeeded" && event.data.workspaceId === lease.workspaceId, "A leased Peer is created only in its proven worktree.");
+    }
     case "agent.create-succeeded":
     case "agent.create-failed":
     case "agent.create-uncertain":
@@ -2580,6 +2764,38 @@ function checkEvent(state, event) {
       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 "lease.reserved": {
+      const collision = leaseCollision(state, assignment2.id, event.data);
+      return need(writable, "A read-only assignment holds no lease.") ?? inState(assignment2, ["dispatching"], "reserve a lease") ?? need(owner?.state === "reserved" && owner.lease === void 0 && owner.agentId === void 0, "A lease extends a fresh reservation.") ?? need(owner?.workspaceId === event.data.workspaceId && owner.baseCommit === event.data.baseCommit, "The lease names a different workspace or base than the reservation.") ?? (collision === void 0 ? void 0 : `${collision.code}: ${collision.message}`);
+    }
+    case "workspace.create-requested":
+      return inState(assignment2, ["dispatching"], "request a worktree") ?? need(owner?.state === "reserved" && owner.lease?.workspaceId === event.data.workspaceId && owner.lease.baseCommit === event.data.baseCommit, "A worktree is requested only for its reserved lease.") ?? need(!state.workspaces.has(assignment2.id), "This assignment already requested its worktree.");
+    case "workspace.create-succeeded":
+    case "workspace.create-failed":
+    case "workspace.create-uncertain":
+    case "workspace.create-refused": {
+      const record = state.workspaces.get(assignment2.id);
+      const from = event.type === "workspace.create-uncertain" ? ["requested"] : ["requested", "uncertain"];
+      return need(record !== void 0 && record.createIntentId === event.data.intentId && from.includes(record.create), "No unresolved worktree create matches.") ?? need(!("workspaceId" in event.data) || event.data.workspaceId === record?.workspaceId, "The result names a different workspace.");
+    }
+    case "lease.reclaimed": {
+      const check = reclaimCheck(state, assignment2.id);
+      if (!check.ok) return check.message;
+      return need(event.data.fromEpoch === check.value.lease.epoch && event.data.toEpoch === event.data.fromEpoch + 1, "A reclaim moves the lease to exactly the next epoch.") ?? need(event.data.priorAgentId === check.value.prior, "The reclaim names a different writer than the lease holder.");
+    }
+    case "scope.exceeded":
+      return need(owner?.lease !== void 0, "Only a leased candidate has scopes to exceed.") ?? need(assignment2.candidate?.commit === event.data.candidateCommit, "The evidence names a different candidate.");
+    case "workspace.close-requested": {
+      const record = state.workspaces.get(assignment2.id);
+      return need(record?.workspaceId === event.data.workspaceId && (record.create === "succeeded" || record.create === "refused"), "Only a created worktree is closed.") ?? need(record?.close === "open" || record?.close === "failed", "The worktree is already closing or closed.") ?? need(owner?.state === "released", "A worktree closes only after its writer is proven released.") ?? need(!event.data.discardUncommitted || event.data.reason !== void 0, "Discarding uncommitted work needs a reason.");
+    }
+    case "workspace.close-succeeded":
+    case "workspace.close-failed":
+    case "workspace.close-uncertain": {
+      const record = state.workspaces.get(assignment2.id);
+      const from = event.type === "workspace.close-uncertain" ? ["requested"] : ["requested", "uncertain"];
+      return need(record !== void 0 && record.closeIntentId === event.data.intentId && from.includes(record.close) && record.workspaceId === event.data.workspaceId, "No unresolved worktree close matches.");
+    }
     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":
@@ -2612,6 +2828,21 @@ function setOwner(state, id2, change) {
   const current2 = state.ownership.get(id2);
   if (current2 !== void 0) state.ownership.set(id2, { ...current2, ...change });
 }
+function setLease(state, id2, change) {
+  const current2 = state.ownership.get(id2);
+  if (current2?.lease !== void 0) state.ownership.set(id2, { ...current2, lease: { ...current2.lease, ...change } });
+}
+function setWorkspace(state, id2, change, event) {
+  const current2 = state.workspaces.get(id2);
+  if (current2 !== void 0) state.workspaces.set(id2, { ...current2, ...change, eventIds: [...current2.eventIds, event.id] });
+}
+function reclaimed(view, event) {
+  const copy = { ...withoutPermission(view) };
+  delete copy.peerAgentId;
+  delete copy.observedProviderId;
+  delete copy.observedModel;
+  return { ...copy, state: "dispatching", reportingState: "consumed", eventIds: [...view.eventIds, event.id] };
+}
 function applyReport(state, view, event) {
   const report = {
     generation: event.data.generation,
@@ -2629,6 +2860,12 @@ function applyReport(state, view, event) {
     ...event.data.candidate === void 0 ? {} : { candidate: event.data.candidate },
     ...event.data.inspectedCommit === void 0 ? {} : { inspectedCommit: event.data.inspectedCommit }
   }, event);
+  const next = state.assignments.get(view.id);
+  if (next?.scopeExceeded !== void 0 && event.data.candidate !== void 0 && event.data.candidate.commit !== next.scopeExceeded.candidateCommit) {
+    const copy = { ...next };
+    delete copy.scopeExceeded;
+    state.assignments.set(view.id, copy);
+  }
 }
 function applyEvent(state, event) {
   state.lastSequence = Math.max(state.lastSequence, event.sequence);
@@ -2792,6 +3029,80 @@ function applyEvent(state, event) {
       setOwner(state, id2, { state: "uncertain" });
       update(state, id2, {}, event);
       return;
+    case "lease.reserved":
+      setOwner(state, id2, {
+        lease: {
+          workspaceId: event.data.workspaceId,
+          branch: event.data.branch,
+          baseCommit: event.data.baseCommit,
+          scopes: event.data.scopes,
+          serialOnly: event.data.serialOnly,
+          epoch: event.data.epoch,
+          priorAgentIds: []
+        }
+      });
+      update(state, id2, {}, event);
+      return;
+    case "workspace.create-requested":
+      state.workspaces.set(id2, {
+        assignmentId: id2,
+        workspaceId: event.data.workspaceId,
+        idempotencyKey: event.data.idempotencyKey,
+        baseCommit: event.data.baseCommit,
+        branchName: event.data.branchName,
+        worktreeSlug: event.data.worktreeSlug,
+        create: "requested",
+        createIntentId: event.data.intentId,
+        close: "open",
+        eventIds: [event.id]
+      });
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, event.type) }, event);
+      return;
+    case "workspace.create-succeeded":
+      setWorkspace(state, id2, { create: "succeeded", worktreePath: event.data.worktreePath, branch: event.data.branch, headCommit: event.data.headCommit }, event);
+      setLease(state, id2, { worktreePath: event.data.worktreePath, branch: event.data.branch });
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, void 0), ...view.state === "uncertain" ? { state: "dispatching" } : {} }, event);
+      return;
+    case "workspace.create-failed":
+    case "workspace.create-refused":
+      setWorkspace(state, id2, { create: event.type === "workspace.create-failed" ? "failed" : "refused" }, event);
+      setOwner(state, id2, { state: "released" });
+      update(state, id2, { state: "blocked", openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "workspace.create-uncertain":
+      setWorkspace(state, id2, { create: "uncertain" }, event);
+      setOwner(state, id2, { state: "uncertain" });
+      update(state, id2, { state: "uncertain" }, event);
+      return;
+    case "lease.reclaimed": {
+      const owner = state.ownership.get(id2);
+      const lease = owner?.lease;
+      if (owner === void 0 || lease === void 0) return;
+      const next = { ...owner, state: "reserved", lease: { ...lease, epoch: event.data.toEpoch, priorAgentIds: [...lease.priorAgentIds, event.data.priorAgentId] } };
+      delete next.agentId;
+      state.ownership.set(id2, next);
+      state.assignments.set(id2, reclaimed(view, event));
+      return;
+    }
+    case "scope.exceeded":
+      update(state, id2, { scopeExceeded: { candidateCommit: event.data.candidateCommit, paths: event.data.paths, eventId: event.id } }, event);
+      return;
+    case "workspace.close-requested":
+      setWorkspace(state, id2, { close: "requested", closeIntentId: event.data.intentId, discardUncommitted: event.data.discardUncommitted }, event);
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, event.type) }, event);
+      return;
+    case "workspace.close-succeeded":
+      setWorkspace(state, id2, { close: "succeeded", archivedAt: event.data.archivedAt, directoryRemoved: event.data.directoryRemoved }, event);
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "workspace.close-failed":
+      setWorkspace(state, id2, { close: "failed" }, event);
+      update(state, id2, { openIntents: withIntent(view, event.data.intentId, void 0) }, event);
+      return;
+    case "workspace.close-uncertain":
+      setWorkspace(state, id2, { close: "uncertain" }, event);
+      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;
@@ -2814,10 +3125,29 @@ function project(projectId, events) {
   }
   return { state, violations: [] };
 }
+function reclaimCheck(state, assignmentId) {
+  const refused = (code2, message) => ({ ok: false, code: code2, message });
+  const view = state.assignments.get(assignmentId);
+  const owner = state.ownership.get(assignmentId);
+  const lease = owner?.lease;
+  const record = state.workspaces.get(assignmentId);
+  if (view === void 0 || owner === void 0 || lease === void 0 || record === void 0) return refused("lease_missing", `Assignment ${assignmentId} holds no worktree lease.`);
+  if (owner.state === "released" || owner.state === "reserved") return refused("lease_state", "Only a held or uncertain lease is reclaimed.");
+  const prior = owner.agentId;
+  if (prior === void 0 || view.peerAgentId !== prior) return refused("lease_state", "The reclaim names a different writer than the lease holder.");
+  if (TERMINAL_STATES.includes(view.state) || view.state === "draft" || view.state === "dispatching") return refused("assignment_state", `Cannot reclaim while the assignment is ${view.state}.`);
+  if (view.closure !== "open") return refused("assignment_state", "A closing assignment is not reclaimed.");
+  if (Object.keys(view.openIntents).length > 0) return refused("effect_unresolved", "Settle every unresolved effect before a reclaim.");
+  if (record.create !== "succeeded" || record.close !== "open" || record.worktreePath === void 0) return refused("worktree_unavailable", "The lease's worktree is not open.");
+  if (view.peerProviderId === void 0) return refused("lease_state", "The assignment names no Peer provider.");
+  return { ok: true, value: { view, lease, worktreePath: record.worktreePath, prior, provider: view.peerProviderId } };
+}
 var TERMINAL_STATES;
 var init_state = __esm({
   "src/runtime-plugin/server/domain/state.ts"() {
     "use strict";
+    init_limits();
+    init_scope();
     TERMINAL_STATES = ["accepted", "rejected", "abandoned"];
   }
 });
@@ -2831,6 +3161,17 @@ var init_receipts = __esm({
 });
 
 // src/runtime-plugin/server/domain/views.ts
+function worktreeDisposition(state, record, present = () => true) {
+  if (record.create === "requested" || record.create === "uncertain" || record.close === "requested" || record.close === "uncertain") return "unresolved";
+  if (record.create === "failed") return "gone";
+  if (record.close === "succeeded") {
+    return record.directoryRemoved === false && (record.worktreePath === void 0 || present(record.worktreePath)) ? "leftover" : "gone";
+  }
+  return state.ownership.get(record.assignmentId)?.state === "released" ? "retained" : "active";
+}
+function dispositions(state, present) {
+  return new Map([...state.workspaces.values()].map((record) => [record, worktreeDisposition(state, record, present)]));
+}
 function quiescence(state) {
   const blockers = [];
   for (const view of state.assignments.values()) {
@@ -2844,13 +3185,23 @@ function quiescence(state) {
     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}` });
+    if (owner.state === "released") continue;
+    blockers.push(owner.lease === void 0 ? { kind: "ownership", id: owner.assignmentId, detail: `writer ownership is ${owner.state}` } : { kind: "lease", id: owner.assignmentId, detail: `worktree lease (epoch ${String(owner.lease.epoch)}) is ${owner.state}` });
+  }
+  for (const record of state.workspaces.values()) {
+    if (worktreeDisposition(state, record) === "unresolved") {
+      blockers.push({ kind: "worktree", id: record.workspaceId, detail: `worktree of ${record.assignmentId} is unresolved (create ${record.create}, close ${record.close})` });
+    }
   }
   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 };
 }
+function worktreesOnDisk(state, present) {
+  const values = [...dispositions(state, present).values()];
+  return { retained: values.filter((value) => value === "retained").length, leftover: values.filter((value) => value === "leftover").length };
+}
 var init_views = __esm({
   "src/runtime-plugin/server/domain/views.ts"() {
     "use strict";
@@ -2859,33 +3210,6 @@ var init_views = __esm({
   }
 });
 
-// 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;
@@ -2942,12 +3266,23 @@ var init_actions = __esm({
     SUPERVISOR_ACTION_SCHEMAS = {
       room_status: z6.strictObject({}),
       runtime_findings: z6.strictObject({}),
-      message_lead: z6.strictObject({ message: boundedString() })
+      // `project` names a project in the caller's portfolio: a runtime project id, the project key or
+      // the repository's name. Omitted, it is the caller's own working project, or its only project.
+      message_lead: z6.strictObject({ message: boundedString(), project: z6.string().min(1).max(4096).optional() }),
+      attention_feedback: z6.strictObject({ id: z6.string().regex(/^att_[A-Za-z0-9_-]{8,32}$/), verdict: z6.enum(["useful", "noise", "unknown"]) })
     };
     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) }),
+      // `worktree` asks the runtime for an isolated worktree; the default is Phase 1's shared
+      // workspace. `serialOnly` names paths that admit one writer at a time, quoted from the
+      // repository's own protocol (docs/design/runtime-coordination-phase2.md P2-D1, §5.3).
+      assignment_dispatch: z6.strictObject({
+        ...assignment,
+        peerProvider: z6.string().min(1).max(128),
+        isolation: z6.enum(["lead-workspace", "worktree"]).optional(),
+        serialOnly: boundedArray(boundedString()).optional()
+      }),
       assignment_answer: z6.strictObject({ ...assignment, answer: boundedString() }),
       assignment_rework: z6.strictObject({ ...assignment, instructions: boundedString() }),
       assignment_accept: z6.strictObject({
@@ -2961,7 +3296,10 @@ var init_actions = __esm({
       assignment_abandon: z6.strictObject({ ...assignment, reason }),
       assignment_close: z6.strictObject(assignment),
       assignment_status: z6.strictObject({ assignmentId: assignmentIdSchema.optional() }),
-      gate_run: z6.strictObject(assignment)
+      gate_run: z6.strictObject(assignment),
+      // Discarding a retained worktree's uncommitted work is Lead's explicit decision, with a reason.
+      workspace_close: z6.strictObject({ ...assignment, discardUncommitted: z6.literal(true).optional(), reason: reason.optional() }).refine((input) => input.discardUncommitted !== true || input.reason !== void 0, { message: "discardUncommitted needs a reason", path: ["reason"] }),
+      lease_reclaim: z6.strictObject({ ...assignment, reason })
     };
   }
 });
@@ -3061,10 +3399,10 @@ function readEvent(value) {
   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) };
+  const parsed2 = readerSchema.safeParse(value);
+  return parsed2.success ? { ok: true, event: parsed2.data } : { ok: false, reason: "invalid", detail: z8.prettifyError(parsed2.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 EVENT_SCHEMA, id, text2, reason2, generation2, digest2, timestamp, workspaceIdSchema, branch, epoch, scopes, 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";
@@ -3080,6 +3418,10 @@ var init_schema = __esm({
     generation2 = z8.number().int().min(1);
     digest2 = z8.string().regex(/^sha256:[0-9a-f]{64}$/);
     timestamp = z8.iso.datetime({ offset: true });
+    workspaceIdSchema = z8.string().regex(/^wks_[a-f0-9]{16}$/);
+    branch = z8.string().min(1).max(256);
+    epoch = z8.number().int().min(1);
+    scopes = z8.array(boundedString()).max(64);
     gateResultSchema = z8.strictObject({
       id,
       assignmentId: assignmentIdSchema,
@@ -3127,7 +3469,17 @@ var init_schema = __esm({
       "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 },
+      // `agentId` and `idempotencyKey` are chosen before the call, so recovery reissues the identical
+      // request (Phase 2 delta P2-D3). Optional and additive: a Phase 1 reader ignores them.
+      "agent.create-requested": {
+        intentId: id,
+        peerProviderId: id,
+        workspaceId: id,
+        parentAgentId: id,
+        label: id,
+        agentId: z8.uuid().optional(),
+        idempotencyKey: z8.string().min(1).max(512).optional()
+      },
       "agent.create-succeeded": { intentId: id, agentId: id },
       "agent.create-failed": { intentId: id, reason: reason2 },
       "agent.create-uncertain": { intentId: id, reason: reason2 },
@@ -3178,6 +3530,30 @@ var init_schema = __esm({
       },
       "gate.finished": { result: gateResultSchema },
       "gate.uncertain": { gateRunId: id, reason: reason2 },
+      // Phase 2 worktree concurrency (docs/design/runtime-coordination-phase2.md §4). A writer lease
+      // extends the assignment's ownership with its own worktree, scopes and epoch.
+      "lease.reserved": { workspaceId: workspaceIdSchema, branch, baseCommit: commitSchema, scopes, serialOnly: scopes, epoch: z8.literal(1) },
+      "workspace.create-requested": {
+        intentId: id,
+        workspaceId: workspaceIdSchema,
+        idempotencyKey: z8.string().min(1).max(512),
+        baseCommit: commitSchema,
+        branchName: branch,
+        worktreeSlug: z8.string().min(1).max(128)
+      },
+      // Written only after the Git proof (P2-D4); `branch` is the name Paseo resolved.
+      "workspace.create-succeeded": { intentId: id, workspaceId: workspaceIdSchema, worktreePath: z8.string().min(1).max(4096), branch, headCommit: commitSchema },
+      "workspace.create-failed": { intentId: id, reason: reason2 },
+      "workspace.create-uncertain": { intentId: id, reason: reason2 },
+      // Created but failed its proof: no Peer is ever placed there, and a close follows.
+      "workspace.create-refused": { intentId: id, workspaceId: workspaceIdSchema, reason: reason2 },
+      "lease.reclaimed": { fromEpoch: epoch, toEpoch: epoch, priorAgentId: id, decidedBy: z8.enum(["lead", "human"]), reason: reason2 },
+      // Handoff evidence, not containment (§5.4).
+      "scope.exceeded": { candidateCommit: commitSchema, paths: z8.array(z8.string().min(1)).min(1) },
+      "workspace.close-requested": { intentId: id, workspaceId: workspaceIdSchema, discardUncommitted: z8.boolean(), reason: reason2.optional() },
+      "workspace.close-succeeded": { intentId: id, workspaceId: workspaceIdSchema, archivedAt: timestamp, directoryRemoved: z8.boolean() },
+      "workspace.close-failed": { intentId: id, workspaceId: workspaceIdSchema, reason: reason2 },
+      "workspace.close-uncertain": { intentId: id, workspaceId: workspaceIdSchema, reason: reason2 },
       // Deterministic notices (D9). Delivery is at least once with a stable id.
       "notice.pending": {
         noticeId: id,
@@ -3540,6 +3916,7 @@ var init_project = __esm({
 });
 
 // src/runtime-state.ts
+import { existsSync } from "fs";
 import { readdir as readdir5 } from "fs/promises";
 import { join as join15 } from "path";
 async function inspectRuntimeState(roomHome) {
@@ -3547,6 +3924,8 @@ async function inspectRuntimeState(roomHome) {
   const names = await readdir5(join15(root, "projects")).catch(() => []);
   const blockers = [];
   const stores = [];
+  let retained = 0;
+  let leftover = 0;
   for (const name of names.sort()) {
     try {
       stores.push(await ProjectStore.open(join15(root, "projects", name)));
@@ -3562,8 +3941,11 @@ async function inspectRuntimeState(roomHome) {
       continue;
     }
     for (const blocker of quiescence(projection.state).blockers) blockers.push({ ...blocker, project: store.meta.canonicalRoot });
+    const onDisk = worktreesOnDisk(projection.state, existsSync);
+    retained += onDisk.retained;
+    leftover += onDisk.leftover;
   }
-  return { root, projects: names.length, blockers };
+  return { root, projects: names.length, blockers, retainedWorktrees: retained, leftoverDirectories: leftover };
 }
 function describeBlockers(summary, limit = 5) {
   const shown = summary.blockers.slice(0, limit).map((blocker) => `${blocker.project}: ${blocker.kind} ${blocker.id} ${blocker.detail}`);
@@ -3931,17 +4313,27 @@ async function runtimeDeselectionCheck(layout) {
   }
   return [warn(
     "runtime.state-retained",
-    `Runtime coordination is quiet; its recorded state for ${String(summary.projects)} project(s) stays at ${summary.root}.`,
+    `Runtime coordination is quiet; its recorded state for ${String(summary.projects)} project(s) stays at ${summary.root}.${worktreeNote(summary, "gone")}`,
     "Export it with: paseo-room export --out <dir>, or keep it for a later --runtime."
   )];
 }
+function worktreeNote(summary, panel) {
+  const parts = [];
+  if (summary.retainedWorktrees > 0) {
+    parts.push(` ${String(summary.retainedWorktrees)} runtime worktree(s) remain open in Paseo; the CLI does not close them \u2014 ${panel === "available" ? "close them from the runtime panel first" : "archive them in Paseo, or re-enable --runtime and close them from the runtime panel"}.`);
+  }
+  if (summary.leftoverDirectories > 0) {
+    parts.push(` ${String(summary.leftoverDirectories)} closed worktree director(ies) were left on disk by a failed teardown; remove them by hand once nothing in them is needed.`);
+  }
+  return parts.join("");
+}
 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}`,
+    `Deleting ${layout.roomHome} also deletes runtime coordination history for ${String(summary.projects)} project(s).${active}${worktreeNote(summary, "available")}`,
     "Export it first with: paseo-room export --out <dir>"
   )];
 }