@seanyao/roll 4.710.2 → 4.710.3

package/dist/roll.mjs

@@ -8928,6 +8928,32 @@ var init_activity_signal = __esm({
   }
 });
 
+// packages/core/dist/loop/adversarial.js
+function adversarialNextStep(state, lastRound, cfg) {
+  if (cfg.elapsedSec >= cfg.totalTimeoutSec) {
+    return { kind: "stop", reason: "timeout" };
+  }
+  if (state.round >= cfg.maxRounds) {
+    return { kind: "stop", reason: "max_rounds" };
+  }
+  if (lastRound === null) {
+    return { kind: "attack" };
+  }
+  if (lastRound.newHole) {
+    return { kind: "fix" };
+  }
+  const effectiveDry = state.dryStreak + 1;
+  if (effectiveDry >= cfg.dryRoundsToStop) {
+    return { kind: "stop", reason: "dry" };
+  }
+  return { kind: "attack" };
+}
+var init_adversarial = __esm({
+  "packages/core/dist/loop/adversarial.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/loop/alert-loop.js
 function alertFileName(slug3) {
   return `ALERT-${slug3}.md`;
@@ -12977,19 +13003,40 @@ function cycleStep(state, event) {
           { kind: "resolve_route", storyId: event.storyId }
         ]
       };
-    case "route_resolved":
+    case "route_resolved": {
+      const execCtx = { ...state.ctx, agent: event.agent, model: event.model };
+      const startCmd = { kind: "emit_event", event: cycleStartEvent(execCtx) };
+      if (event.adversarial !== void 0) {
+        const plan = event.adversarial;
+        return {
+          state: {
+            ...state,
+            phase: "execute",
+            attempt: 1,
+            ctx: execCtx,
+            adversarial: {
+              plan,
+              round: 0,
+              dryStreak: 0,
+              holesFound: 0,
+              attackTests: [],
+              inFlight: "test_author",
+              implementedInitial: false
+            }
+          },
+          commands: [startCmd, { kind: "spawn_role", role: "test_author", agent: plan.testAuthor, round: 0 }]
+        };
+      }
       return {
         state: {
           ...state,
           phase: "execute",
           attempt: 1,
-          ctx: { ...state.ctx, agent: event.agent, model: event.model }
+          ctx: execCtx
         },
-        commands: [
-          { kind: "emit_event", event: cycleStartEvent({ ...state.ctx, agent: event.agent, model: event.model }) },
-          { kind: "spawn_agent", agent: event.agent, attempt: 1 }
-        ]
+        commands: [startCmd, { kind: "spawn_agent", agent: event.agent, attempt: 1 }]
       };
+    }
     case "route_pending":
       return terminate({ ...state, phase: "route" }, "pending_rig_recovery", [
         { kind: "cleanup_environment" },
@@ -13026,6 +13073,83 @@ function cycleStep(state, event) {
         commands: [{ kind: "capture_facts" }]
       };
     }
+    case "role_exited": {
+      const adv = state.adversarial;
+      if (adv === void 0) {
+        return { state, commands: [] };
+      }
+      const cid = state.ctx.cycleId;
+      const sid = state.ctx.storyId ?? "";
+      if (event.exit !== 0 || event.timedOut) {
+        return {
+          state: { ...state, phase: "reconcile", ctx: { ...state.ctx, agentExitCode: event.exit, agentTimedOut: event.timedOut } },
+          commands: [{ kind: "capture_facts" }]
+        };
+      }
+      const cfg = {
+        maxRounds: adv.plan.maxRounds,
+        dryRoundsToStop: adv.plan.dryRoundsToStop,
+        elapsedSec: event.elapsedSec ?? 0,
+        totalTimeoutSec: adv.plan.totalTimeoutSec
+      };
+      const terminatedCmd = (reason, rounds, holesFound2) => ({
+        kind: "emit_event",
+        event: { type: "adversarial:terminated", cycleId: cid, storyId: sid, reason, rounds, holesFound: holesFound2, ts: 0 }
+      });
+      if (adv.inFlight === "test_author") {
+        return {
+          state: { ...state, adversarial: { ...adv, inFlight: "implementer" } },
+          commands: [
+            { kind: "emit_event", event: { type: "adversarial:test-authored", cycleId: cid, storyId: sid, agent: adv.plan.testAuthor, ts: 0 } },
+            { kind: "spawn_role", role: "implementer", agent: adv.plan.implementer, round: adv.round }
+          ]
+        };
+      }
+      if (adv.inFlight === "implementer") {
+        const step2 = adversarialNextStep({ round: adv.round, dryStreak: adv.dryStreak }, null, cfg);
+        const cmds = [];
+        if (!adv.implementedInitial) {
+          cmds.push({
+            kind: "emit_event",
+            event: { type: "adversarial:implemented", cycleId: cid, storyId: sid, agent: adv.plan.implementer, round: adv.round, ts: 0 }
+          });
+        }
+        if (step2.kind === "stop") {
+          cmds.push(terminatedCmd(step2.reason, adv.round, adv.holesFound));
+          cmds.push({ kind: "capture_facts" });
+          return { state: { ...state, phase: "reconcile", adversarial: { ...adv, implementedInitial: true } }, commands: cmds };
+        }
+        const nextRound = adv.round + 1;
+        cmds.push({ kind: "spawn_role", role: "attacker", agent: adv.plan.testAuthor, round: nextRound });
+        return { state: { ...state, adversarial: { ...adv, round: nextRound, inFlight: "attacker", implementedInitial: true } }, commands: cmds };
+      }
+      const newHole = event.newHole === true;
+      const holesFound = newHole ? adv.holesFound + 1 : adv.holesFound;
+      const attackTests = newHole && event.attackTest !== void 0 && event.attackTest !== "" ? [...adv.attackTests, event.attackTest] : adv.attackTests;
+      const reportedDryStreak = newHole ? 0 : adv.dryStreak + 1;
+      const attackEvent = {
+        kind: "emit_event",
+        event: { type: "adversarial:attack-round", cycleId: cid, storyId: sid, agent: adv.plan.testAuthor, round: adv.round, newHole, dryStreak: reportedDryStreak, ts: 0 }
+      };
+      const step = adversarialNextStep({ round: adv.round, dryStreak: adv.dryStreak }, { newHole }, cfg);
+      if (step.kind === "fix") {
+        return {
+          state: { ...state, adversarial: { ...adv, dryStreak: 0, holesFound, attackTests, inFlight: "implementer" } },
+          commands: [attackEvent, { kind: "spawn_role", role: "implementer", agent: adv.plan.implementer, round: adv.round }]
+        };
+      }
+      if (step.kind === "attack") {
+        const nextRound = adv.round + 1;
+        return {
+          state: { ...state, adversarial: { ...adv, round: nextRound, dryStreak: reportedDryStreak, holesFound, attackTests, inFlight: "attacker" } },
+          commands: [attackEvent, { kind: "spawn_role", role: "attacker", agent: adv.plan.testAuthor, round: nextRound }]
+        };
+      }
+      return {
+        state: { ...state, phase: "reconcile", adversarial: { ...adv, dryStreak: reportedDryStreak, holesFound, attackTests } },
+        commands: [attackEvent, terminatedCmd(step.reason, adv.round, holesFound), { kind: "capture_facts" }]
+      };
+    }
     case "facts_captured": {
       const status2 = classifyCaptured(event.facts);
       const nextCtx = status2 === "agent_internal" ? {
@@ -13231,6 +13355,7 @@ var init_orchestrator = __esm({
     "use strict";
     init_tracker();
     init_builder_finalization();
+    init_adversarial();
     init_pr();
     init_gate();
     CYCLE_TIMEOUT_SEC = 2700;
@@ -13250,6 +13375,7 @@ var init_orchestrator = __esm({
       route_resolved: ["route"],
       route_pending: ["route"],
       agent_exited: ["execute"],
+      role_exited: ["execute"],
       facts_captured: ["reconcile"],
       published: ["publish"],
       merge_polled: ["merge-wait", "publish"],
@@ -18020,6 +18146,7 @@ var init_dist2 = __esm({
     init_bus();
     init_infra_default3();
     init_activity_signal();
+    init_adversarial();
     init_alert_loop();
     init_branch_canary();
     init_remote_branch_gc();
@@ -235788,9 +235915,9 @@ __export(showcase_exports, {
   showcaseCommand: () => showcaseCommand
 });
 import { spawnSync as spawnSync17 } from "node:child_process";
-import { cpSync as cpSync3, existsSync as existsSync128, mkdirSync as mkdirSync71, mkdtempSync as mkdtempSync9, readdirSync as readdirSync50, readFileSync as readFileSync129, rmSync as rmSync23, statSync as statSync40, writeFileSync as writeFileSync71 } from "node:fs";
+import { cpSync as cpSync3, existsSync as existsSync129, mkdirSync as mkdirSync71, mkdtempSync as mkdtempSync9, readdirSync as readdirSync50, readFileSync as readFileSync130, rmSync as rmSync24, statSync as statSync40, writeFileSync as writeFileSync71 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
-import { dirname as dirname70, join as join144 } from "node:path";
+import { dirname as dirname71, join as join145 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function parseArgs3(args) {
   const opts = {
@@ -235829,11 +235956,11 @@ function parseArgs3(args) {
   return opts;
 }
 function packageRoot() {
-  let dir = dirname70(fileURLToPath3(import.meta.url));
+  let dir = dirname71(fileURLToPath3(import.meta.url));
   for (let i = 0; i < 12; i++) {
-    if (existsSync128(join144(dir, "conventions")))
+    if (existsSync129(join145(dir, "conventions")))
       return dir;
-    const parent = dirname70(dir);
+    const parent = dirname71(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -235841,8 +235968,8 @@ function packageRoot() {
   return dir;
 }
 function rollBin3() {
-  const devPath = join144(packageRoot(), "packages", "cli", "bin", "roll.js");
-  if (existsSync128(devPath))
+  const devPath = join145(packageRoot(), "packages", "cli", "bin", "roll.js");
+  if (existsSync129(devPath))
     return devPath;
   return "roll";
 }
@@ -235869,30 +235996,30 @@ function runRoll(sandbox, rollHome4, args, opts = {}) {
 }
 function fileNonEmpty3(p) {
   try {
-    return existsSync128(p) && statSync40(p).size > 0;
+    return existsSync129(p) && statSync40(p).size > 0;
   } catch {
     return false;
   }
 }
 function makeSandbox(sourceProject) {
-  const root = mkdtempSync9(join144(tmpdir12(), "roll-showcase-"));
-  const sandbox = join144(root, "project");
-  const rollHome4 = join144(root, "home");
+  const root = mkdtempSync9(join145(tmpdir12(), "roll-showcase-"));
+  const sandbox = join145(root, "project");
+  const rollHome4 = join145(root, "home");
   mkdirSync71(sandbox, { recursive: true });
   mkdirSync71(rollHome4, { recursive: true });
-  const srcRoll = join144(sourceProject, ".roll");
-  if (existsSync128(srcRoll)) {
-    cpSync3(srcRoll, join144(sandbox, ".roll"), { recursive: true });
+  const srcRoll = join145(sourceProject, ".roll");
+  if (existsSync129(srcRoll)) {
+    cpSync3(srcRoll, join145(sandbox, ".roll"), { recursive: true });
   } else {
-    mkdirSync71(join144(sandbox, ".roll", "features"), { recursive: true });
+    mkdirSync71(join145(sandbox, ".roll", "features"), { recursive: true });
   }
   return { sandbox, rollHome: rollHome4 };
 }
 function findCardSpec2(sandbox, card) {
-  const featuresDir = join144(sandbox, ".roll", "features");
+  const featuresDir = join145(sandbox, ".roll", "features");
   const candidates = [];
   const walk2 = (dir, depth) => {
-    if (depth > 3 || !existsSync128(dir))
+    if (depth > 3 || !existsSync129(dir))
       return;
     let entries = [];
     try {
@@ -235901,7 +236028,7 @@ function findCardSpec2(sandbox, card) {
       return;
     }
     for (const name of entries) {
-      const full = join144(dir, name);
+      const full = join145(dir, name);
       let isDir4 = false;
       try {
         isDir4 = statSync40(full).isDirectory();
@@ -235909,8 +236036,8 @@ function findCardSpec2(sandbox, card) {
         continue;
       }
       if (isDir4) {
-        if (name === card && existsSync128(join144(full, "spec.md")))
-          candidates.push(join144(full, "spec.md"));
+        if (name === card && existsSync129(join145(full, "spec.md")))
+          candidates.push(join145(full, "spec.md"));
         walk2(full, depth + 1);
       }
     }
@@ -235922,9 +236049,9 @@ function resetSandbox(sandbox, card) {
   const notes = [];
   let reset2 = false;
   let ok12 = false;
-  const backlogPath = join144(sandbox, ".roll", "backlog.md");
-  if (existsSync128(backlogPath)) {
-    const before = readFileSync129(backlogPath, "utf8");
+  const backlogPath = join145(sandbox, ".roll", "backlog.md");
+  if (existsSync129(backlogPath)) {
+    const before = readFileSync130(backlogPath, "utf8");
     const cardRow = before.split("\n").find((line) => line.startsWith("|") && line.includes(card));
     const hadStatusToken = cardRow !== void 0 && statusMarkerRe(false).test(cardRow);
     const alreadyTodo = cardRow !== void 0 && findStatusMarker(cardRow) === STATUS_MARKER.todo;
@@ -235951,24 +236078,24 @@ function resetSandbox(sandbox, card) {
   } else {
     notes.push("backlog: .roll/backlog.md absent");
   }
-  const pulseCmd = join144(sandbox, "packages", "cli", "src", "commands", "pulse.ts");
-  if (existsSync128(pulseCmd)) {
-    rmSync23(pulseCmd, { force: true });
+  const pulseCmd = join145(sandbox, "packages", "cli", "src", "commands", "pulse.ts");
+  if (existsSync129(pulseCmd)) {
+    rmSync24(pulseCmd, { force: true });
     notes.push("removed prior pulse.ts surface");
   }
   return { ok: ok12, reset: reset2, notes };
 }
 function writeCasting(sandbox, casting) {
-  const agentsPath = join144(sandbox, ".roll", "agents.yaml");
-  mkdirSync71(dirname70(agentsPath), { recursive: true });
+  const agentsPath = join145(sandbox, ".roll", "agents.yaml");
+  mkdirSync71(dirname71(agentsPath), { recursive: true });
   writeFileSync71(agentsPath, castingAgentsYaml(casting), "utf8");
 }
 async function captureScreenshots(sandbox, card) {
   const shots = [];
   const infra = await Promise.resolve().then(() => (init_dist3(), dist_exports));
-  const shotDir = join144(sandbox, ".roll", "showcase", card, "screenshots");
+  const shotDir = join145(sandbox, ".roll", "showcase", card, "screenshots");
   mkdirSync71(shotDir, { recursive: true });
-  const cliOut = join144(shotDir, "pulse-cli.png");
+  const cliOut = join145(shotDir, "pulse-cli.png");
   const cli = await infra.captureScreenshot({
     kind: "terminal",
     out: cliOut,
@@ -235980,12 +236107,12 @@ async function captureScreenshots(sandbox, card) {
     present: cli.taken && fileNonEmpty3(cliOut),
     ...cli.skipped !== void 0 ? { skipped: cli.skipped } : {}
   });
-  const nowPage = join144(sandbox, ".roll", "features", "index.html");
-  const webOut = join144(shotDir, "now-pulse-badge.png");
+  const nowPage = join145(sandbox, ".roll", "features", "index.html");
+  const webOut = join145(shotDir, "now-pulse-badge.png");
   const web = await infra.captureScreenshot({
     kind: "web",
     out: webOut,
-    url: existsSync128(nowPage) ? `file://${nowPage}#now` : "about:blank"
+    url: existsSync129(nowPage) ? `file://${nowPage}#now` : "about:blank"
   });
   shots.push({
     surface: "web",
@@ -235996,10 +236123,10 @@ async function captureScreenshots(sandbox, card) {
   return shots;
 }
 function readBacklogStatus(sandbox, card) {
-  const backlogPath = join144(sandbox, ".roll", "backlog.md");
-  if (!existsSync128(backlogPath))
+  const backlogPath = join145(sandbox, ".roll", "backlog.md");
+  if (!existsSync129(backlogPath))
     return void 0;
-  for (const line of readFileSync129(backlogPath, "utf8").split("\n")) {
+  for (const line of readFileSync130(backlogPath, "utf8").split("\n")) {
     if (line.startsWith("|") && line.includes(card)) {
       const marker = findStatusMarker(line);
       if (marker !== void 0)
@@ -236009,11 +236136,11 @@ function readBacklogStatus(sandbox, card) {
   return void 0;
 }
 function readTruthLadder(sandbox, card) {
-  const truthPath = join144(sandbox, ".roll", "features", "truth.json");
-  if (!existsSync128(truthPath))
+  const truthPath = join145(sandbox, ".roll", "features", "truth.json");
+  if (!existsSync129(truthPath))
     return void 0;
   try {
-    const snap = JSON.parse(readFileSync129(truthPath, "utf8"));
+    const snap = JSON.parse(readFileSync130(truthPath, "utf8"));
     const row2 = (snap.stories ?? []).find((s) => s.id === card);
     return row2?.ladder;
   } catch {
@@ -236021,12 +236148,12 @@ function readTruthLadder(sandbox, card) {
   }
 }
 function readTcrCommits(sandbox) {
-  const runsPath3 = join144(sandbox, ".roll", "loop", "runs.jsonl");
-  if (!existsSync128(runsPath3))
+  const runsPath3 = join145(sandbox, ".roll", "loop", "runs.jsonl");
+  if (!existsSync129(runsPath3))
     return [];
   const out3 = [];
   try {
-    const lines3 = readFileSync129(runsPath3, "utf8").trim().split("\n").filter(Boolean);
+    const lines3 = readFileSync130(runsPath3, "utf8").trim().split("\n").filter(Boolean);
     const last = lines3[lines3.length - 1];
     if (last === void 0)
       return [];
@@ -236105,7 +236232,7 @@ ${msg6}
     const backlogStatus = readBacklogStatus(sandbox, card);
     const truthLadder = readTruthLadder(sandbox, card);
     const tcrCommits = readTcrCommits(sandbox);
-    const reportPath = join144(sandbox, ".roll", "features");
+    const reportPath = join145(sandbox, ".roll", "features");
     const gate = parseAttestGate(attest.stdout + attest.stderr);
     const run = {
       casting,
@@ -236165,7 +236292,7 @@ ROLL_HOME: ${rollHome4}
     return 1;
   } finally {
     if (!keepSandbox) {
-      rmSync23(dirname70(sandbox), { recursive: true, force: true });
+      rmSync24(dirname71(sandbox), { recursive: true, force: true });
     }
   }
 }
@@ -237380,6 +237507,20 @@ function agentCredentialReadiness(agent, env = process.env, home) {
   });
   return { agent: canonical, requiredEnv, missingEnv, ok: missingEnv.length === 0 };
 }
+function adversarialRolePrompt(role) {
+  switch (role) {
+    case "test_author":
+      return "You are the test author. Write failing red tests from the AC acceptance contract; do not write production code and do not read the implementation.";
+    case "implementer":
+      return "You are the implementer. Write only production code to make the failing tests pass; do not modify, edit, touch, or change any test files.";
+    case "attacker":
+      return "You are the attacker. Add only new breaking tests, each targeting one untested failure mode; do not edit or modify existing tests or production code.";
+    default: {
+      const exhaustive = role;
+      throw new Error(`adversarialRolePrompt: unknown role ${String(exhaustive)}`);
+    }
+  }
+}
 function agentSpawnSupportsPurpose(spawn10, purpose) {
   return spawn10.supportedPurposes?.includes(purpose) === true;
 }
@@ -254671,8 +254812,8 @@ function writeSet(runtimeDir12, set) {
   writeFileSync30(tmp, JSON.stringify([...set].sort(), null, 2), "utf8");
   writeFileSync30(path, readFileSync55(tmp, "utf8"), "utf8");
   try {
-    const { rmSync: rmSync27 } = __require("node:fs");
-    rmSync27(tmp, { force: true });
+    const { rmSync: rmSync28 } = __require("node:fs");
+    rmSync28(tmp, { force: true });
   } catch {
   }
 }
@@ -271066,8 +271207,8 @@ async function loopExhaustionSplitCommand(argv, deps = realExhaustionSplitDeps()
 init_dist2();
 init_dist();
 init_dist3();
-import { appendFileSync as appendFileSync22, existsSync as existsSync122, mkdirSync as mkdirSync67, readdirSync as readdirSync45, readFileSync as readFileSync123, writeFileSync as writeFileSync66 } from "node:fs";
-import { dirname as dirname67, join as join138 } from "node:path";
+import { appendFileSync as appendFileSync22, existsSync as existsSync123, mkdirSync as mkdirSync67, readdirSync as readdirSync45, readFileSync as readFileSync124, writeFileSync as writeFileSync66 } from "node:fs";
+import { dirname as dirname68, join as join139 } from "node:path";
 
 // packages/cli/dist/runner/executor.js
 init_dist2();
@@ -272085,6 +272226,19 @@ function recordExecutionProfile(ports, cycleId, storyId, estMin) {
   }
   return profile;
 }
+var DEFAULT_ADVERSARIAL_CFG = {
+  maxRounds: 4,
+  dryRoundsToStop: 2,
+  totalTimeoutSec: 2700
+};
+function planAdversarial(profile, implementer, activeAgents) {
+  if (profile !== "verified" && profile !== "designed")
+    return void 0;
+  const testAuthor = activeAgents.find((a) => a !== "" && a !== implementer);
+  if (testAuthor === void 0)
+    return void 0;
+  return { testAuthor, implementer, ...DEFAULT_ADVERSARIAL_CFG };
+}
 function writeEvaluatorArtifact(ports, ctx, signals) {
   const profile = ctx.selectedProfile;
   if (profile !== "verified" && profile !== "designed")
@@ -272580,7 +272734,16 @@ async function executeSetupCommand(cmd, ports, ctx) {
       const selectedAgent = active.includes(r.agent) ? r.agent : active[0] ?? r.agent;
       const selectedModel = selectedAgent === r.agent ? r.model : "";
       const selectedProfile = recordExecutionProfile(ports, ctx.cycleId ?? "", cmd.storyId, estMin);
-      return { event: { type: "route_resolved", agent: selectedAgent, model: selectedModel }, ctxPatch: { selectedProfile } };
+      const adversarial = planAdversarial(selectedProfile, selectedAgent, active);
+      return {
+        event: {
+          type: "route_resolved",
+          agent: selectedAgent,
+          model: selectedModel,
+          ...adversarial !== void 0 ? { adversarial } : {}
+        },
+        ctxPatch: { selectedProfile }
+      };
     }
     // execute: spawn the agent (TCR commits happen inside the worktree). The
     // exit code + timeout feed back as agent_exited; usage is captured for cost.
@@ -273721,32 +273884,107 @@ ${res.stderr}
   }
 }
 
+// packages/cli/dist/runner/spawn-role-handler.js
+import { existsSync as existsSync110, readFileSync as readFileSync112, rmSync as rmSync21 } from "node:fs";
+import { dirname as dirname61, join as join128 } from "node:path";
+function adversarialMarkerPath(ports, cycleId, round) {
+  return join128(dirname61(ports.paths.eventsPath), `adversarial-${cycleId || "cycle"}-round-${round}.json`);
+}
+function readAttackMarker(path) {
+  if (!existsSync110(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync112(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null)
+      return null;
+    const rec = parsed;
+    const marker = {};
+    if (typeof rec["newHole"] === "boolean")
+      marker.newHole = rec["newHole"];
+    if (typeof rec["attackTest"] === "string")
+      marker.attackTest = rec["attackTest"];
+    return marker;
+  } catch {
+    return null;
+  }
+}
+async function executeSpawnRoleCommand(cmd, ports, ctx) {
+  const markerPath2 = adversarialMarkerPath(ports, ctx.cycleId ?? "", cmd.round);
+  try {
+    rmSync21(markerPath2, { force: true });
+  } catch {
+  }
+  const startSec = ports.clock();
+  const rolePrompt = adversarialRolePrompt(cmd.role);
+  const wallSec = readCycleTimeoutThresholds(ports.repoCwd).wallSec;
+  const res = await ports.agentSpawn(cmd.agent, {
+    purpose: cmd.role,
+    cwd: ports.paths.worktreePath,
+    skillBody: `${rolePrompt}
+
+${ports.skillBody}`,
+    writableRoots: agentWritableRoots(ports.repoCwd, ports.paths.alertsPath),
+    timeoutMs: wallSec * 1e3,
+    ...ctx.model !== void 0 && ctx.model !== "" ? { model: ctx.model } : {},
+    ...ctx.storyId !== void 0 && ctx.storyId !== "" ? { storyId: ctx.storyId } : {},
+    ...ctx.evidenceRunDir !== void 0 ? { runDir: ctx.evidenceRunDir } : {},
+    env: {
+      ...process.env,
+      ROLL_LOOP_ALERT: ports.paths.alertsPath,
+      ROLL_ADVERSARIAL_MARKER: markerPath2,
+      ...worktreeGitEnv(ports.paths.worktreePath, ports.repoCwd),
+      ...agentSpawnEnvironment(cmd.agent)
+    }
+  });
+  const elapsedSec = ctx.startSec !== void 0 && ctx.startSec > 0 ? Math.max(0, ports.clock() - ctx.startSec) : Math.max(0, ports.clock() - startSec);
+  let newHole;
+  let attackTest;
+  if (cmd.role === "attacker") {
+    const marker = readAttackMarker(markerPath2);
+    newHole = marker?.newHole === true;
+    if (newHole && typeof marker?.attackTest === "string" && marker.attackTest !== "") {
+      attackTest = marker.attackTest;
+    }
+  }
+  return {
+    event: {
+      type: "role_exited",
+      role: cmd.role,
+      exit: res.exitCode,
+      timedOut: res.timedOut,
+      elapsedSec,
+      ...newHole !== void 0 ? { newHole } : {},
+      ...attackTest !== void 0 ? { attackTest } : {}
+    }
+  };
+}
+
 // packages/cli/dist/runner/capture-facts-handler.js
 init_dist2();
 init_dist();
 import { execFile as execFile15 } from "node:child_process";
-import { existsSync as existsSync114, mkdirSync as mkdirSync62, readFileSync as readFileSync116, writeFileSync as writeFileSync61 } from "node:fs";
-import { dirname as dirname63, join as join132 } from "node:path";
+import { existsSync as existsSync115, mkdirSync as mkdirSync62, readFileSync as readFileSync117, writeFileSync as writeFileSync61 } from "node:fs";
+import { dirname as dirname64, join as join133 } from "node:path";
 import { promisify as promisify15 } from "node:util";
 
 // packages/cli/dist/runner/correction-actuator.js
 init_dist2();
 init_dist();
-import { appendFileSync as appendFileSync19, existsSync as existsSync110, mkdirSync as mkdirSync59, readFileSync as readFileSync112, readdirSync as readdirSync42, writeFileSync as writeFileSync58 } from "node:fs";
-import { dirname as dirname61, join as join128 } from "node:path";
+import { appendFileSync as appendFileSync19, existsSync as existsSync111, mkdirSync as mkdirSync59, readFileSync as readFileSync113, readdirSync as readdirSync42, writeFileSync as writeFileSync58 } from "node:fs";
+import { dirname as dirname62, join as join129 } from "node:path";
 function readMode(projectPath3) {
   try {
-    const path = join128(projectPath3, ".roll", "policy.yaml");
-    if (!existsSync110(path))
+    const path = join129(projectPath3, ".roll", "policy.yaml");
+    if (!existsSync111(path))
       return "conservative";
-    return parsePolicy(readFileSync112(path, "utf8")).loopSafety.correctionActuator;
+    return parsePolicy(readFileSync113(path, "utf8")).loopSafety.correctionActuator;
   } catch {
     return "conservative";
   }
 }
 function readEvents7(eventsPath4) {
   try {
-    return readFileSync112(eventsPath4, "utf8").split("\n").map(parseEventLine).filter((ev) => ev !== null);
+    return readFileSync113(eventsPath4, "utf8").split("\n").map(parseEventLine).filter((ev) => ev !== null);
   } catch {
     return [];
   }
@@ -273776,7 +274014,7 @@ function reviewConsensus(events, cycleId) {
 }
 function appendEvent(eventsPath4, event) {
   try {
-    mkdirSync59(dirname61(eventsPath4), { recursive: true });
+    mkdirSync59(dirname62(eventsPath4), { recursive: true });
     appendFileSync19(eventsPath4, `${JSON.stringify(event)}
 `, "utf8");
   } catch {
@@ -273784,7 +274022,7 @@ function appendEvent(eventsPath4, event) {
 }
 function appendAlert2(alertsPath, msg6) {
   try {
-    mkdirSync59(dirname61(alertsPath), { recursive: true });
+    mkdirSync59(dirname62(alertsPath), { recursive: true });
     appendFileSync19(alertsPath, `${msg6}
 `, "utf8");
   } catch {
@@ -273792,7 +274030,7 @@ function appendAlert2(alertsPath, msg6) {
 }
 function markStoryTodo(projectPath3, storyId) {
   try {
-    const path = join128(projectPath3, ".roll", "backlog.md");
+    const path = join129(projectPath3, ".roll", "backlog.md");
     const store = new BacklogStore();
     const snap = store.readBacklog(path);
     const row2 = snap.items.find((it) => it.id === storyId);
@@ -273808,18 +274046,18 @@ function markStoryTodo(projectPath3, storyId) {
 }
 function storyEpic(projectPath3, storyId) {
   try {
-    const idx = JSON.parse(readFileSync112(join128(projectPath3, ".roll", "index.json"), "utf8"));
+    const idx = JSON.parse(readFileSync113(join129(projectPath3, ".roll", "index.json"), "utf8"));
     const epic = idx[storyId];
     if (typeof epic === "string" && epic.trim() !== "")
       return epic;
   } catch {
   }
   try {
-    const features = join128(projectPath3, ".roll", "features");
+    const features = join129(projectPath3, ".roll", "features");
     for (const d of readdirSync42(features, { withFileTypes: true })) {
       if (!d.isDirectory())
         continue;
-      if (existsSync110(join128(features, d.name, storyId)))
+      if (existsSync111(join129(features, d.name, storyId)))
         return d.name;
     }
   } catch {
@@ -273828,7 +274066,7 @@ function storyEpic(projectPath3, storyId) {
 }
 function existingFixId(projectPath3, storyId, signal) {
   try {
-    const snap = new BacklogStore().readBacklog(join128(projectPath3, ".roll", "backlog.md"));
+    const snap = new BacklogStore().readBacklog(join129(projectPath3, ".roll", "backlog.md"));
     return snap.items.find((it) => {
       const desc = it.desc.toLowerCase();
       if (!it.id.startsWith("FIX-"))
@@ -273850,7 +274088,7 @@ function fixDescription(storyId, signal) {
 }
 function writeFixSpec(projectPath3, epic, fixId, decision) {
   try {
-    const dir = join128(projectPath3, ".roll", "features", epic, fixId);
+    const dir = join129(projectPath3, ".roll", "features", epic, fixId);
     mkdirSync59(dir, { recursive: true });
     const body = [
       "---",
@@ -273881,7 +274119,7 @@ function writeFixSpec(projectPath3, epic, fixId, decision) {
       "- [ ] Leave the PR open for human merge approval",
       ""
     ].join("\n");
-    writeFileSync58(join128(dir, "spec.md"), body, "utf8");
+    writeFileSync58(join129(dir, "spec.md"), body, "utf8");
   } catch {
   }
 }
@@ -273889,7 +274127,7 @@ function createFix(projectPath3, decision) {
   const existing = existingFixId(projectPath3, decision.storyId, decision.signal);
   if (existing !== void 0)
     return { mutation: "existing_fix", fixId: existing };
-  const path = join128(projectPath3, ".roll", "backlog.md");
+  const path = join129(projectPath3, ".roll", "backlog.md");
   const store = new BacklogStore();
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
@@ -273914,7 +274152,7 @@ function createFix(projectPath3, decision) {
 }
 function markStoryHold(projectPath3, storyId, reason) {
   try {
-    const path = join128(projectPath3, ".roll", "backlog.md");
+    const path = join129(projectPath3, ".roll", "backlog.md");
     const store = new BacklogStore();
     const snap = store.readBacklog(path);
     const row2 = snap.items.find((it) => it.id === storyId);
@@ -273976,15 +274214,15 @@ function applyCorrectionAction(input) {
 
 // packages/cli/dist/runner/pairing-gate.js
 init_dist2();
-import { existsSync as existsSync112, mkdirSync as mkdirSync60, readFileSync as readFileSync114, writeFileSync as writeFileSync59 } from "node:fs";
+import { existsSync as existsSync113, mkdirSync as mkdirSync60, readFileSync as readFileSync115, writeFileSync as writeFileSync59 } from "node:fs";
 import { homedir as homedir29 } from "node:os";
-import { join as join130 } from "node:path";
+import { join as join131 } from "node:path";
 
 // packages/cli/dist/runner/peer-gate.js
 init_dist2();
 import { execFile as execFile13 } from "node:child_process";
-import { existsSync as existsSync111, readFileSync as readFileSync113, readdirSync as readdirSync43 } from "node:fs";
-import { join as join129 } from "node:path";
+import { existsSync as existsSync112, readFileSync as readFileSync114, readdirSync as readdirSync43 } from "node:fs";
+import { join as join130 } from "node:path";
 import { promisify as promisify13 } from "node:util";
 var execFileAsync13 = promisify13(execFile13);
 var HIGH_RISK = [/^\.github\/workflows\//, /^packages\/infra\/src\/(git|github|process)\.ts$/];
@@ -274014,8 +274252,8 @@ async function cycleChangedFiles(worktreeCwd) {
   }
 }
 function peerEvidencePresent(runtimeDir12, cycleId) {
-  const dir = join129(runtimeDir12, "peer");
-  if (!existsSync111(dir))
+  const dir = join130(runtimeDir12, "peer");
+  if (!existsSync112(dir))
     return false;
   try {
     return readdirSync43(dir).some((f) => f.startsWith(`cycle-${cycleId}.`));
@@ -274025,20 +274263,20 @@ function peerEvidencePresent(runtimeDir12, cycleId) {
 }
 function readPeerGateMode(repoCwd) {
   try {
-    const p = join129(repoCwd, ".roll", "policy.yaml");
-    if (!existsSync111(p))
+    const p = join130(repoCwd, ".roll", "policy.yaml");
+    if (!existsSync112(p))
       return "hard";
-    return parsePolicy(readFileSync113(p, "utf8")).loopSafety.peerGate === "soft" ? "soft" : "hard";
+    return parsePolicy(readFileSync114(p, "utf8")).loopSafety.peerGate === "soft" ? "soft" : "hard";
   } catch {
     return "hard";
   }
 }
 function readPeerOnPoolTimeout(repoCwd) {
   try {
-    const p = join129(repoCwd, ".roll", "policy.yaml");
-    if (!existsSync111(p))
+    const p = join130(repoCwd, ".roll", "policy.yaml");
+    if (!existsSync112(p))
       return "block";
-    return parsePolicy(readFileSync113(p, "utf8")).loopSafety.peerOnPoolTimeout === "degrade" ? "degrade" : "block";
+    return parsePolicy(readFileSync114(p, "utf8")).loopSafety.peerOnPoolTimeout === "degrade" ? "degrade" : "block";
   } catch {
     return "block";
   }
@@ -274080,9 +274318,9 @@ async function runPeerGate(worktreeCwd, runtimeDir12, cycleId, mode, sinks, opts
 
 // packages/cli/dist/runner/pairing-gate.js
 function readScopedAgentLayer2(path) {
-  if (!existsSync112(path))
+  if (!existsSync113(path))
     return null;
-  const text2 = readFileSync114(path, "utf8");
+  const text2 = readFileSync115(path, "utf8");
   if (!text2.includes("roll-agents/v1"))
     return null;
   const parsed = normalizeAgentScopeConfig(text2);
@@ -274092,10 +274330,10 @@ function readScopedAgentLayer2(path) {
   return { config: parsed.config, path };
 }
 function loadScopedPairingConfig(projectDir, installed) {
-  const rollHome4 = process.env["ROLL_HOME"] ?? join130(homedir29(), ".roll");
+  const rollHome4 = process.env["ROLL_HOME"] ?? join131(homedir29(), ".roll");
   const layers = [
-    readScopedAgentLayer2(join130(rollHome4, "agents.yaml")),
-    readScopedAgentLayer2(join130(projectDir, ".roll", "agents.yaml"))
+    readScopedAgentLayer2(join131(rollHome4, "agents.yaml")),
+    readScopedAgentLayer2(join131(projectDir, ".roll", "agents.yaml"))
   ].filter((layer) => layer !== null);
   if (layers.length === 0)
     return null;
@@ -274127,9 +274365,9 @@ function loadPairingConfig(projectDir, installed, fallback) {
   const scoped = loadScopedPairingConfig(projectDir, installed);
   if (scoped !== null)
     return scoped;
-  const cfgPath = join130(projectDir, ".roll", "pairing.yaml");
-  if (existsSync112(cfgPath))
-    return { cfg: parsePairingConfig(readFileSync114(cfgPath, "utf8")), source: "legacy-pairing" };
+  const cfgPath = join131(projectDir, ".roll", "pairing.yaml");
+  if (existsSync113(cfgPath))
+    return { cfg: parsePairingConfig(readFileSync115(cfgPath, "utf8")), source: "legacy-pairing" };
   return fallback === void 0 ? null : { cfg: fallback, source: "default-score" };
 }
 function enabledPairingStages(projectDir) {
@@ -274146,9 +274384,9 @@ function enabledPairingStages(projectDir) {
   }
 }
 function evidencePath(runtimeDir12, cycleId, stage) {
-  const dir = join130(runtimeDir12, "peer");
+  const dir = join131(runtimeDir12, "peer");
   const name = stage === "code" ? `cycle-${cycleId}.pair.json` : `cycle-${cycleId}.${stage}.pair.json`;
-  return join130(dir, name);
+  return join131(dir, name);
 }
 var REVIEW_TIMEOUT_BASE_MS = 18e4;
 var REVIEW_TIMEOUT_LARGE_MS = 3e5;
@@ -274335,7 +274573,7 @@ async function runPairing(projectDir, worktreeCwd, runtimeDir12, cycleId, workin
     }
     const { peer, review } = dispatched;
     const path = evidencePath(runtimeDir12, cycleId, stage);
-    mkdirSync60(join130(runtimeDir12, "peer"), { recursive: true });
+    mkdirSync60(join131(runtimeDir12, "peer"), { recursive: true });
     writeFileSync59(path, JSON.stringify({ cycleId, workingAgent, peer, stage, ...review }, null, 2), "utf8");
     deps.event({ type: "pair:verdict", cycleId, peer, verdict: review.verdict, findings: review.findings.length, cost: review.cost, stage, ts: deps.now() });
     return { status: "reviewed", peer, verdict: review.verdict };
@@ -274466,7 +274704,7 @@ async function runScorePairing(projectDir, runtimeDir12, cycleId, workingAgent,
     });
     try {
       const path = evidencePath(runtimeDir12, cycleId, scoreStage);
-      mkdirSync60(join130(runtimeDir12, "peer"), { recursive: true });
+      mkdirSync60(join131(runtimeDir12, "peer"), { recursive: true });
       writeFileSync59(path, JSON.stringify({ cycleId, workingAgent, peer, stage: scoreStage, score: scored.score, verdict: scored.verdict, rationale: scored.rationale, cost: scored.cost, sessionId: sessionId2 }, null, 2), "utf8");
       deps.event({ type: "pair:score", cycleId, peer, score: scored.score, verdict: scored.verdict, cost: scored.cost, stage: scoreStage, ts: deps.now() });
     } catch {
@@ -274605,7 +274843,7 @@ async function retryPeerConsult(worktreeCwd, runtimeDir12, cycleId, deps) {
     }
     const { peer, sameTypeFallback, review } = dispatched;
     const path = evidencePath(runtimeDir12, cycleId, "code");
-    mkdirSync60(join130(runtimeDir12, "peer"), { recursive: true });
+    mkdirSync60(join131(runtimeDir12, "peer"), { recursive: true });
     writeFileSync59(path, JSON.stringify({ cycleId, workingAgent: working, peer, stage: "code", sameTypeFallback, ...review }, null, 2), "utf8");
     deps.event({ type: "pair:verdict", cycleId, peer, verdict: review.verdict, findings: review.findings.length, cost: review.cost, stage: "code", ts: deps.now() });
     return { status: "reviewed", peer, sameTypeFallback };
@@ -274636,8 +274874,8 @@ DIFF:
 init_dist2();
 init_dist();
 import { execFile as execFile14 } from "node:child_process";
-import { existsSync as existsSync113, mkdirSync as mkdirSync61, readFileSync as readFileSync115, writeFileSync as writeFileSync60 } from "node:fs";
-import { dirname as dirname62, join as join131 } from "node:path";
+import { existsSync as existsSync114, mkdirSync as mkdirSync61, readFileSync as readFileSync116, writeFileSync as writeFileSync60 } from "node:fs";
+import { dirname as dirname63, join as join132 } from "node:path";
 import { promisify as promisify14 } from "node:util";
 var execFileAsync14 = promisify14(execFile14);
 function createCapturePeerHelpers(params) {
@@ -274671,9 +274909,9 @@ function createCapturePeerHelpers(params) {
     const key = `${peer}:${stage}`;
     const attempt = (rawArtifactAttempts.get(key) ?? 0) + 1;
     rawArtifactAttempts.set(key, attempt);
-    const peerDir2 = join131(dirname62(ports.paths.eventsPath), "cycle-logs", ctx.cycleId ?? "cycle", "peer");
+    const peerDir2 = join132(dirname63(ports.paths.eventsPath), "cycle-logs", ctx.cycleId ?? "cycle", "peer");
     mkdirSync61(peerDir2, { recursive: true });
-    const artifactPath2 = join131(peerDir2, `${peer}.${stage}.attempt-${attempt}.raw.txt`);
+    const artifactPath2 = join132(peerDir2, `${peer}.${stage}.attempt-${attempt}.raw.txt`);
     writeFileSync60(artifactPath2, `--- stdout ---
 ${stdout}
 --- stderr ---
@@ -274683,9 +274921,9 @@ ${stderr}
   };
   const computeAuthDiagnostics = () => {
     try {
-      if (!existsSync113(ports.paths.eventsPath))
+      if (!existsSync114(ports.paths.eventsPath))
         return excludedPeers([]);
-      const events = readFileSync115(ports.paths.eventsPath, "utf8").split("\n").map(parseEventLine).filter((e) => e !== null);
+      const events = readFileSync116(ports.paths.eventsPath, "utf8").split("\n").map(parseEventLine).filter((e) => e !== null);
       const cooldown = authCooldownExclusions(events);
       for (const [peer, failures] of cooldown) {
         ports.events.appendEvent(ports.paths.eventsPath, {
@@ -274821,7 +275059,7 @@ async function executeCaptureFactsCommand(cmd, ports, ctx) {
     tcrCount
   });
   const peerGateMode = readPeerGateMode(ports.repoCwd);
-  const runtimeDir12 = dirname63(ports.paths.eventsPath);
+  const runtimeDir12 = dirname64(ports.paths.eventsPath);
   const cycleIdStr = ctx.cycleId ?? "";
   const peerGateAllowedAgents = projectAllowedAgents(ports.repoCwd);
   const peerGateInstalled = ports.installedAgents?.() ?? agentsInstalled(realAgentEnv());
@@ -274841,8 +275079,8 @@ async function executeCaptureFactsCommand(cmd, ports, ctx) {
   {
     let pairHistory;
     try {
-      if (existsSync114(ports.paths.eventsPath)) {
-        const events = readFileSync116(ports.paths.eventsPath, "utf8").split("\n").map(parseEventLine).filter((e) => e !== null);
+      if (existsSync115(ports.paths.eventsPath)) {
+        const events = readFileSync117(ports.paths.eventsPath, "utf8").split("\n").map(parseEventLine).filter((e) => e !== null);
         pairHistory = pairingHistory(events);
       }
     } catch {
@@ -274862,7 +275100,7 @@ async function executeCaptureFactsCommand(cmd, ports, ctx) {
       allowedAgents: peerGateAllowedAgents
     };
     for (const stage of enabledPairingStages(ports.repoCwd)) {
-      await runPairing(ports.repoCwd, ports.paths.worktreePath, dirname63(ports.paths.eventsPath), ctx.cycleId ?? "", ctx.agent ?? "", stage, pairingDeps);
+      await runPairing(ports.repoCwd, ports.paths.worktreePath, dirname64(ports.paths.eventsPath), ctx.cycleId ?? "", ctx.agent ?? "", stage, pairingDeps);
     }
   }
   let peerGate = await runPeerGate(ports.paths.worktreePath, runtimeDir12, cycleIdStr, peerGateMode, peerGateSinks, peerGateOpts);
@@ -274885,9 +275123,9 @@ async function executeCaptureFactsCommand(cmd, ports, ctx) {
     }
     if (peerBlocked && retry.status === "timeout" && readPeerOnPoolTimeout(ports.repoCwd) === "degrade") {
       const how = retry.sameTypeFallback === true ? "same-type separate-session review" : "peer review";
-      const unavailableDir = join132(runtimeDir12, "peer-unavailable");
+      const unavailableDir = join133(runtimeDir12, "peer-unavailable");
       mkdirSync62(unavailableDir, { recursive: true });
-      writeFileSync61(join132(unavailableDir, `cycle-${cycleIdStr}.json`), JSON.stringify({
+      writeFileSync61(join133(unavailableDir, `cycle-${cycleIdStr}.json`), JSON.stringify({
         cycleId: cycleIdStr,
         status: retry.status,
         how,
@@ -275000,9 +275238,9 @@ ${res.stderr}`;
     let goalLine = "";
     let evalContractFormatted = "";
     try {
-      const specPath = join132(cardArchiveDir(ports.repoCwd, storyId), "spec.md");
-      if (existsSync114(specPath)) {
-        const specText = readFileSync116(specPath, "utf8");
+      const specPath = join133(cardArchiveDir(ports.repoCwd, storyId), "spec.md");
+      if (existsSync115(specPath)) {
+        const specText = readFileSync117(specPath, "utf8");
         const title = (/^title:\s*(.+)$/m.exec(specText)?.[1] ?? "").trim();
         if (title !== "")
           goalLine = `Goal: ${title}
@@ -275016,7 +275254,7 @@ ${goalLine}Delivery: peer-reviewed cycle, scoring stage
 Diff stat:
 ${diffStat}`;
     const skill = storyId.startsWith("FIX-") || storyId.startsWith("BUG-") ? "roll-fix" : "roll-build";
-    const scoreResult = await runScorePairing(ports.repoCwd, dirname63(ports.paths.eventsPath), ctx.cycleId ?? "", ctx.agent ?? "", storyId, skill, summary, {
+    const scoreResult = await runScorePairing(ports.repoCwd, dirname64(ports.paths.eventsPath), ctx.cycleId ?? "", ctx.agent ?? "", storyId, skill, summary, {
       installed: ports.installedAgents?.() ?? agentsInstalled(realAgentEnv()),
       // Historical auth streaks do not shrink the fair candidate pool.
       isAvailable: peerAvailable,
@@ -275181,25 +275419,25 @@ init_dist2();
 init_dist();
 init_dist3();
 import { execFileSync as execFileSync30 } from "node:child_process";
-import { existsSync as existsSync117, lstatSync as lstatSync10, realpathSync as realpathSync17, unlinkSync as unlinkSync5 } from "node:fs";
-import { dirname as dirname64, join as join134 } from "node:path";
+import { existsSync as existsSync118, lstatSync as lstatSync10, realpathSync as realpathSync17, unlinkSync as unlinkSync5 } from "node:fs";
+import { dirname as dirname65, join as join135 } from "node:path";
 
 // packages/cli/dist/runner/cycle-role-artifact-writer.js
 init_dist();
 init_dist2();
-import { existsSync as existsSync115, readFileSync as readFileSync117, mkdirSync as mkdirSync63, writeFileSync as writeFileSync62 } from "node:fs";
+import { existsSync as existsSync116, readFileSync as readFileSync118, mkdirSync as mkdirSync63, writeFileSync as writeFileSync62 } from "node:fs";
 function writeCycleRoleSummaryBestEffort(cycleId, eventsPath4, cycleLogDir) {
   try {
     if (!cycleId)
       return;
     let raw;
     try {
-      raw = readFileSync117(eventsPath4, "utf-8");
+      raw = readFileSync118(eventsPath4, "utf-8");
     } catch {
       return;
     }
     const outDir = `${cycleLogDir}/${cycleId}`;
-    if (!existsSync115(outDir)) {
+    if (!existsSync116(outDir)) {
       mkdirSync63(outDir, { recursive: true });
     }
     const lines3 = raw.split("\n").filter((l) => l.trim() !== "");
@@ -275224,8 +275462,8 @@ function writeCycleRoleSummaryBestEffort(cycleId, eventsPath4, cycleLogDir) {
 }
 
 // packages/cli/dist/runner/environment-cleanup.js
-import { existsSync as existsSync116, lstatSync as lstatSync9, mkdirSync as mkdirSync64, readFileSync as readFileSync118, readdirSync as readdirSync44, renameSync as renameSync24, rmSync as rmSync21 } from "node:fs";
-import { basename as basename19, join as join133, relative as relative11 } from "node:path";
+import { existsSync as existsSync117, lstatSync as lstatSync9, mkdirSync as mkdirSync64, readFileSync as readFileSync119, readdirSync as readdirSync44, renameSync as renameSync24, rmSync as rmSync22 } from "node:fs";
+import { basename as basename19, join as join134, relative as relative11 } from "node:path";
 var CLEANUP_TIMEOUT_MS = 1e4;
 var HEAVY_CLEANUP_TERMINALS = ["idle", "done", "published", "orphan"];
 var DEFAULT_CLEANUP_MANIFEST = {
@@ -275259,7 +275497,7 @@ var DEFAULT_CLEANUP_MANIFEST = {
 function readCleanupManifest(manifestPath2) {
   let text2;
   try {
-    text2 = readFileSync118(manifestPath2, "utf8");
+    text2 = readFileSync119(manifestPath2, "utf8");
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT")
@@ -275461,14 +275699,14 @@ function cleanupTimeoutResult(maxDurationMs) {
 }
 function resolvePattern(worktreePath, pattern, deadline, now2) {
   if (!pattern.includes("**")) {
-    const abs = join133(worktreePath, pattern);
+    const abs = join134(worktreePath, pattern);
     return [abs];
   }
   const recursiveIdx = pattern.indexOf("**");
   const prefix = pattern.slice(0, recursiveIdx);
   const rest = pattern.slice(recursiveIdx + 2);
-  const base = join133(worktreePath, prefix);
-  if (!existsSync116(base))
+  const base = join134(worktreePath, prefix);
+  if (!existsSync117(base))
     return [];
   const suffix = rest?.replace(/^\//, "") ?? "";
   const matches = [];
@@ -275487,7 +275725,7 @@ function walkRecursive(dir, worktreePath, suffix, out3, deadline, now2) {
   for (const entry of entries) {
     if (now2() >= deadline)
       return;
-    const abs = join133(dir, entry);
+    const abs = join134(dir, entry);
     const rel = relative11(worktreePath, abs);
     if (suffix && rel.endsWith(suffix)) {
       out3.push(abs);
@@ -275506,16 +275744,16 @@ function applyRule(worktreePath, cycleId, rule, absPath) {
     return { rule: rule.name, path: absPath, ok: false, warning: "target outside worktree refused" };
   }
   try {
-    if (!existsSync116(absPath)) {
+    if (!existsSync117(absPath)) {
       return { rule: rule.name, path: rel, ok: true };
     }
   } catch {
     return { rule: rule.name, path: rel, ok: false, warning: "cannot stat target" };
   }
   if (rule.kind === "isolate") {
-    const isolateRoot = join133(worktreePath, ".roll-cleanup", cycleId, rule.name);
+    const isolateRoot = join134(worktreePath, ".roll-cleanup", cycleId, rule.name);
     const base = basename19(absPath);
-    const dest = join133(isolateRoot, base);
+    const dest = join134(isolateRoot, base);
     try {
       mkdirSync64(isolateRoot, { recursive: true });
       renameSync24(absPath, dest);
@@ -275525,7 +275763,7 @@ function applyRule(worktreePath, cycleId, rule, absPath) {
     }
   }
   try {
-    rmSync21(absPath, { recursive: true, force: true });
+    rmSync22(absPath, { recursive: true, force: true });
     return { rule: rule.name, path: rel, ok: true };
   } catch (err16) {
     return { rule: rule.name, path: rel, ok: false, warning: `rm failed: ${err16}` };
@@ -275582,7 +275820,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
         }
       }
       if (r.degraded === true && r.status === 0 && ctx.storyId !== void 0 && ctx.cycleId !== void 0) {
-        const runtimeDir12 = dirname64(ports.paths.eventsPath);
+        const runtimeDir12 = dirname65(ports.paths.eventsPath);
         addPendingPrCreate(runtimeDir12, {
           storyId: ctx.storyId,
           cycleId: ctx.cycleId,
@@ -275680,7 +275918,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
         }
       } catch {
       }
-      const manifestPath2 = join134(ports.repoCwd, ".roll", "loop", "cleanup-manifest.yaml");
+      const manifestPath2 = join135(ports.repoCwd, ".roll", "loop", "cleanup-manifest.yaml");
       const manifest = resolveCleanupManifest(ports.paths.worktreePath, manifestPath2);
       const results = applyCleanupManifest(ports.paths.worktreePath, ctx.cycleId, manifest, {
         terminalStatus: cmd.terminalStatus,
@@ -275700,7 +275938,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
     // pure worktree teardown again.
     case "cleanup_worktree":
       try {
-        const dst = join134(ports.paths.worktreePath, ".roll");
+        const dst = join135(ports.paths.worktreePath, ".roll");
         if (lstatSync10(dst, { throwIfNoEntry: false })?.isSymbolicLink() === true)
           unlinkSync5(dst);
       } catch {
@@ -275725,7 +275963,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
         });
         ports.events.appendAlert(ports.paths.alertsPath, `FIX-1210: cycle ${cmd.cycleId} \u2014 core.worktree was pointing to "${repair.detail}" \u2014 auto-unset at terminal`);
       }
-      const metaRepair = repairCoreWorktreeContamination(join134(ports.repoCwd, ".roll"));
+      const metaRepair = repairCoreWorktreeContamination(join135(ports.repoCwd, ".roll"));
       if (metaRepair.healed) {
         ports.events.appendEvent(ports.paths.eventsPath, {
           type: "cycle:cleanup",
@@ -275754,7 +275992,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
       const terminalStoryId = ctx.storyId ?? "";
       if (terminalStoryId !== "") {
         try {
-          removeLease(join134(dirname64(ports.paths.eventsPath), "story-leases.json"), terminalStoryId, "cycle");
+          removeLease(join135(dirname65(ports.paths.eventsPath), "story-leases.json"), terminalStoryId, "cycle");
         } catch {
         }
       }
@@ -275854,7 +276092,7 @@ async function executeTerminalCommand(cmd, ports, ctx) {
         await commitInRepoBacklog(ports, ctx, terminalStoryId, terminalMerged);
       }
       if (ctx.cycleId !== void 0) {
-        const cycleLogDir = join134(dirname64(ports.paths.eventsPath), "cycle-logs");
+        const cycleLogDir = join135(dirname65(ports.paths.eventsPath), "cycle-logs");
         writeCycleRoleSummaryBestEffort(ctx.cycleId, ports.paths.eventsPath, cycleLogDir);
       }
       return {};
@@ -275875,8 +276113,8 @@ async function executeTerminalCommand(cmd, ports, ctx) {
 }
 function isInRepoRollLayout(worktreePath) {
   try {
-    const rollDir = join134(worktreePath, ".roll");
-    if (!existsSync117(rollDir))
+    const rollDir = join135(worktreePath, ".roll");
+    if (!existsSync118(rollDir))
       return false;
     const top = execFileSync30("git", ["-C", rollDir, "rev-parse", "--show-toplevel"], {
       encoding: "utf8",
@@ -275893,9 +276131,9 @@ function isInRepoRollLayout(worktreePath) {
 }
 async function commitInRepoBacklog(ports, ctx, storyId, terminalMerged) {
   const msg6 = `chore: ${storyId} status update (cycle ${ctx.cycleId})`;
-  const backlogRel = join134(".roll", "backlog.md");
+  const backlogRel = join135(".roll", "backlog.md");
   try {
-    if (!existsSync117(join134(ports.repoCwd, backlogRel)))
+    if (!existsSync118(join135(ports.repoCwd, backlogRel)))
       return;
     execFileSync30("git", ["add", "--", backlogRel], { cwd: ports.repoCwd, stdio: "ignore" });
     const dirty = execFileSync30("git", ["status", "--porcelain", "--", backlogRel], {
@@ -275918,13 +276156,13 @@ async function commitInRepoBacklog(ports, ctx, storyId, terminalMerged) {
 init_dist2();
 init_dist3();
 import { execFile as execFile16 } from "node:child_process";
-import { appendFileSync as appendFileSync20, existsSync as existsSync119, mkdirSync as mkdirSync65, readFileSync as readFileSync120, statSync as statSync38, writeFileSync as writeFileSync64 } from "node:fs";
-import { dirname as dirname65, join as join136 } from "node:path";
+import { appendFileSync as appendFileSync20, existsSync as existsSync120, mkdirSync as mkdirSync65, readFileSync as readFileSync121, statSync as statSync38, writeFileSync as writeFileSync64 } from "node:fs";
+import { dirname as dirname66, join as join137 } from "node:path";
 import { promisify as promisify16 } from "node:util";
 
 // packages/cli/dist/runner/selfheal-budget.js
-import { existsSync as existsSync118, readFileSync as readFileSync119, writeFileSync as writeFileSync63 } from "node:fs";
-import { join as join135 } from "node:path";
+import { existsSync as existsSync119, readFileSync as readFileSync120, writeFileSync as writeFileSync63 } from "node:fs";
+import { join as join136 } from "node:path";
 var SELFHEAL_AGENT_BUDGET = 2;
 function selfHealBudget(env = process.env) {
   const raw = (env["ROLL_LOOP_AGENT_RETRY_MAX"] ?? "").trim();
@@ -275938,14 +276176,14 @@ function autoRecoverEnabled(env = process.env) {
 }
 var EMPTY = { attempts: 0, triedAgents: [], lastReason: "" };
 function stateFile2(runtimeDir12) {
-  return join135(runtimeDir12, "selfheal-cards.json");
+  return join136(runtimeDir12, "selfheal-cards.json");
 }
 function read2(runtimeDir12) {
   try {
     const p = stateFile2(runtimeDir12);
-    if (!existsSync118(p))
+    if (!existsSync119(p))
       return { stories: {} };
-    const o = JSON.parse(readFileSync119(p, "utf8"));
+    const o = JSON.parse(readFileSync120(p, "utf8"));
     return { stories: o.stories !== void 0 && typeof o.stories === "object" ? o.stories : {} };
   } catch {
     return { stories: {} };
@@ -276024,13 +276262,13 @@ function nodePorts(opts) {
     },
     readText(absPath) {
       try {
-        return readFileSync120(absPath, "utf8");
+        return readFileSync121(absPath, "utf8");
       } catch {
         return "";
       }
     },
     writeText(absPath, text2) {
-      mkdirSync65(dirname65(absPath), { recursive: true });
+      mkdirSync65(dirname66(absPath), { recursive: true });
       writeFileSync64(absPath, text2, "utf8");
     }
   };
@@ -276065,7 +276303,7 @@ function nodePorts(opts) {
     mergedDelivery,
     // FIX-1018: skip stories that already have locally-committed-but-unpublished
     // work from a prior cycle. The executor reads the runtime file at pick time.
-    pendingPublish: (storyId) => readPendingPublish(dirname65(opts.paths.eventsPath)).has(storyId),
+    pendingPublish: (storyId) => readPendingPublish(dirname66(opts.paths.eventsPath)).has(storyId),
     pendingMergeDelivery: (storyId) => {
       const truth = deliveryTruth().get(storyId);
       if (truth === void 0)
@@ -276213,10 +276451,10 @@ function nodePorts(opts) {
     },
     backlog: {
       read(projectCwd) {
-        const p = join136(projectCwd, ".roll", "backlog.md");
-        if (!existsSync119(p))
+        const p = join137(projectCwd, ".roll", "backlog.md");
+        if (!existsSync120(p))
           return [];
-        return parseBacklog(readFileSync120(p, "utf8"));
+        return parseBacklog(readFileSync121(p, "utf8"));
       },
       // FIX-198: the production binding was MISSING entirely (the optional
       // chain made every In-Progress claim a silent no-op). ID-anchored mark
@@ -276224,8 +276462,8 @@ function nodePorts(opts) {
       // never kill the cycle, the reconcile pass is the safety net.
       markStatus(projectCwd, id, status2) {
         try {
-          const p = join136(projectCwd, ".roll", "backlog.md");
-          if (!existsSync119(p))
+          const p = join137(projectCwd, ".roll", "backlog.md");
+          if (!existsSync120(p))
             return;
           const store = new BacklogStore();
           const snap = store.readBacklog(p);
@@ -276248,7 +276486,7 @@ function nodePorts(opts) {
           return scoped;
         const tier = classifyComplexity(estMin);
         const routeDeps = opts.routeDeps;
-        const rt = (process.env["ROLL_PROJECT_RUNTIME_DIR"] ?? "").trim() || join136(opts.repoCwd, ".roll", "loop");
+        const rt = (process.env["ROLL_PROJECT_RUNTIME_DIR"] ?? "").trim() || join137(opts.repoCwd, ".roll", "loop");
         const tried = storyId !== "" ? readSelfHeal(rt, storyId).triedAgents : [];
         const dec = tried.length > 0 ? resolveRouteExcluding(tier, routeDeps, tried) ?? resolveRoute(tier, routeDeps) : resolveRoute(tier, routeDeps);
         return { agent: dec.agent, model: dec.model ?? "" };
@@ -276256,7 +276494,7 @@ function nodePorts(opts) {
     } : { resolve: () => ({ agent: "claude", model: "" }) },
     evidence: {
       openFrame(projectCwd, storyId, runId) {
-        return openEvidenceFrame({ runDir: join136(cardArchiveDir(projectCwd, storyId), runId) }).runDir;
+        return openEvidenceFrame({ runDir: join137(cardArchiveDir(projectCwd, storyId), runId) }).runDir;
       }
     },
     capture: {
@@ -276290,7 +276528,7 @@ function nodePorts(opts) {
   };
 }
 function appendAlertLine(alertsPath, message) {
-  mkdirSync65(dirname65(alertsPath), { recursive: true });
+  mkdirSync65(dirname66(alertsPath), { recursive: true });
   appendFileSync20(alertsPath, `${message}
 `, "utf8");
 }
@@ -276312,6 +276550,9 @@ async function executeCommand(cmd, ports, ctx) {
       return executeSetupCommand(cmd, ports, ctx);
     case "spawn_agent":
       return executeSpawnAgentCommand(cmd, ports, ctx);
+    // US-LOOP-102: adversarial role spawn (test_author/implementer/attacker).
+    case "spawn_role":
+      return executeSpawnRoleCommand(cmd, ports, ctx);
     // layer). No feedback event (the orchestrator already transitioned).
     case "kill_agent":
       return {};
@@ -276356,13 +276597,13 @@ init_dist2();
 init_dist2();
 
 // packages/cli/dist/lib/cycle-attribution.js
-import { existsSync as existsSync120, readFileSync as readFileSync121 } from "node:fs";
+import { existsSync as existsSync121, readFileSync as readFileSync122 } from "node:fs";
 function readCycleAttributionFromEvents(eventsPath4, cycleId) {
-  if (!existsSync120(eventsPath4))
+  if (!existsSync121(eventsPath4))
     return {};
   let content;
   try {
-    content = readFileSync121(eventsPath4, "utf8");
+    content = readFileSync122(eventsPath4, "utf8");
   } catch {
     return {};
   }
@@ -276567,6 +276808,8 @@ function describeCommand(cmd) {
       return `resolve_route        \u2192 router.resolveRoute(${cmd.storyId})`;
     case "spawn_agent":
       return `spawn_agent          \u2192 agentSpawn(${cmd.agent}, attempt ${cmd.attempt})`;
+    case "spawn_role":
+      return `spawn_role           \u2192 agentSpawn(${cmd.agent} as ${cmd.role}, round ${cmd.round})`;
     case "kill_agent":
       return `kill_agent           \u2192 SIGKILL (grace ${cmd.graceSec}s)`;
     case "sleep_backoff":
@@ -276636,21 +276879,21 @@ function maybeSwitchAgent(deps) {
 // packages/cli/dist/runner/correction-circuit.js
 init_dist2();
 init_dist();
-import { appendFileSync as appendFileSync21, existsSync as existsSync121, mkdirSync as mkdirSync66, readFileSync as readFileSync122, writeFileSync as writeFileSync65 } from "node:fs";
-import { dirname as dirname66, join as join137 } from "node:path";
+import { appendFileSync as appendFileSync21, existsSync as existsSync122, mkdirSync as mkdirSync66, readFileSync as readFileSync123, writeFileSync as writeFileSync65 } from "node:fs";
+import { dirname as dirname67, join as join138 } from "node:path";
 function readLoopSafety(projectPath3) {
   try {
-    const path = join137(projectPath3, ".roll", "policy.yaml");
-    if (!existsSync121(path))
+    const path = join138(projectPath3, ".roll", "policy.yaml");
+    if (!existsSync122(path))
       return parsePolicy("").loopSafety;
-    return parsePolicy(readFileSync122(path, "utf8")).loopSafety;
+    return parsePolicy(readFileSync123(path, "utf8")).loopSafety;
   } catch {
     return parsePolicy("").loopSafety;
   }
 }
 function readEvents8(eventsPath4) {
   try {
-    return readFileSync122(eventsPath4, "utf8").split("\n").map(parseEventLine).filter((ev) => ev !== null);
+    return readFileSync123(eventsPath4, "utf8").split("\n").map(parseEventLine).filter((ev) => ev !== null);
   } catch {
     return [];
   }
@@ -276659,7 +276902,7 @@ function alreadyTripped(events, verdict) {
   return events.some((ev) => ev.type === "correction:circuit_breaker" && ev.signal === verdict.signal && ev.threshold === verdict.threshold && (ev.storyId ?? "") === (verdict.storyId ?? ""));
 }
 function appendEvent2(eventsPath4, event) {
-  mkdirSync66(dirname66(eventsPath4), { recursive: true });
+  mkdirSync66(dirname67(eventsPath4), { recursive: true });
   appendFileSync21(eventsPath4, `${JSON.stringify(event)}
 `, "utf8");
 }
@@ -276673,8 +276916,8 @@ function applyCorrectionCircuitBreaker(projectPath3, slug3, eventsPath4, alertsP
     return { status: "already_tripped", verdict };
   const failure6 = classifyCorrectionFailure(verdict.signal);
   const playbook = playbookForFailure(failure6.failureClass, failure6.rootCauseKey);
-  const pauseMarker = join137(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
-  const pauseWritten = !existsSync121(pauseMarker);
+  const pauseMarker = join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
+  const pauseWritten = !existsSync122(pauseMarker);
   const alertMsg = `# ALERT \u2014 correction circuit breaker tripped
 
 **Reason**: ${verdict.reason}
@@ -276687,10 +276930,10 @@ function applyCorrectionCircuitBreaker(projectPath3, slug3, eventsPath4, alertsP
 **Action**: loop paused to prevent unattended correction oscillation. Resume manually with \`roll loop resume\`.
 `;
   try {
-    mkdirSync66(dirname66(pauseMarker), { recursive: true });
+    mkdirSync66(dirname67(pauseMarker), { recursive: true });
     if (pauseWritten)
       writeFileSync65(pauseMarker, alertMsg, "utf8");
-    mkdirSync66(dirname66(alertsPath), { recursive: true });
+    mkdirSync66(dirname67(alertsPath), { recursive: true });
     appendFileSync21(alertsPath, `${alertMsg}
 `, "utf8");
     appendEvent2(eventsPath4, {
@@ -276723,23 +276966,23 @@ function announceReport(projectPath3, slug3, storyId, opener = (p) => {
 }) {
   if (storyId === "")
     return null;
-  const latest = join138(cardArchiveDir(projectPath3, storyId), "latest");
-  const review = join138(latest, reviewFileName(storyId));
-  const legacyReport = join138(latest, reportFileName(storyId));
-  const report = existsSync122(review) ? review : existsSync122(legacyReport) ? legacyReport : null;
+  const latest = join139(cardArchiveDir(projectPath3, storyId), "latest");
+  const review = join139(latest, reviewFileName(storyId));
+  const legacyReport = join139(latest, reportFileName(storyId));
+  const report = existsSync123(review) ? review : existsSync123(legacyReport) ? legacyReport : null;
   if (report === null)
     return null;
   const label5 = currentLang() === "zh" ? "\u9A8C\u6536 Review Page" : "Acceptance Review Page";
   process.stdout.write(`${label5}: ${report}
 `);
-  const muted = existsSync122(join138(projectPath3, ".roll", "loop", `mute-${slug3}`)) || existsSync122(join138(process.env["ROLL_SHARED_ROOT"] || join138(process.env["HOME"] ?? "", ".shared", "roll"), "loop", `mute-${slug3}`));
+  const muted = existsSync123(join139(projectPath3, ".roll", "loop", `mute-${slug3}`)) || existsSync123(join139(process.env["ROLL_SHARED_ROOT"] || join139(process.env["HOME"] ?? "", ".shared", "roll"), "loop", `mute-${slug3}`));
   if (!muted)
     opener(report);
   return report;
 }
 function resetLiveLog(runtimeDirPath, cycleId) {
   try {
-    writeFileSync66(join138(runtimeDirPath, "live.log"), `=== cycle ${cycleId} ===
+    writeFileSync66(join139(runtimeDirPath, "live.log"), `=== cycle ${cycleId} ===
 `, "utf8");
   } catch {
   }
@@ -276756,7 +276999,7 @@ function cycleSignalTeardown(paths, cycleId, branch, sig, deps = {}) {
   }
   let owned = false;
   try {
-    owned = existsSync122(paths.lockPath) && readLockOwner(paths.lockPath)?.pid === pid;
+    owned = existsSync123(paths.lockPath) && readLockOwner(paths.lockPath)?.pid === pid;
   } catch {
     owned = false;
   }
@@ -276859,7 +277102,7 @@ function makeCycleId(now2 = /* @__PURE__ */ new Date(), pid = process.pid) {
 }
 function runtimeDir11(projectPath3) {
   const env = (process.env["ROLL_PROJECT_RUNTIME_DIR"] ?? "").trim();
-  return env !== "" ? env : join138(projectPath3, ".roll", "loop");
+  return env !== "" ? env : join139(projectPath3, ".roll", "loop");
 }
 var PAUSE_THRESHOLD = 3;
 var GO_LOCK_STALE_SEC2 = 21600;
@@ -276891,11 +277134,11 @@ function writeCardSkipAlert(alertsPath, eventsPath4, cycleId, storyId, count) {
 }
 function incrementConsecutiveFails(projectPath3, slug3, alertsPath, eventsPath4, cycleId, storyId, terminal) {
   const rt = runtimeDir11(projectPath3);
-  const counterFile = join138(rt, "consecutive-fails");
+  const counterFile = join139(rt, "consecutive-fails");
   let count = 0;
   try {
-    if (existsSync122(counterFile)) {
-      count = parseInt(readFileSync123(counterFile, "utf8").trim(), 10) || 0;
+    if (existsSync123(counterFile)) {
+      count = parseInt(readFileSync124(counterFile, "utf8").trim(), 10) || 0;
     }
   } catch {
   }
@@ -276907,8 +277150,8 @@ function incrementConsecutiveFails(projectPath3, slug3, alertsPath, eventsPath4,
   const threshold = readFailurePauseThreshold(projectPath3);
   if (count < threshold)
     return;
-  const pauseMarker = join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
-  if (existsSync122(pauseMarker))
+  const pauseMarker = join139(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
+  if (existsSync123(pauseMarker))
     return;
   const alertMsg = `# ALERT \u2014 loop auto-paused after ${count} consecutive failures
 
@@ -276943,8 +277186,8 @@ loop run-once: \u8FDE\u7EED ${count} \u6B21\u5931\u8D25\u540E\u81EA\u52A8\u6682\
 `);
 }
 function writeRootCausePause(projectPath3, slug3, alertsPath, eventsPath4, cycleId, attribution, count, snapshotPath2) {
-  const pauseMarker = join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
-  if (existsSync122(pauseMarker))
+  const pauseMarker = join139(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
+  if (existsSync123(pauseMarker))
     return;
   const playbook = playbookForFailure(attribution.failureClass, attribution.rootCauseKey);
   const alertMsg = `# ALERT \u2014 loop auto-paused on ${attribution.failureClass} failure
@@ -277005,10 +277248,10 @@ function handleNonCardFailure(projectPath3, slug3, alertsPath, eventsPath4, runt
 }
 function readFailurePauseThreshold(projectPath3) {
   try {
-    const policy = join138(projectPath3, ".roll", "policy.yaml");
-    if (!existsSync122(policy))
+    const policy = join139(projectPath3, ".roll", "policy.yaml");
+    if (!existsSync123(policy))
       return PAUSE_THRESHOLD;
-    return parsePolicy(readFileSync123(policy, "utf8")).loopSafety.maxConsecutiveFailures;
+    return parsePolicy(readFileSync124(policy, "utf8")).loopSafety.maxConsecutiveFailures;
   } catch {
     return PAUSE_THRESHOLD;
   }
@@ -277016,7 +277259,7 @@ function readFailurePauseThreshold(projectPath3) {
 function resetConsecutiveFails(projectPath3) {
   const rt = runtimeDir11(projectPath3);
   try {
-    writeFileSync66(join138(rt, "consecutive-fails"), "0", "utf8");
+    writeFileSync66(join139(rt, "consecutive-fails"), "0", "utf8");
   } catch {
   }
 }
@@ -277030,14 +277273,14 @@ loop run-once: ${storyId} \u2014 \u4EE3\u7406\u5168\u90E8\u8017\u5C3D(${failCoun
   }
 }
 function idleCounterPath(projectPath3, slug3) {
-  return join138(runtimeDir11(projectPath3), `consecutive-idle-${slug3}`);
+  return join139(runtimeDir11(projectPath3), `consecutive-idle-${slug3}`);
 }
 function incrementConsecutiveIdle(projectPath3, slug3) {
   const file = idleCounterPath(projectPath3, slug3);
   let count = 0;
   try {
-    if (existsSync122(file)) {
-      count = parseInt(readFileSync123(file, "utf8").trim(), 10) || 0;
+    if (existsSync123(file)) {
+      count = parseInt(readFileSync124(file, "utf8").trim(), 10) || 0;
     }
   } catch {
   }
@@ -277103,9 +277346,9 @@ function readExternalBlock(eventsPath4, cycleId) {
   const authDetails = [];
   const networkDetails = [];
   try {
-    if (!existsSync122(eventsPath4))
+    if (!existsSync123(eventsPath4))
       return null;
-    for (const line of readFileSync123(eventsPath4, "utf8").split("\n")) {
+    for (const line of readFileSync124(eventsPath4, "utf8").split("\n")) {
       if (line.trim() === "" || !line.includes("agent:blocked"))
         continue;
       let e;
@@ -277167,8 +277410,8 @@ function writeReviewerBlockedAlert(projectPath3, slug3, alertsPath, eventsPath4,
   } catch {
   }
   if (block.cause === "auth") {
-    const pauseMarker = join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
-    if (!existsSync122(pauseMarker)) {
+    const pauseMarker = join139(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
+    if (!existsSync123(pauseMarker)) {
       try {
         writeFileSync66(pauseMarker, msg6, "utf8");
         bus.appendEvent(eventsPath4, { type: "policy:safety_pause", loop: "ci", reason: `agent auth block: ${agents}`, ts: ts2 });
@@ -277187,15 +277430,15 @@ function readSkillBody3(projectPath3) {
 }
 function buildLoopRouteDeps(projectPath3) {
   function readSlot(slot) {
-    const agentsYaml = join138(projectPath3, ".roll", "agents.yaml");
+    const agentsYaml = join139(projectPath3, ".roll", "agents.yaml");
     try {
-      return readSlotFromText(readFileSync123(agentsYaml, "utf8"), slot);
+      return readSlotFromText(readFileSync124(agentsYaml, "utf8"), slot);
     } catch {
       return void 0;
     }
   }
   function firstInstalled() {
-    const fromLocal = readField(join138(projectPath3, ".roll", "local.yaml"), /^agent:/);
+    const fromLocal = readField(join139(projectPath3, ".roll", "local.yaml"), /^agent:/);
     if (fromLocal !== void 0)
       return fromLocal;
     return firstInstalledAgent(realAgentEnv());
@@ -277204,7 +277447,7 @@ function buildLoopRouteDeps(projectPath3) {
 }
 function readField(path, re) {
   try {
-    const text2 = readFileSync123(path, "utf8");
+    const text2 = readFileSync124(path, "utf8");
     for (const line of text2.split("\n")) {
       const m7 = line.match(re);
       if (m7 !== null) {
@@ -277236,9 +277479,9 @@ async function loopRunOnceCommand(args) {
     try {
       const markerIdx = id.path.indexOf(WORKTREE_MARKER);
       const stableProjectPath = markerIdx !== -1 ? id.path.slice(0, markerIdx) : cwd;
-      const stableRt = join138(stableProjectPath, ".roll", "loop");
-      mkdirSync67(dirname67(stableRt), { recursive: true });
-      appendFileSync22(join138(stableRt, `ALERT-${id.slug}.md`), `${msg6}
+      const stableRt = join139(stableProjectPath, ".roll", "loop");
+      mkdirSync67(dirname68(stableRt), { recursive: true });
+      appendFileSync22(join139(stableRt, `ALERT-${id.slug}.md`), `${msg6}
 `, "utf8");
     } catch {
     }
@@ -277265,8 +277508,8 @@ async function loopRunOnceCommand(args) {
     return 0;
   }
   const rt = runtimeDir11(id.path);
-  const alertsPath = join138(rt, `ALERT-${id.slug}.md`);
-  mkdirSync67(dirname67(alertsPath), { recursive: true });
+  const alertsPath = join139(rt, `ALERT-${id.slug}.md`);
+  mkdirSync67(dirname68(alertsPath), { recursive: true });
   if (coreWorktreeHeal.healed) {
     try {
       appendFileSync22(alertsPath, `[${(/* @__PURE__ */ new Date()).toISOString()}] ALERT FIX-1209: core.worktree was pointing to "${coreWorktreeHeal.detail}" \u2014 auto-unset before project identity resolution
@@ -277277,16 +277520,16 @@ async function loopRunOnceCommand(args) {
 `);
   }
   const paths = {
-    eventsPath: join138(rt, "events.ndjson"),
-    runsPath: join138(rt, "runs.jsonl"),
+    eventsPath: join139(rt, "events.ndjson"),
+    runsPath: join139(rt, "runs.jsonl"),
     alertsPath,
-    lockPath: join138(rt, "inner.lock"),
-    heartbeatPath: join138(rt, "heartbeat"),
-    worktreePath: join138(rt, "worktrees", `cycle-${cycleId}`)
+    lockPath: join139(rt, "inner.lock"),
+    heartbeatPath: join139(rt, "heartbeat"),
+    worktreePath: join139(rt, "worktrees", `cycle-${cycleId}`)
   };
   const allowedCards = parseAllowedCardsEnv();
   if (allowedCards === void 0) {
-    const goLockOwner = readLockOwner(join138(rt, "go.lock"));
+    const goLockOwner = readLockOwner(join139(rt, "go.lock"));
     if (isOwnerHeld(goLockOwner, Math.floor(Date.now() / 1e3), GO_LOCK_STALE_SEC2)) {
       const ts2 = Math.floor(Date.now() / 1e3);
       new EventBus().appendEvent(paths.eventsPath, {
@@ -277370,7 +277613,7 @@ loop run-once: ${repoCheck.detail !== "" ? `(${repoCheck.detail})` : ""}
     process.stderr.write(`loop run-once: roll-loop SKILL.md not found \u2014 refusing to spawn a blind agent (ALERT written)
 loop run-once: \u627E\u4E0D\u5230 roll-loop SKILL.md \u2014 \u62D2\u7EDD\u76F2\u5F00 agent(\u5DF2\u5199 ALERT)
 `);
-    incrementConsecutiveFails(id.path, id.slug, alertsPath, join138(rt, "events.ndjson"), cycleId, "", "skill_missing");
+    incrementConsecutiveFails(id.path, id.slug, alertsPath, join139(rt, "events.ndjson"), cycleId, "", "skill_missing");
     return 1;
   }
   const routeDeps = buildLoopRouteDeps(id.path);
@@ -277467,13 +277710,13 @@ loop run-once: \u8BC4\u5BA1\u5224\u5B9A ${resizeStory} \u8303\u56F4\u8FC7\u5927(
     const idleCount = incrementConsecutiveIdle(id.path, id.slug);
     try {
       const bus = new EventBus();
-      const backlogFile = join138(id.path, ".roll", "backlog.md");
+      const backlogFile = join139(id.path, ".roll", "backlog.md");
       const nowSec2 = Math.floor(Date.now() / 1e3);
       const outcome = await maybeEnterDormancy({
         slug: id.slug,
         count: idleCount,
         resolveState: () => resolveLoopRunState(id.path, id.slug),
-        readBacklog: () => existsSync122(backlogFile) ? readFileSync123(backlogFile, "utf8") : "",
+        readBacklog: () => existsSync123(backlogFile) ? readFileSync124(backlogFile, "utf8") : "",
         scheduler: createScheduler(process.platform, { uid: process.getuid?.() ?? 0 }),
         loopLabel: launchdLabel("loop", id.slug),
         now: () => (/* @__PURE__ */ new Date()).toISOString(),
@@ -277481,8 +277724,8 @@ loop run-once: \u8BC4\u5BA1\u5224\u5B9A ${resizeStory} \u8303\u56F4\u8FC7\u5927(
         writeDormant: (body) => writeDormantMarker(dormantMarkerPath(id.path, id.slug), body),
         upsertDormantRun: () => bus.upsertRun(paths.runsPath, { storyId: "", cycleId }, buildRunRow({ kind: "append_run", status: "dormant", outcome: mapV2Status("dormant"), cycleId }, { cycleId, branch, loop: "ci" }, nowSec2)),
         writePause: (reason) => {
-          const p = join138(id.path, ".roll", "loop", `PAUSE-${id.slug}`);
-          mkdirSync67(dirname67(p), { recursive: true });
+          const p = join139(id.path, ".roll", "loop", `PAUSE-${id.slug}`);
+          mkdirSync67(dirname68(p), { recursive: true });
           writeFileSync66(p, `# loop paused \u2014 dormancy bootout failed
 
 ${reason}
@@ -277523,7 +277766,7 @@ loop run-once: cycle ${cycleId} \u2192 ${externalBlock.cause}_blocked(\u53EF\u60
     const failedAgent = (result.state?.ctx?.agent ?? "").trim();
     const zeroTcr = tcr === 0 && (result.terminal === "gave_up" || result.terminal === "blocked");
     if (sid !== "" && failedAgent !== "" && zeroTcr) {
-      const backlogFile = join138(id.path, ".roll", "backlog.md");
+      const backlogFile = join139(id.path, ".roll", "backlog.md");
       const bus = new EventBus();
       const swapped = autoRecoverEnabled() ? maybeSwitchAgent({
         runtimeDir: runtimeDir11(id.path),
@@ -277540,7 +277783,7 @@ loop run-once: cycle ${cycleId} \u2192 ${externalBlock.cause}_blocked(\u53EF\u60
         emit: (ev) => bus.appendEvent(paths.eventsPath, ev),
         remarkTodo: (storyId) => {
           try {
-            const content = readFileSync123(backlogFile, "utf8");
+            const content = readFileSync124(backlogFile, "utf8");
             const r = markStatus(content, storyId, STATUS_MARKER.todo);
             if (r.count > 0)
               writeFileSync66(backlogFile, r.content, "utf8");
@@ -277658,7 +277901,7 @@ async function isOffline(resolve14 = (h) => lookup2(h)) {
   }
 }
 function isLoopPaused(projectPath3, slug3) {
-  return existsSync122(join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`));
+  return existsSync123(join139(projectPath3, ".roll", "loop", `PAUSE-${slug3}`));
 }
 function branchCanaryTrips(projectPath3, slug3, rt, alertsPath) {
   let ephemeralBranchCount = 0;
@@ -277669,7 +277912,7 @@ function branchCanaryTrips(projectPath3, slug3, rt, alertsPath) {
   }
   let worktreeCount = 0;
   try {
-    worktreeCount = readdirSync45(join138(rt, "worktrees"), { withFileTypes: true }).filter((e) => e.isDirectory()).length;
+    worktreeCount = readdirSync45(join139(rt, "worktrees"), { withFileTypes: true }).filter((e) => e.isDirectory()).length;
   } catch {
   }
   const parsed = parseInt(process.env["ROLL_BRANCH_CANARY_MAX"] ?? "", 10);
@@ -277681,7 +277924,7 @@ function branchCanaryTrips(projectPath3, slug3, rt, alertsPath) {
     alreadyPaused: isLoopPaused(projectPath3, slug3)
   });
   if (verdict.shouldPause) {
-    const pauseMarker = join138(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
+    const pauseMarker = join139(projectPath3, ".roll", "loop", `PAUSE-${slug3}`);
     const msg6 = `# ALERT \u2014 loop auto-paused: branch/worktree leak canary tripped (US-LOOP-096)
 
 **Leak count**: ${verdict.total} (ephemeral branches ${ephemeralBranchCount} + worktrees ${worktreeCount}) > threshold ${threshold}
@@ -277689,7 +277932,7 @@ function branchCanaryTrips(projectPath3, slug3, rt, alertsPath) {
   Inspect \`git branch\` / \`git worktree list\`, clean up, then: \`roll loop resume\`
 `;
     try {
-      mkdirSync67(dirname67(pauseMarker), { recursive: true });
+      mkdirSync67(dirname68(pauseMarker), { recursive: true });
       writeFileSync66(pauseMarker, msg6, "utf8");
     } catch {
     }
@@ -277756,16 +277999,16 @@ function checkCoreWorktreeContamination(cwd) {
   const main = repairCoreWorktreeContamination(cwd);
   if (main.healed)
     return main;
-  const meta8 = repairCoreWorktreeContamination(join138(cwd, ".roll"));
+  const meta8 = repairCoreWorktreeContamination(join139(cwd, ".roll"));
   return meta8.healed ? { healed: true, detail: `roll-meta: ${meta8.detail}` } : meta8;
 }
 
 // packages/cli/dist/commands/offboard.js
 init_dist();
 import { spawnSync as spawnSync16 } from "node:child_process";
-import { existsSync as existsSync123, readFileSync as readFileSync124, realpathSync as realpathSync18, renameSync as renameSync25, rmSync as rmSync22, writeFileSync as writeFileSync67 } from "node:fs";
+import { existsSync as existsSync124, readFileSync as readFileSync125, realpathSync as realpathSync18, renameSync as renameSync25, rmSync as rmSync23, writeFileSync as writeFileSync67 } from "node:fs";
 import { homedir as homedir30 } from "node:os";
-import { join as join139, resolve as resolve11 } from "node:path";
+import { join as join140, resolve as resolve11 } from "node:path";
 function pal5() {
   const noColor2 = (process.env["NO_COLOR"] ?? "") !== "";
   return noColor2 ? { RED: "", GREEN: "", YELLOW: "", CYAN: "", BOLD: "", NC: "" } : {
@@ -277803,7 +278046,7 @@ function m4(key, ...args) {
   return t(v2Catalog, msgLang7(), key, ...args);
 }
 function changesetPath2(projectDir) {
-  return join139(projectDir, ".roll", "onboard-changeset.yaml");
+  return join140(projectDir, ".roll", "onboard-changeset.yaml");
 }
 function loopInCycle2() {
   return (process.env["ROLL_LOOP_AGENT"] ?? "") !== "" || (process.env["ROLL_CYCLE_LOG_RAW"] ?? "") !== "";
@@ -277813,7 +278056,7 @@ function runLaunchctl(args) {
   if (args[0] !== void 0 && readOnly.has(args[0])) {
     return spawnSync16("launchctl", args, { stdio: "inherit" }).status ?? 1;
   }
-  const canonical = join139(homedir30(), "Library", "LaunchAgents");
+  const canonical = join140(homedir30(), "Library", "LaunchAgents");
   const launchdDir = process.env["_LAUNCHD_DIR"] ?? canonical;
   if (launchdDir !== canonical)
     return 0;
@@ -277864,7 +278107,7 @@ function writeFileAtomic2(path, text2) {
     writeFileSync67(tmp, text2);
     renameSync25(tmp, path);
   } catch (error) {
-    rmSync22(tmp, { force: true });
+    rmSync23(tmp, { force: true });
     throw error;
   }
 }
@@ -277895,7 +278138,7 @@ function offboardCommand(args) {
     projectDir = process.cwd();
   }
   const changeset = changesetPath2(projectDir);
-  if (!existsSync123(changeset)) {
+  if (!existsSync124(changeset)) {
     err10(m4("offboard.no_changeset_en"));
     err10(m4("offboard.no_changeset_zh"));
     process.stderr.write("\n");
@@ -277909,7 +278152,7 @@ function offboardCommand(args) {
 `);
     return 1;
   }
-  const parsed = parseChangeset(readFileSync124(changeset, "utf8"));
+  const parsed = parseChangeset(readFileSync125(changeset, "utf8"));
   if (!parsed.ok) {
     err10(m4("offboard.failed_to_parse_changeset"));
     return 1;
@@ -277994,9 +278237,9 @@ function offboardCommand(args) {
   process.stdout.write(m4("offboard.applying_offboard") + "\n");
   for (const item of mergedFiles) {
     const path = resolveChangesetItem(projectDir, item);
-    if (!existsSync123(path))
+    if (!existsSync124(path))
       continue;
-    const before = readFileSync124(path, "utf8");
+    const before = readFileSync125(path, "utf8");
     const after = stripRollMergeBlocks(before);
     if (after !== before) {
       writeFileAtomic2(path, after);
@@ -278007,8 +278250,8 @@ function offboardCommand(args) {
   for (const item of files) {
     try {
       const path = resolveChangesetItem(projectDir, item);
-      rmSync22(path, { force: true });
-      if (!existsSync123(path))
+      rmSync23(path, { force: true });
+      if (!existsSync124(path))
         process.stdout.write(`    removed file ${item}
 `);
     } catch {
@@ -278016,16 +278259,16 @@ function offboardCommand(args) {
   }
   for (const item of dirs) {
     try {
-      rmSync22(resolveChangesetItem(projectDir, item), { recursive: true, force: true });
+      rmSync23(resolveChangesetItem(projectDir, item), { recursive: true, force: true });
       process.stdout.write(`    removed dir  ${item}
 `);
     } catch {
     }
   }
   for (const item of giEntries) {
-    const gi = join139(projectDir, ".gitignore");
-    if (existsSync123(gi)) {
-      const lines3 = readFileSync124(gi, "utf8").split("\n");
+    const gi = join140(projectDir, ".gitignore");
+    if (existsSync124(gi)) {
+      const lines3 = readFileSync125(gi, "utf8").split("\n");
       if (lines3.includes(item)) {
         const kept = lines3.filter((l) => l !== item);
         writeFileAtomic2(gi, kept.join("\n"));
@@ -278035,27 +278278,27 @@ function offboardCommand(args) {
     }
   }
   for (const item of plists) {
-    const plistPath = join139(homedir30(), "Library", "LaunchAgents", item);
+    const plistPath = join140(homedir30(), "Library", "LaunchAgents", item);
     const r = runLaunchctl(["unload", "-w", plistPath]);
     if (r === 0)
       process.stdout.write(`    unloaded     ${item}
 `);
-    rmSync22(plistPath, { force: true });
+    rmSync23(plistPath, { force: true });
   }
-  rmSync22(changeset, { force: true });
+  rmSync23(changeset, { force: true });
   ok11(m4("offboard.offboard_complete_offboard"));
   return 0;
 }
 
 // packages/cli/dist/commands/prices.js
 init_dist();
-import { existsSync as existsSync125, readdirSync as readdirSync47, readFileSync as readFileSync126 } from "node:fs";
-import { join as join141 } from "node:path";
+import { existsSync as existsSync126, readdirSync as readdirSync47, readFileSync as readFileSync127 } from "node:fs";
+import { join as join142 } from "node:path";
 
 // packages/cli/dist/commands/prices-refresh.js
 init_dist();
-import { existsSync as existsSync124, mkdirSync as mkdirSync68, readdirSync as readdirSync46, readFileSync as readFileSync125, writeFileSync as writeFileSync68 } from "node:fs";
-import { join as join140 } from "node:path";
+import { existsSync as existsSync125, mkdirSync as mkdirSync68, readdirSync as readdirSync46, readFileSync as readFileSync126, writeFileSync as writeFileSync68 } from "node:fs";
+import { join as join141 } from "node:path";
 var FetchError = class extends Error {
   constructor(message) {
     super(message);
@@ -278276,13 +278519,13 @@ function vendorFromSnapshotName(name) {
   return match[2] ?? "anthropic";
 }
 function latestSnapshotPath(snapshotDir, vendor) {
-  if (!existsSync124(snapshotDir))
+  if (!existsSync125(snapshotDir))
     return null;
-  const snaps = readdirSync46(snapshotDir).filter((name) => SNAPSHOT_RE.test(name) && vendorFromSnapshotName(name) === vendor).sort().map((name) => join140(snapshotDir, name));
+  const snaps = readdirSync46(snapshotDir).filter((name) => SNAPSHOT_RE.test(name) && vendorFromSnapshotName(name) === vendor).sort().map((name) => join141(snapshotDir, name));
   return snaps[snaps.length - 1] ?? null;
 }
 function readPrices(path) {
-  const data = JSON.parse(readFileSync125(path, "utf8"));
+  const data = JSON.parse(readFileSync126(path, "utf8"));
   return data.prices ?? {};
 }
 function diffPrices(oldPrices, newPrices) {
@@ -278375,7 +278618,7 @@ function snapshotJson(payload) {
 function writeSnapshot(input) {
   mkdirSync68(input.snapshotDir, { recursive: true });
   const suffix = input.vendor === "anthropic" ? "" : `-${input.vendor}`;
-  const dest = join140(input.snapshotDir, `snapshot-${input.effectiveAt}${suffix}.json`);
+  const dest = join141(input.snapshotDir, `snapshot-${input.effectiveAt}${suffix}.json`);
   writeFileSync68(dest, snapshotJson({
     version: input.effectiveAt,
     effective_at: input.effectiveAt,
@@ -278447,7 +278690,7 @@ async function pricesRefreshCommand(args, deps = {}) {
   } else {
     vendor = "anthropic";
   }
-  const snapshotDir = deps.snapshotDir ?? join140(repoRoot2(), "lib", "prices");
+  const snapshotDir = deps.snapshotDir ?? join141(repoRoot2(), "lib", "prices");
   try {
     const result = await refresh({ snapshotDir, vendor, url, deps });
     if (result.action === "unchanged") {
@@ -278484,13 +278727,13 @@ async function pricesRefreshCommand(args, deps = {}) {
 
 // packages/cli/dist/commands/prices.js
 function loadSnapshots() {
-  const dir = join141(repoRoot2(), "lib", "prices");
-  if (!existsSync125(dir)) {
+  const dir = join142(repoRoot2(), "lib", "prices");
+  if (!existsSync126(dir)) {
     throw new Error(`no price snapshots found in ${dir}; run \`roll prices refresh\``);
   }
   const files = readdirSync47(dir).filter((n) => n.startsWith("snapshot-") && n.endsWith(".json")).sort();
   return files.map((name) => {
-    const data = JSON.parse(readFileSync126(join141(dir, name), "utf8"));
+    const data = JSON.parse(readFileSync127(join142(dir, name), "utf8"));
     for (const key of ["version", "effective_at", "source_url", "prices"]) {
       if (data[key] === void 0)
         throw new Error(`snapshot ${name} missing required key ${key}`);
@@ -278669,24 +278912,24 @@ init_dist3();
 init_dist();
 init_render();
 import { execFileSync as execFileSync33 } from "node:child_process";
-import { mkdirSync as mkdirSync72, readFileSync as readFileSync130, writeFileSync as writeFileSync72, existsSync as existsSync129 } from "node:fs";
-import { dirname as dirname71, join as join145 } from "node:path";
+import { mkdirSync as mkdirSync72, readFileSync as readFileSync131, writeFileSync as writeFileSync72, existsSync as existsSync130 } from "node:fs";
+import { dirname as dirname72, join as join146 } from "node:path";
 
 // packages/cli/dist/lib/release-consistency.js
 init_dist2();
 init_dist();
 init_render();
 import { execFileSync as execFileSync32 } from "node:child_process";
-import { existsSync as existsSync127, mkdirSync as mkdirSync70, readFileSync as readFileSync128, readdirSync as readdirSync49, statSync as statSync39, writeFileSync as writeFileSync70 } from "node:fs";
-import { dirname as dirname69, join as join143 } from "node:path";
+import { existsSync as existsSync128, mkdirSync as mkdirSync70, readFileSync as readFileSync129, readdirSync as readdirSync49, statSync as statSync39, writeFileSync as writeFileSync70 } from "node:fs";
+import { dirname as dirname70, join as join144 } from "node:path";
 
 // packages/cli/dist/lib/consistency-audit.js
 init_dist2();
 init_dist3();
 init_dist();
 import { execFile as execFile17 } from "node:child_process";
-import { existsSync as existsSync126, mkdirSync as mkdirSync69, readFileSync as readFileSync127, readdirSync as readdirSync48, writeFileSync as writeFileSync69 } from "node:fs";
-import { dirname as dirname68, join as join142 } from "node:path";
+import { existsSync as existsSync127, mkdirSync as mkdirSync69, readFileSync as readFileSync128, readdirSync as readdirSync48, writeFileSync as writeFileSync69 } from "node:fs";
+import { dirname as dirname69, join as join143 } from "node:path";
 import { promisify as promisify17 } from "node:util";
 init_dist();
 init_dist();
@@ -278694,10 +278937,10 @@ var PROBE_CAP = 20;
 var COUNT_WINDOW_SEC = 72 * 3600;
 var execFileAsync17 = promisify17(execFile17);
 function readJsonl(path) {
-  if (!existsSync126(path))
+  if (!existsSync127(path))
     return [];
   const out3 = [];
-  for (const line of readFileSync127(path, "utf8").split("\n")) {
+  for (const line of readFileSync128(path, "utf8").split("\n")) {
     if (line.trim() === "")
       continue;
     try {
@@ -278710,18 +278953,18 @@ function readJsonl(path) {
   return out3;
 }
 function readJson(path) {
-  if (!existsSync126(path))
+  if (!existsSync127(path))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync127(path, "utf8"));
+    const parsed = JSON.parse(readFileSync128(path, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function hasScreenshotArtifact(reportPath) {
-  const runDir = dirname68(reportPath);
-  const manifest = readJson(join142(runDir, "evidence.json"));
+  const runDir = dirname69(reportPath);
+  const manifest = readJson(join143(runDir, "evidence.json"));
   if (manifest !== null) {
     const screenshots = manifest["screenshots"];
     if (Array.isArray(screenshots) && screenshots.some((x) => typeof x === "string" && x !== ""))
@@ -278737,8 +278980,8 @@ function hasScreenshotArtifact(reportPath) {
       }
     }
   }
-  const dir = join142(runDir, "screenshots");
-  if (!existsSync126(dir))
+  const dir = join143(runDir, "screenshots");
+  if (!existsSync127(dir))
     return false;
   try {
     return readdirSync48(dir).some((name) => /\.png$/i.test(name));
@@ -278747,7 +278990,7 @@ function hasScreenshotArtifact(reportPath) {
   }
 }
 function hasMachineCaptureSkip2(reportPath) {
-  const manifest = readJson(join142(dirname68(reportPath), "evidence.json"));
+  const manifest = readJson(join143(dirname69(reportPath), "evidence.json"));
   const captures = manifest?.["captures"];
   if (!Array.isArray(captures))
     return false;
@@ -278774,18 +279017,18 @@ async function gatherAuditSnapshot(projectPath3, runtimeDir12, deps = {}) {
   const nowSec2 = deps.nowSec ?? Math.floor(Date.now() / 1e3);
   const snapshot = emptyAuditSnapshot(nowSec2, TERMINAL_SCHEMA_EPOCH_SEC);
   const skipped2 = [];
-  const backlogPath = join142(projectPath3, ".roll", "backlog.md");
-  if (existsSync126(backlogPath)) {
-    snapshot.backlog = parseBacklog(readFileSync127(backlogPath, "utf8")).map((r) => ({ id: r.id, status: r.status }));
+  const backlogPath = join143(projectPath3, ".roll", "backlog.md");
+  if (existsSync127(backlogPath)) {
+    snapshot.backlog = parseBacklog(readFileSync128(backlogPath, "utf8")).map((r) => ({ id: r.id, status: r.status }));
   }
   snapshot.index = readIndex(projectPath3);
   snapshot.localMainAhead = deps.localMainAhead !== void 0 ? await deps.localMainAhead() : await gitLocalMainAhead(projectPath3);
-  snapshot.runs = readJsonl(join142(runtimeDir12, "runs.jsonl"));
+  snapshot.runs = readJsonl(join143(runtimeDir12, "runs.jsonl"));
   let eventFailed = 0;
   const terminal = [];
-  const eventsPath4 = join142(runtimeDir12, "events.ndjson");
-  if (existsSync126(eventsPath4)) {
-    for (const line of readFileSync127(eventsPath4, "utf8").split("\n")) {
+  const eventsPath4 = join143(runtimeDir12, "events.ndjson");
+  if (existsSync127(eventsPath4)) {
+    for (const line of readFileSync128(eventsPath4, "utf8").split("\n")) {
       const e = parseEventLine(line);
       if (e === null)
         continue;
@@ -278807,22 +279050,22 @@ async function gatherAuditSnapshot(projectPath3, runtimeDir12, deps = {}) {
     if (!row2.status.includes("\u2705"))
       continue;
     const card = cardArchiveDir(projectPath3, row2.id);
-    if (!existsSync126(card))
+    if (!existsSync127(card))
       continue;
-    const reportPath = join142(card, "latest", reportFileName(row2.id));
-    const specPath = join142(card, "spec.md");
+    const reportPath = join143(card, "latest", reportFileName(row2.id));
+    const specPath = join143(card, "spec.md");
     let noVisualSurface = false;
-    if (existsSync126(specPath)) {
+    if (existsSync127(specPath)) {
       try {
-        noVisualSurface = !hasVisualEvidenceAc(readFileSync127(specPath, "utf8"));
+        noVisualSurface = !hasVisualEvidenceAc(readFileSync128(specPath, "utf8"));
       } catch {
       }
     }
     snapshot.attest[row2.id] = {
-      report: existsSync126(reportPath),
-      acMap: existsSync126(join142(card, "ac-map.json")),
-      visualEvidence: existsSync126(reportPath) ? hasScreenshotArtifact(reportPath) : false,
-      machineSkip: existsSync126(reportPath) ? hasMachineCaptureSkip2(reportPath) : false,
+      report: existsSync127(reportPath),
+      acMap: existsSync127(join143(card, "ac-map.json")),
+      visualEvidence: existsSync127(reportPath) ? hasScreenshotArtifact(reportPath) : false,
+      machineSkip: existsSync127(reportPath) ? hasMachineCaptureSkip2(reportPath) : false,
       noVisualSurface
     };
   }
@@ -278906,16 +279149,16 @@ async function consistencyAuditCommand(args, deps = {}) {
   const json = args.includes("--json");
   const projectPath3 = process.cwd();
   const rtEnv = (process.env["ROLL_PROJECT_RUNTIME_DIR"] ?? "").trim();
-  const runtimeDir12 = rtEnv !== "" ? rtEnv : join142(projectPath3, ".roll", "loop");
+  const runtimeDir12 = rtEnv !== "" ? rtEnv : join143(projectPath3, ".roll", "loop");
   const { snapshot, skipped: skipped2 } = await gatherAuditSnapshot(projectPath3, runtimeDir12, deps);
   const report = runConsistencyAudit(snapshot);
   const nowMs2 = (deps.nowSec ?? Math.floor(Date.now() / 1e3)) * 1e3;
   const dateTag = new Date(nowMs2).toISOString().slice(0, 10);
-  const outDir = join142(projectPath3, ".roll", "reports", "consistency");
+  const outDir = join143(projectPath3, ".roll", "reports", "consistency");
   try {
     mkdirSync69(outDir, { recursive: true });
-    writeFileSync69(join142(outDir, `${dateTag}.json`), JSON.stringify({ generatedAt: dateTag, ...report, skipped: skipped2 }, null, 1));
-    writeFileSync69(join142(outDir, `${dateTag}.md`), renderMarkdown2(report, skipped2, dateTag));
+    writeFileSync69(join143(outDir, `${dateTag}.json`), JSON.stringify({ generatedAt: dateTag, ...report, skipped: skipped2 }, null, 1));
+    writeFileSync69(join143(outDir, `${dateTag}.md`), renderMarkdown2(report, skipped2, dateTag));
   } catch {
     process.stderr.write("consistency audit: report write failed (scan still completed)\n");
   }
@@ -278923,7 +279166,7 @@ async function consistencyAuditCommand(args, deps = {}) {
     process.stdout.write(JSON.stringify({ ...report, skipped: skipped2 }, null, 1) + "\n");
   } else {
     process.stdout.write(`consistency audit (shadow): fail ${report.summary.fail} \xB7 warn ${report.summary.warn} \xB7 unknown ${report.summary.unknown} \xB7 grandfathered ${report.summary.grandfathered}
-\u4E00\u81F4\u6027\u5BA1\u8BA1(\u5F71\u5B50\u6A21\u5F0F): \u62A5\u544A\u5DF2\u5199\u5165 ${join142(".roll", "reports", "consistency", `${dateTag}.md`)}
+\u4E00\u81F4\u6027\u5BA1\u8BA1(\u5F71\u5B50\u6A21\u5F0F): \u62A5\u544A\u5DF2\u5199\u5165 ${join143(".roll", "reports", "consistency", `${dateTag}.md`)}
 `);
     for (const f of report.findings.filter((x) => x.severity === "fail").slice(0, 10)) {
       process.stdout.write(`  \u2717 ${f.rule} ${f.subject} \u2014 ${f.detail}
@@ -278962,7 +279205,7 @@ function escapeRegExp4(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function readText(p) {
-  return readFileSync128(p, "utf8");
+  return readFileSync129(p, "utf8");
 }
 var COMMAND_SURFACE_REPLACEMENTS = /* @__PURE__ */ new Map([
   ["migrate", "npx @seanyao/roll@2 migrate"],
@@ -278980,7 +279223,7 @@ function lineNumberAt(text2, index) {
   return text2.slice(0, index).split("\n").length;
 }
 function existingTextFiles(projectDir, rels) {
-  return rels.map((rel) => ({ rel, abs: join143(projectDir, rel) })).filter((f) => {
+  return rels.map((rel) => ({ rel, abs: join144(projectDir, rel) })).filter((f) => {
     try {
       return statSync39(f.abs).isFile();
     } catch {
@@ -278991,7 +279234,7 @@ function existingTextFiles(projectDir, rels) {
 function walkTextFiles(projectDir, relDir, extensions) {
   const out3 = [];
   const walk2 = (dirRel) => {
-    const dirAbs = join143(projectDir, dirRel);
+    const dirAbs = join144(projectDir, dirRel);
     let entries;
     try {
       entries = readdirSync49(dirAbs, { withFileTypes: true });
@@ -278999,7 +279242,7 @@ function walkTextFiles(projectDir, relDir, extensions) {
       return;
     }
     for (const entry of entries) {
-      const rel = join143(dirRel, entry.name);
+      const rel = join144(dirRel, entry.name);
       if (entry.isDirectory()) {
         walk2(rel);
         continue;
@@ -279007,7 +279250,7 @@ function walkTextFiles(projectDir, relDir, extensions) {
       const dot = entry.name.lastIndexOf(".");
       const ext = dot === -1 ? "" : entry.name.slice(dot);
       if (entry.isFile() && extensions.has(ext))
-        out3.push({ rel, abs: join143(projectDir, rel) });
+        out3.push({ rel, abs: join144(projectDir, rel) });
     }
   };
   walk2(relDir);
@@ -279134,13 +279377,13 @@ var nodeFreshnessPort3 = {
   },
   readText(absPath) {
     try {
-      return readFileSync128(absPath, "utf8");
+      return readFileSync129(absPath, "utf8");
     } catch {
       return "";
     }
   },
   writeText(absPath, text2) {
-    mkdirSync70(dirname69(absPath), { recursive: true });
+    mkdirSync70(dirname70(absPath), { recursive: true });
     writeFileSync70(absPath, text2, "utf8");
   }
 };
@@ -279179,13 +279422,13 @@ function mergeShasFromStatus(status2) {
   return shas;
 }
 function findCardSpec(projectDir, id) {
-  const featuresDir = join143(projectDir, ".roll", "features");
+  const featuresDir = join144(projectDir, ".roll", "features");
   try {
     for (const epic of readdirSync49(featuresDir, { withFileTypes: true })) {
       if (!epic.isDirectory())
         continue;
-      const spec = join143(featuresDir, epic.name, id, "spec.md");
-      if (existsSync127(spec))
+      const spec = join144(featuresDir, epic.name, id, "spec.md");
+      if (existsSync128(spec))
         return spec;
     }
   } catch {
@@ -279203,13 +279446,13 @@ function cardChangelogExempt(projectDir, id) {
   }
 }
 function checkFeaturesCatalog(projectDir) {
-  const backlog = join143(projectDir, ".roll", "backlog.md");
-  if (!existsSync127(backlog))
+  const backlog = join144(projectDir, ".roll", "backlog.md");
+  if (!existsSync128(backlog))
     return { status: "pass", gaps: [] };
   const backlogText = readText(backlog);
   const gaps = [];
-  const features = join143(projectDir, ".roll", "features.md");
-  if (existsSync127(features)) {
+  const features = join144(projectDir, ".roll", "features.md");
+  if (existsSync128(features)) {
     const featuresText = readText(features);
     for (const featName of readDoneFeatures(backlogText).keys()) {
       const escaped = escapeRegExp4(featName);
@@ -279232,8 +279475,8 @@ function checkFeaturesCatalog(projectDir) {
   return { status: gaps.length === 0 ? "pass" : "fail", gaps };
 }
 function checkTruthLive(projectDir) {
-  const backlog = join143(projectDir, ".roll", "backlog.md");
-  if (!existsSync127(backlog))
+  const backlog = join144(projectDir, ".roll", "backlog.md");
+  if (!existsSync128(backlog))
     return { status: "pass", gaps: [] };
   const backlogText = readText(backlog);
   const facts = backlogRowFacts(backlogText);
@@ -279269,19 +279512,19 @@ function checkTruthLive(projectDir) {
   return { status: gaps.length === 0 ? "pass" : "fail", gaps };
 }
 function checkCards(projectDir) {
-  const backlog = join143(projectDir, ".roll", "backlog.md");
-  const featuresDir = join143(projectDir, ".roll", "features");
-  if (!existsSync127(backlog) || !existsSync127(featuresDir))
+  const backlog = join144(projectDir, ".roll", "backlog.md");
+  const featuresDir = join144(projectDir, ".roll", "features");
+  if (!existsSync128(backlog) || !existsSync128(featuresDir))
     return { status: "pass", gaps: [] };
   const cardEpic = /* @__PURE__ */ new Map();
   try {
     for (const epic of readdirSync49(featuresDir, { withFileTypes: true })) {
       if (!epic.isDirectory())
         continue;
-      for (const card of readdirSync49(join143(featuresDir, epic.name), { withFileTypes: true })) {
+      for (const card of readdirSync49(join144(featuresDir, epic.name), { withFileTypes: true })) {
         if (!card.isDirectory())
           continue;
-        if (existsSync127(join143(featuresDir, epic.name, card.name, "spec.md")) && !cardEpic.has(card.name)) {
+        if (existsSync128(join144(featuresDir, epic.name, card.name, "spec.md")) && !cardEpic.has(card.name)) {
           cardEpic.set(card.name, epic.name);
         }
       }
@@ -279291,7 +279534,7 @@ function checkCards(projectDir) {
   }
   const hasAcBlock = (epic, id) => {
     try {
-      const text2 = readText(join143(featuresDir, epic, id, "spec.md"));
+      const text2 = readText(join144(featuresDir, epic, id, "spec.md"));
       return acForStory(text2, id, { fileOwned: true }).length > 0;
     } catch {
       return true;
@@ -279316,12 +279559,12 @@ function checkCards(projectDir) {
     const ev = /\[evidence\]\(([^)]+)\)/.exec(line);
     if (ev !== null) {
       const target = (ev[1] ?? "").replace(/^\.roll\//, "");
-      if (!existsSync127(join143(projectDir, ".roll", target))) {
+      if (!existsSync128(join144(projectDir, ".roll", target))) {
         gaps.push(`Backlog row ${id} evidence link is broken: ${ev[1] ?? ""}`);
       }
     } else if (line.includes(STATUS_MARKER.done)) {
       const epic = cardEpic.get(id) ?? "";
-      if (!existsSync127(join143(featuresDir, epic, id, "latest", `${id}-report.html`))) {
+      if (!existsSync128(join144(featuresDir, epic, id, "latest", `${id}-report.html`))) {
         if (hasAcBlock(epic, id)) {
           gaps.push(`Done backlog row ${id} has ACs but no attest report`);
         } else {
@@ -279343,8 +279586,8 @@ function checkCards(projectDir) {
 }
 function checkDocs(projectDir) {
   const gaps = checkTopLevelCommands(activeDocsFiles(projectDir), DOC_RETIRED_TOP_LEVEL_COMMANDS);
-  const changelogPath = join143(projectDir, "CHANGELOG.md");
-  if (existsSync127(changelogPath)) {
+  const changelogPath = join144(projectDir, "CHANGELOG.md");
+  if (existsSync128(changelogPath)) {
     const changelog = readText(changelogPath);
     for (const id of releaseDeltaCardIds(projectDir)) {
       const base = id.replace(/[a-z]$/, "");
@@ -279417,9 +279660,9 @@ function siteTokens(name) {
 }
 function checkSite(projectDir) {
   const gaps = checkTopLevelCommands(activeSiteFiles(projectDir), SITE_HIDDEN_TOP_LEVEL_COMMANDS);
-  const siteJs = join143(projectDir, "site", "roll-data.js");
-  const backlog = join143(projectDir, ".roll", "backlog.md");
-  if (!existsSync127(siteJs) || !existsSync127(backlog))
+  const siteJs = join144(projectDir, "site", "roll-data.js");
+  const backlog = join144(projectDir, ".roll", "backlog.md");
+  if (!existsSync128(siteJs) || !existsSync128(backlog))
     return { status: gaps.length === 0 ? "pass" : "fail", gaps };
   const siteText = readText(siteJs);
   const seenGuideRefs = /* @__PURE__ */ new Set();
@@ -279428,7 +279671,7 @@ function checkSite(projectDir) {
     if (seenGuideRefs.has(rel))
       continue;
     seenGuideRefs.add(rel);
-    if (!existsSync127(join143(projectDir, rel))) {
+    if (!existsSync128(join144(projectDir, rel))) {
       gaps.push(`site/roll-data.js links a guide that does not exist: ${rel}`);
     }
   }
@@ -279469,7 +279712,7 @@ function listFiles2(dir) {
   try {
     return readdirSync49(dir).filter((n) => {
       try {
-        return statSync39(join143(dir, n)).isFile();
+        return statSync39(join144(dir, n)).isFile();
       } catch {
         return false;
       }
@@ -279480,9 +279723,9 @@ function listFiles2(dir) {
 }
 function checkI18n(projectDir) {
   const gaps = [];
-  const guideEn = join143(projectDir, "guide", "en");
-  const guideZh = join143(projectDir, "guide", "zh");
-  if (existsSync127(guideEn) && existsSync127(guideZh)) {
+  const guideEn = join144(projectDir, "guide", "en");
+  const guideZh = join144(projectDir, "guide", "zh");
+  if (existsSync128(guideEn) && existsSync128(guideZh)) {
     const enFiles = new Set(listFiles2(guideEn));
     const zhFiles = new Set(listFiles2(guideZh));
     const enOnly = [...enFiles].filter((f) => !zhFiles.has(f)).sort();
@@ -279492,8 +279735,8 @@ function checkI18n(projectDir) {
     for (const f of zhOnly)
       gaps.push(`guide/zh/${f} has no corresponding guide/en/${f}`);
   }
-  const i18nDir = join143(projectDir, "lib", "i18n");
-  if (existsSync127(i18nDir)) {
+  const i18nDir = join144(projectDir, "lib", "i18n");
+  if (existsSync128(i18nDir)) {
     const keysEn = /* @__PURE__ */ new Set();
     const keysZh = /* @__PURE__ */ new Set();
     let shFiles = [];
@@ -279503,7 +279746,7 @@ function checkI18n(projectDir) {
       shFiles = [];
     }
     for (const name of shFiles) {
-      const text2 = readText(join143(i18nDir, name));
+      const text2 = readText(join144(i18nDir, name));
       for (const m7 of text2.matchAll(/_i18n_set\s+(en|zh)\s+([^\s]+)/g)) {
         const lang10 = m7[1];
         const key = m7[2] ?? "";
@@ -279543,7 +279786,7 @@ function rglobBats(dir) {
       return;
     }
     for (const e of entries) {
-      const full = join143(d, e);
+      const full = join144(d, e);
       let st;
       try {
         st = statSync39(full);
@@ -279561,9 +279804,9 @@ function rglobBats(dir) {
 }
 function checkTests(projectDir) {
   const gaps = [];
-  const backlog = join143(projectDir, ".roll", "backlog.md");
-  const testsDir = join143(projectDir, "tests");
-  if (!existsSync127(backlog))
+  const backlog = join144(projectDir, ".roll", "backlog.md");
+  const testsDir = join144(projectDir, "tests");
+  if (!existsSync128(backlog))
     return { status: "pass", gaps: [] };
   const backlogText = readText(backlog);
   const allFeatures = /* @__PURE__ */ new Set();
@@ -279588,7 +279831,7 @@ function checkTests(projectDir) {
         doneFeatures.push(currentFeature);
     }
   }
-  const testFiles = existsSync127(testsDir) ? rglobBats(testsDir) : [];
+  const testFiles = existsSync128(testsDir) ? rglobBats(testsDir) : [];
   if (testFiles.length === 0)
     return { status: "pass", gaps: [] };
   for (const feat of doneFeatures) {
@@ -279933,17 +280176,17 @@ function writeReleaseTestProof(exec) {
   const cwd = exec("git", ["rev-parse", "--show-toplevel"]).trim();
   const tree = exec("git", ["write-tree"]).trim();
   const ts2 = Math.floor(Date.now() / 1e3);
-  const proofPath = join145(cwd, ".roll", "last-test-pass");
-  mkdirSync72(dirname71(proofPath), { recursive: true });
+  const proofPath = join146(cwd, ".roll", "last-test-pass");
+  mkdirSync72(dirname72(proofPath), { recursive: true });
   writeFileSync72(proofPath, JSON.stringify({ ts: ts2, tree, mode: "release", scope: "affected" }), "utf8");
 }
 function assertTestProofFresh(exec) {
   const cwd = exec("git", ["rev-parse", "--show-toplevel"]).trim();
-  const proofPath = join145(cwd, ".roll", "last-test-pass");
-  if (!existsSync129(proofPath)) {
+  const proofPath = join146(cwd, ".roll", "last-test-pass");
+  if (!existsSync130(proofPath)) {
     throw new Error("test-pass proof missing \u2014 run `roll test` before committing");
   }
-  const body = readFileSync130(proofPath, "utf8");
+  const body = readFileSync131(proofPath, "utf8");
   const tsMatch = /"ts":(\d+)/.exec(body);
   const treeMatch = /"tree":"([^"]*)"/.exec(body);
   const ts2 = tsMatch ? Number(tsMatch[1]) : NaN;
@@ -280020,7 +280263,7 @@ function realReleaseDeps() {
   return {
     version: (cwd) => {
       try {
-        const pkg = JSON.parse(readFileSync130(join145(cwd, "package.json"), "utf8"));
+        const pkg = JSON.parse(readFileSync131(join146(cwd, "package.json"), "utf8"));
         return typeof pkg.version === "string" ? pkg.version : "";
       } catch {
         return "";
@@ -280055,11 +280298,11 @@ function realReleaseDeps() {
         return true;
       }
     },
-    readChangelog: (cwd) => readFileSync130(join145(cwd, "CHANGELOG.md"), "utf8"),
-    writeChangelog: (cwd, text2) => writeFileSync72(join145(cwd, "CHANGELOG.md"), text2, "utf8"),
+    readChangelog: (cwd) => readFileSync131(join146(cwd, "CHANGELOG.md"), "utf8"),
+    writeChangelog: (cwd, text2) => writeFileSync72(join146(cwd, "CHANGELOG.md"), text2, "utf8"),
     bumpVersion: (cwd, version) => {
-      const path = join145(cwd, "package.json");
-      const pkg = JSON.parse(readFileSync130(path, "utf8"));
+      const path = join146(cwd, "package.json");
+      const pkg = JSON.parse(readFileSync131(path, "utf8"));
       pkg["version"] = version;
       writeFileSync72(path, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
@@ -280076,7 +280319,7 @@ function realReleaseDeps() {
       commitPushWithGate({
         branch,
         message,
-        rollManaged: existsSync129(join145(cwd, ".roll")),
+        rollManaged: existsSync130(join146(cwd, ".roll")),
         exec: (cmd, args) => execFileSync33(cmd, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 6e5 })
       });
     },
@@ -280169,7 +280412,7 @@ function realReleaseDeps() {
     recordReleaseFact: (cwd, tagName) => {
       try {
         const runtimeDir12 = (process.env["ROLL_PROJECT_RUNTIME_DIR"] ?? "").trim();
-        const eventsPath4 = runtimeDir12 !== "" ? join145(runtimeDir12, EVENTS_FILE) : join145(cwd, ".roll", "loop", EVENTS_FILE);
+        const eventsPath4 = runtimeDir12 !== "" ? join146(runtimeDir12, EVENTS_FILE) : join146(cwd, ".roll", "loop", EVENTS_FILE);
         new EventBus().appendEvent(eventsPath4, {
           type: "release:gate",
           tag: tagName,
@@ -280398,15 +280641,15 @@ ${c("dim", "\u2192 Running the golden-path showcase (real models; its verdict do
 init_dist();
 init_render();
 import { spawnSync as spawnSync19 } from "node:child_process";
-import { existsSync as existsSync131, lstatSync as lstatSync12, mkdirSync as mkdirSync74, readFileSync as readFileSync132, readdirSync as readdirSync52, readlinkSync as readlinkSync3, statSync as statSync42 } from "node:fs";
-import { join as join147 } from "node:path";
+import { existsSync as existsSync132, lstatSync as lstatSync12, mkdirSync as mkdirSync74, readFileSync as readFileSync133, readdirSync as readdirSync52, readlinkSync as readlinkSync3, statSync as statSync42 } from "node:fs";
+import { join as join148 } from "node:path";
 
 // packages/cli/dist/lib/roll-capture-install.js
 init_dist();
 import { spawnSync as spawnSync18 } from "node:child_process";
-import { chmodSync as chmodSync2, existsSync as existsSync130, lstatSync as lstatSync11, mkdirSync as mkdirSync73, mkdtempSync as mkdtempSync10, readdirSync as readdirSync51, readFileSync as readFileSync131, renameSync as renameSync26, rmSync as rmSync24, statSync as statSync41, writeFileSync as writeFileSync73 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync131, lstatSync as lstatSync11, mkdirSync as mkdirSync73, mkdtempSync as mkdtempSync10, readdirSync as readdirSync51, readFileSync as readFileSync132, renameSync as renameSync26, rmSync as rmSync25, statSync as statSync41, writeFileSync as writeFileSync73 } from "node:fs";
 import { homedir as homedir31 } from "node:os";
-import { join as join146 } from "node:path";
+import { join as join147 } from "node:path";
 var RELEASE_API = "https://api.github.com/repos/seanyao/roll-capture/releases/latest";
 var ASSET_NAME = "Roll-Capture.app.zip";
 var APP_NAME2 = "Roll Capture.app";
@@ -280431,7 +280674,7 @@ function defaultRollCaptureInstallDeps() {
     home: homedir31(),
     uid: typeof process.getuid === "function" ? process.getuid() : void 0,
     ...platform3 === "darwin" && !isCi2(process.env) && process.env["ROLL_SKIP_CAPTURE_INSTALL"] !== "1" ? { hasAquaGUI: macosHasAquaGUI3(execFile18) } : {},
-    exists: existsSync130,
+    exists: existsSync131,
     renamePath: renameSync26,
     execFile: execFile18,
     fetchLatestRelease: (timeoutMs) => defaultFetchLatestRelease(timeoutMs, process.env, execFile18),
@@ -280478,12 +280721,12 @@ async function installRollCapture(deps = defaultRollCaptureInstallDeps()) {
   if (bytes.byteLength !== asset.size) {
     return manual(`download size mismatch: expected ${asset.size} bytes, got ${bytes.byteLength}`, release.tagName);
   }
-  const applicationsDir = join146(deps.home, "Applications");
-  const targetApp = join146(applicationsDir, APP_NAME2);
+  const applicationsDir = join147(deps.home, "Applications");
+  const targetApp = join147(applicationsDir, APP_NAME2);
   mkdirSync73(applicationsDir, { recursive: true });
-  const workDir = mkdtempSync10(join146(applicationsDir, ".roll-capture-install-"));
-  const zipPath = join146(workDir, ASSET_NAME);
-  const extractDir = join146(workDir, "extract");
+  const workDir = mkdtempSync10(join147(applicationsDir, ".roll-capture-install-"));
+  const zipPath = join147(workDir, ASSET_NAME);
+  const extractDir = join147(workDir, "extract");
   try {
     mkdirSync73(extractDir, { recursive: true });
     writeFileSync73(zipPath, bytes);
@@ -280503,7 +280746,7 @@ async function installRollCapture(deps = defaultRollCaptureInstallDeps()) {
   } catch (error) {
     return manual(`install failed: ${errorMessage(error)}`, release.tagName);
   } finally {
-    rmSync24(workDir, { recursive: true, force: true });
+    rmSync25(workDir, { recursive: true, force: true });
   }
 }
 function renderRollCaptureInstallResult(result, lang10) {
@@ -280640,7 +280883,7 @@ function macosHasAquaGUI3(execFile18) {
 function findExtractedApp(dir) {
   try {
     for (const name of readdirSync51(dir)) {
-      const candidate = join146(dir, name);
+      const candidate = join147(dir, name);
       const st = lstatSync11(candidate);
       if (st.isSymbolicLink())
         continue;
@@ -280658,10 +280901,10 @@ function findExtractedApp(dir) {
   return null;
 }
 function findBundleExecutable(appPath) {
-  const macosDir = join146(appPath, "Contents", "MacOS");
+  const macosDir = join147(appPath, "Contents", "MacOS");
   try {
     for (const name of readdirSync51(macosDir)) {
-      const candidate = join146(macosDir, name);
+      const candidate = join147(macosDir, name);
       const st = lstatSync11(candidate);
       if (st.isSymbolicLink())
         continue;
@@ -280677,7 +280920,7 @@ function replaceAppAtomically(app, targetApp, deps) {
   const renamePath = deps.renamePath ?? renameSync26;
   const backupApp = `${targetApp}.bak`;
   const hadExisting = lstatExists(targetApp);
-  rmSync24(backupApp, { recursive: true, force: true });
+  rmSync25(backupApp, { recursive: true, force: true });
   if (!hadExisting) {
     renamePath(app, targetApp);
     return;
@@ -280689,10 +280932,10 @@ function replaceAppAtomically(app, targetApp, deps) {
     backupCreated = true;
     renamePath(app, targetApp);
     targetReplaced = true;
-    rmSync24(backupApp, { recursive: true, force: true });
+    rmSync25(backupApp, { recursive: true, force: true });
   } catch (error) {
     if (targetReplaced)
-      rmSync24(targetApp, { recursive: true, force: true });
+      rmSync25(targetApp, { recursive: true, force: true });
     if (backupCreated) {
       try {
         renamePath(backupApp, targetApp);
@@ -280744,13 +280987,13 @@ function enableNodeGlobalProxyFromEnv(env) {
   }
 }
 function readInstalledVersion(appPath, deps) {
-  const plistPath = join146(appPath, "Contents", "Info.plist");
+  const plistPath = join147(appPath, "Contents", "Info.plist");
   const plutil = deps.execFile("plutil", ["-extract", "CFBundleShortVersionString", "raw", "-o", "-", plistPath]);
   const raw = plutil.code === 0 ? plutil.stdout.trim() : "";
   if (raw !== "")
     return raw;
   try {
-    const text2 = readFileSync131(plistPath, "utf8");
+    const text2 = readFileSync132(plistPath, "utf8");
     const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(text2);
     return match?.[1];
   } catch {
@@ -280778,7 +281021,7 @@ function manual(reason, releaseTag) {
 }
 function renderEn(result) {
   if (result.status === "installed") {
-    return `Roll Capture.app installed at ${result.appPath ?? join146("~", "Applications", APP_NAME2)}; open it once and grant Screen Recording permission.`;
+    return `Roll Capture.app installed at ${result.appPath ?? join147("~", "Applications", APP_NAME2)}; open it once and grant Screen Recording permission.`;
   }
   if (result.status === "already-installed") {
     const update = result.updateAvailable === true && result.releaseTag !== void 0 ? `; newer release ${result.releaseTag} is available` : "";
@@ -280790,7 +281033,7 @@ function renderEn(result) {
 }
 function renderZh(result) {
   if (result.status === "installed") {
-    return `Roll Capture.app \u5DF2\u5B89\u88C5\u5230 ${result.appPath ?? join146("~", "Applications", APP_NAME2)}\uFF1B\u8BF7\u6253\u5F00\u4E00\u6B21\u5E76\u6388\u4E88\u5C4F\u5E55\u5F55\u5236\u6743\u9650\u3002`;
+    return `Roll Capture.app \u5DF2\u5B89\u88C5\u5230 ${result.appPath ?? join147("~", "Applications", APP_NAME2)}\uFF1B\u8BF7\u6253\u5F00\u4E00\u6B21\u5E76\u6388\u4E88\u5C4F\u5E55\u5F55\u5236\u6743\u9650\u3002`;
   }
   if (result.status === "already-installed") {
     const update = result.updateAvailable === true && result.releaseTag !== void 0 ? `\uFF1B\u6709\u65B0\u7248 ${result.releaseTag} \u53EF\u7528` : "";
@@ -280873,7 +281116,7 @@ function walk(dir, lines3) {
     return;
   }
   for (const name of names) {
-    const p = join147(dir, name);
+    const p = join148(dir, name);
     let isLink = false;
     try {
       isLink = lstatSync12(p).isSymbolicLink();
@@ -280903,7 +281146,7 @@ function walk(dir, lines3) {
 }
 function fileFingerprint(p) {
   try {
-    const buf = readFileSync132(p);
+    const buf = readFileSync133(p);
     let sum = 0;
     for (let i = 0; i < buf.length; i++)
       sum = sum * 31 + (buf[i] ?? 0) >>> 0;
@@ -280933,18 +281176,18 @@ function ensureHooksPath(repoPath) {
   }
 }
 function peerEnsureStateDir() {
-  const base = join147(rollHome(), ".peer-state");
+  const base = join148(rollHome(), ".peer-state");
   mkdirSync74(base, { recursive: true });
-  mkdirSync74(join147(base, "logs"), { recursive: true });
+  mkdirSync74(join148(base, "logs"), { recursive: true });
 }
 function tmuxPresent() {
   return onPath("tmux");
 }
 function submoduleGuard() {
   const pkg = rollPkgDir();
-  const skills = join147(pkg, "skills");
-  const hasGit = existsSync131(join147(pkg, ".git"));
-  const hasMods = existsSync131(join147(pkg, ".gitmodules"));
+  const skills = join148(pkg, "skills");
+  const hasGit = existsSync132(join148(pkg, ".git"));
+  const hasMods = existsSync132(join148(pkg, ".gitmodules"));
   let empty = true;
   try {
     empty = readdirSync52(skills).length === 0;
@@ -281061,7 +281304,7 @@ async function setupCommand(args) {
       return 1;
     }
   }
-  if (!existsSync131(rollPkgConventions())) {
+  if (!existsSync132(rollPkgConventions())) {
     err13(m5("shared.convention_source_not_found_at_2", rollPkgConventions()));
     err13(m5("shared.run_this_from_the_roll_repo"));
     return 1;
@@ -281070,7 +281313,7 @@ async function setupCommand(args) {
   const home = rollHome();
   const aiDirsList = [".claude", ".kimi", ".kimi-code", ".codex", ".pi", ".agentrules", ".reasonix"];
   const homeDir = process.env["HOME"] ?? "";
-  const aiDirs = aiDirsList.map((d) => join147(homeDir, d)).join(":");
+  const aiDirs = aiDirsList.map((d) => join148(homeDir, d)).join(":");
   const steps = [];
   const s1 = runSetupStep(home, () => {
     installLocal(force);
@@ -281084,7 +281327,7 @@ async function setupCommand(args) {
     syncSkills(force);
   });
   steps.push({ num: 3, label: "Install skills to ~/.claude", status: stateToMarker(s3, force) });
-  const s4 = runSetupStep(join147(home, ".peer-state"), () => {
+  const s4 = runSetupStep(join148(home, ".peer-state"), () => {
     peerEnsureStateDir();
   });
   steps.push({ num: 4, label: "Initialize peer-review state directory", status: stateToMarker(s4, force) });
@@ -281151,8 +281394,8 @@ init_showcase2();
 
 // packages/cli/dist/commands/test.js
 import { spawnSync as spawnSync20 } from "node:child_process";
-import { appendFileSync as appendFileSync23, existsSync as existsSync132, mkdirSync as mkdirSync75, readFileSync as readFileSync133, rmSync as rmSync25, writeFileSync as writeFileSync74 } from "node:fs";
-import { dirname as dirname72, join as join148, resolve as resolve12 } from "node:path";
+import { appendFileSync as appendFileSync23, existsSync as existsSync133, mkdirSync as mkdirSync75, readFileSync as readFileSync134, rmSync as rmSync26, writeFileSync as writeFileSync74 } from "node:fs";
+import { dirname as dirname73, join as join149, resolve as resolve12 } from "node:path";
 function pal7() {
   const noColor2 = (process.env["NO_COLOR"] ?? "") !== "";
   return noColor2 ? { CYAN: "", GREEN: "", YELLOW: "", RED: "", NC: "" } : { CYAN: "\x1B[0;36m", GREEN: "\x1B[0;32m", YELLOW: "\x1B[0;33m", RED: "\x1B[0;31m", NC: "\x1B[0m" };
@@ -281173,12 +281416,12 @@ function currentEvidenceFrame() {
   if (raw === "")
     return null;
   const runDir = resolve12(raw);
-  if (!existsSync132(runDir))
+  if (!existsSync133(runDir))
     return null;
   const frame = {
     runDir,
-    evidenceDir: join148(runDir, "evidence"),
-    screenshotsDir: join148(runDir, "screenshots")
+    evidenceDir: join149(runDir, "evidence"),
+    screenshotsDir: join149(runDir, "screenshots")
   };
   try {
     mkdirSync75(frame.evidenceDir, { recursive: true });
@@ -281209,7 +281452,7 @@ function appendRollTestEvidence(frame, cmd, argv, status2, stdout, stderr) {
   try {
     const ts2 = (/* @__PURE__ */ new Date()).toISOString();
     const command = [cmd, ...argv];
-    appendFileSync23(join148(frame.evidenceDir, "roll-test-output.log"), [
+    appendFileSync23(join149(frame.evidenceDir, "roll-test-output.log"), [
       `===== roll test ${ts2} exit=${status2} =====`,
       `$ ${command.join(" ")}`,
       "--- stdout ---",
@@ -281218,7 +281461,7 @@ function appendRollTestEvidence(frame, cmd, argv, status2, stdout, stderr) {
       stderr,
       ""
     ].join("\n"), "utf8");
-    appendFileSync23(join148(frame.evidenceDir, "roll-test-summary.txt"), JSON.stringify({
+    appendFileSync23(join149(frame.evidenceDir, "roll-test-summary.txt"), JSON.stringify({
       ts: ts2,
       command,
       exitCode: status2,
@@ -281229,12 +281472,12 @@ function appendRollTestEvidence(frame, cmd, argv, status2, stdout, stderr) {
   }
 }
 function isolationGetType() {
-  const file = join148(process.cwd(), ".roll", "local.yaml");
-  if (!existsSync132(file))
+  const file = join149(process.cwd(), ".roll", "local.yaml");
+  if (!existsSync133(file))
     return "none";
   let text2;
   try {
-    text2 = readFileSync133(file, "utf8");
+    text2 = readFileSync134(file, "utf8");
   } catch {
     return "none";
   }
@@ -281282,19 +281525,19 @@ function resetLockPath() {
   return ".roll/.iso-reset.lock";
 }
 function resetLockHeld() {
-  return existsSync132(resetLockPath());
+  return existsSync133(resetLockPath());
 }
 function resetAcquireLock() {
   const lock = resetLockPath();
-  if (existsSync132(lock))
+  if (existsSync133(lock))
     return false;
-  mkdirSync75(dirname72(lock), { recursive: true });
+  mkdirSync75(dirname73(lock), { recursive: true });
   writeFileSync74(lock, `${process.pid}
 `);
   return true;
 }
 function resetReleaseLock() {
-  rmSync25(resetLockPath(), { force: true });
+  rmSync26(resetLockPath(), { force: true });
 }
 function runForward(cmd, argv) {
   const frame = currentEvidenceFrame();
@@ -281312,15 +281555,15 @@ function runForward(cmd, argv) {
 }
 function ensureSkillsSubmoduleReady() {
   const pkg = rollPkgDir();
-  const required2 = join148(pkg, "skills", "roll-onboard", "SKILL.md");
-  if (existsSync132(required2))
+  const required2 = join149(pkg, "skills", "roll-onboard", "SKILL.md");
+  if (existsSync133(required2))
     return true;
-  if (existsSync132(join148(pkg, ".git")) && existsSync132(join148(pkg, ".gitmodules"))) {
+  if (existsSync133(join149(pkg, ".git")) && existsSync133(join149(pkg, ".gitmodules"))) {
     spawnSync20("git", ["submodule", "update", "--init", "--recursive", "--quiet", "skills"], {
       cwd: pkg,
       stdio: "ignore"
     });
-    if (existsSync132(required2))
+    if (existsSync133(required2))
       return true;
   }
   err14("roll test: skills submodule is empty");
@@ -281329,7 +281572,7 @@ function ensureSkillsSubmoduleReady() {
 }
 function isolationDispatch(method, args) {
   const type = isolationGetType();
-  if (type === "none" && !existsSync132(join148(process.cwd(), ".roll", "local.yaml"))) {
+  if (type === "none" && !existsSync133(join149(process.cwd(), ".roll", "local.yaml"))) {
     infoErr("isolation: no test_isolation config, falling back to type=none (host)");
   }
   if (!SUPPORTED_TYPES.includes(type)) {
@@ -281425,7 +281668,7 @@ function testCommand(args) {
 
 // packages/cli/dist/commands/tool.js
 init_dist2();
-import { join as join149 } from "node:path";
+import { join as join150 } from "node:path";
 var TOOL_USAGE = "Usage: roll tool status\n  Show registered tools, input contracts, effective policy state, and requirement readiness.\n\u5C55\u793A\u5DF2\u6CE8\u518C\u5DE5\u5177\u3001\u5165\u53C2\u5951\u7EA6\u3001\u6709\u6548 policy \u72B6\u6001\u4E0E requirement \u5C31\u7EEA\u5EA6\u3002\n";
 async function toolCommand(args) {
   const sub = args[0] ?? "";
@@ -281443,7 +281686,7 @@ async function toolCommand(args) {
   return 0;
 }
 async function collectToolRows(projectRoot3, requirementResolver = resolveRequirement) {
-  const policy = new ToolPolicyEngine({ policyPath: join149(projectRoot3, ".roll", "policy.yaml") });
+  const policy = new ToolPolicyEngine({ policyPath: join150(projectRoot3, ".roll", "policy.yaml") });
   const rows = [];
   for (const declaration of collectBuiltinToolDeclarations(projectRoot3)) {
     const effective = await policy.resolve(declaration.id, declaration.defaults);
@@ -281505,8 +281748,8 @@ function pad5(value, width) {
 // packages/cli/dist/commands/truth.js
 init_dist();
 init_dist2();
-import { statSync as statSync43, readFileSync as readFileSync134, writeFileSync as writeFileSync75, mkdirSync as mkdirSync76, existsSync as existsSync133 } from "node:fs";
-import { dirname as dirname73, join as join150 } from "node:path";
+import { statSync as statSync43, readFileSync as readFileSync135, writeFileSync as writeFileSync75, mkdirSync as mkdirSync76, existsSync as existsSync134 } from "node:fs";
+import { dirname as dirname74, join as join151 } from "node:path";
 var TRUTH_USAGE = "Usage: roll truth <command>\n  query <storyId>  Deterministic delivery-truth query (structured, zero markdown parse).\n  audit            Bidirectional drift audit: backlog Done \u2194 projection truth.\n\u547D\u4EE4:\n  query <storyId>  \u7ED3\u6784\u5316\u4EA4\u4ED8\u771F\u76F8\u67E5\u8BE2\uFF08\u786E\u5B9A\u6027\uFF0C\u4E0D\u89E3\u6790 markdown\uFF09\n  audit            \u53CC\u5411\u6F02\u79FB\u5BA1\u8BA1\uFF1Abacklog Done \u2194 \u6295\u5F71\u771F\u76F8";
 function formatTruth(t2, lang10) {
   const lines3 = [];
@@ -281538,13 +281781,13 @@ var nodeFreshnessPort4 = {
   },
   readText(absPath) {
     try {
-      return readFileSync134(absPath, "utf8");
+      return readFileSync135(absPath, "utf8");
     } catch {
       return "";
     }
   },
   writeText(absPath, text2) {
-    mkdirSync76(dirname73(absPath), { recursive: true });
+    mkdirSync76(dirname74(absPath), { recursive: true });
     writeFileSync75(absPath, text2, "utf8");
   }
 };
@@ -281552,8 +281795,8 @@ function truthAuditCommand(args, lang10) {
   const json = args.includes("--json");
   const cwd = process.cwd();
   const nowSec2 = Math.floor(Date.now() / 1e3);
-  const backlogPath = join150(cwd, ".roll", "backlog.md");
-  const backlogRows = existsSync133(backlogPath) ? parseBacklog(readFileSync134(backlogPath, "utf8")).map((r) => ({ id: r.id, status: r.status })) : [];
+  const backlogPath = join151(cwd, ".roll", "backlog.md");
+  const backlogRows = existsSync134(backlogPath) ? parseBacklog(readFileSync135(backlogPath, "utf8")).map((r) => ({ id: r.id, status: r.status })) : [];
   const deliveries = ensureDeliveriesFresh(cwd, nodeFreshnessPort4, nodeExecPort);
   const snapshot = emptyAuditSnapshot(nowSec2, TERMINAL_SCHEMA_EPOCH_SEC);
   snapshot.backlog = backlogRows;
@@ -281638,8 +281881,8 @@ function truthCommand(args) {
 
 // packages/cli/dist/commands/tune.js
 init_dist2();
-import { existsSync as existsSync134, readFileSync as readFileSync135 } from "node:fs";
-import { join as join151 } from "node:path";
+import { existsSync as existsSync135, readFileSync as readFileSync136 } from "node:fs";
+import { join as join152 } from "node:path";
 function projectPath2() {
   return (process.env["ROLL_MAIN_PROJECT"] ?? "").trim() || process.cwd();
 }
@@ -281647,11 +281890,11 @@ function str6(v, dflt = "") {
   return typeof v === "string" ? v : dflt;
 }
 function parseJsonl(path) {
-  if (!existsSync134(path))
+  if (!existsSync135(path))
     return [];
   let text2;
   try {
-    text2 = readFileSync135(path, "utf8");
+    text2 = readFileSync136(path, "utf8");
   } catch {
     return [];
   }
@@ -281782,9 +282025,9 @@ function tuneCommand(argv) {
   if (argv[0] === "reset")
     return printReset();
   const proj = projectPath2();
-  const loopDir2 = join151(proj, ".roll", "loop");
-  const runs = parseJsonl(join151(loopDir2, "runs.jsonl"));
-  const events = parseJsonl(join151(loopDir2, "events.ndjson"));
+  const loopDir2 = join152(proj, ".roll", "loop");
+  const runs = parseJsonl(join152(loopDir2, "runs.jsonl"));
+  const events = parseJsonl(join152(loopDir2, "events.ndjson"));
   const minSamplesRaw = flag(argv, "--min-samples");
   const now2 = flag(argv, "--now") ?? (/* @__PURE__ */ new Date()).toISOString();
   const input = {
@@ -281823,9 +282066,9 @@ function tuneCommand(argv) {
 // packages/cli/dist/commands/update.js
 init_dist();
 import { spawnSync as spawnSync21 } from "node:child_process";
-import { existsSync as existsSync135, mkdtempSync as mkdtempSync11, readFileSync as readFileSync136, rmSync as rmSync26 } from "node:fs";
+import { existsSync as existsSync136, mkdtempSync as mkdtempSync11, readFileSync as readFileSync137, rmSync as rmSync27 } from "node:fs";
 import { tmpdir as tmpdir13 } from "node:os";
-import { join as join152 } from "node:path";
+import { join as join153 } from "node:path";
 function pal8() {
   const noColor2 = (process.env["NO_COLOR"] ?? "") !== "";
   return noColor2 ? { CYAN: "", GREEN: "", YELLOW: "", RED: "", BOLD: "", NC: "" } : {
@@ -281889,20 +282132,20 @@ function resolveRemoteVersion() {
 }
 function downloadAndInstallCurl(tag) {
   const url = `https://github.com/seanyao/roll/archive/refs/tags/${tag}.tar.gz`;
-  const tmpDir = mkdtempSync11(join152(tmpdir13(), "roll-update-"));
+  const tmpDir = mkdtempSync11(join153(tmpdir13(), "roll-update-"));
   try {
     info5(`[roll] Downloading roll ${tag} ...`);
-    const dl = runForward2("curl", ["-fsSL", url, "-o", join152(tmpDir, "roll.tar.gz")]);
+    const dl = runForward2("curl", ["-fsSL", url, "-o", join153(tmpDir, "roll.tar.gz")]);
     if (dl !== 0) {
       err15(m6("update.curl_download_failed"));
       return { ok: false };
     }
     info5("[roll] Extracting ...");
-    const extractDir = join152(tmpDir, "extract");
+    const extractDir = join153(tmpDir, "extract");
     spawnSync21("mkdir", ["-p", extractDir], { stdio: "ignore" });
     const ex = runForward2("tar", [
       "-xzf",
-      join152(tmpDir, "roll.tar.gz"),
+      join153(tmpDir, "roll.tar.gz"),
       "--strip-components=1",
       "-C",
       extractDir
@@ -281913,13 +282156,13 @@ function downloadAndInstallCurl(tag) {
     }
     return { ok: true, newVersion: treeVersion(extractDir) };
   } finally {
-    rmSync26(tmpDir, { recursive: true, force: true });
+    rmSync27(tmpDir, { recursive: true, force: true });
   }
 }
 function checkInstalledVersionOrRetry() {
   const expected = (spawnSync21("npm", ["view", "@seanyao/roll", "version"], { encoding: "utf8" }).stdout ?? "").trim();
   const pkgRoot = (spawnSync21("npm", ["root", "-g"], { encoding: "utf8" }).stdout ?? "").trim();
-  const installedTree = join152(pkgRoot, "@seanyao", "roll");
+  const installedTree = join153(pkgRoot, "@seanyao", "roll");
   const installed = treeVersion(installedTree);
   if (expected === "" || installed === "")
     return;
@@ -281933,18 +282176,18 @@ function checkInstalledVersionOrRetry() {
   }
 }
 function invalidateUpdateCache() {
-  rmSync26(join152(rollHome(), ".update-check"), { force: true });
+  rmSync27(join153(rollHome(), ".update-check"), { force: true });
 }
 function showChangelog() {
-  const changelog = join152(rollPkgDir(), "CHANGELOG.md");
-  if (!existsSync135(changelog))
+  const changelog = join153(rollPkgDir(), "CHANGELOG.md");
+  if (!existsSync136(changelog))
     return;
   const { BOLD: BOLD2, CYAN, NC } = pal8();
   process.stdout.write(`${BOLD2}${m6("changelog.heading")}:${NC}
 `);
   let count = 0;
   let inSection = false;
-  for (const line of readFileSync136(changelog, "utf8").split("\n")) {
+  for (const line of readFileSync137(changelog, "utf8").split("\n")) {
     if (/^## /.test(line)) {
       count += 1;
       if (count > 3)
@@ -281967,9 +282210,9 @@ async function updateCommand(args) {
   }
   info5(m6("update.current_version", rollVersion()));
   let installMethod = "npm";
-  const methodFile = join152(rollPkgDir(), ".install-method");
-  if (existsSync135(methodFile)) {
-    installMethod = readFileSync136(methodFile, "utf8").trim() || "npm";
+  const methodFile = join153(rollPkgDir(), ".install-method");
+  if (existsSync136(methodFile)) {
+    installMethod = readFileSync137(methodFile, "utf8").trim() || "npm";
   }
   if (installMethod === "curl") {
     info5(m6("update.upgrading_via_curl"));
@@ -282005,9 +282248,9 @@ async function updateCommand(args) {
 
 // packages/cli/dist/commands/worktree-audit.js
 import { execFileSync as execFileSync34 } from "node:child_process";
-import { readFileSync as readFileSync137 } from "node:fs";
+import { readFileSync as readFileSync138 } from "node:fs";
 import { homedir as homedir32 } from "node:os";
-import { basename as basename20, dirname as dirname74, join as join153, relative as relative12, resolve as resolve13 } from "node:path";
+import { basename as basename20, dirname as dirname75, join as join154, relative as relative12, resolve as resolve13 } from "node:path";
 function git5(args, cwd) {
   try {
     return execFileSync34("git", args, {
@@ -282022,7 +282265,7 @@ function git5(args, cwd) {
 }
 function readFileSafe(p) {
   try {
-    return readFileSync137(p, "utf8");
+    return readFileSync138(p, "utf8");
   } catch {
     return null;
   }
@@ -282033,7 +282276,7 @@ function classifyOwner(absPath, repoRoot3) {
   const rp = resolve13(absPath);
   if (rp.startsWith(loopRoot + "/") || rp === loopRoot)
     return "loop";
-  const repoParent = dirname74(resolve13(repoRoot3));
+  const repoParent = dirname75(resolve13(repoRoot3));
   const rel = relative12(repoParent, rp);
   if (!rel.startsWith("..")) {
     const name = basename20(rp);
@@ -282142,7 +282385,7 @@ function countAhead(wtPath, deps) {
 function isActiveCycle(cycleId, repoRoot3, deps) {
   if (!cycleId)
     return false;
-  const lockPath2 = join153(repoRoot3, ".roll", "loop", "inner.lock");
+  const lockPath2 = join154(repoRoot3, ".roll", "loop", "inner.lock");
   const lock = deps.readFile ? deps.readFile(lockPath2) : readFileSafe(lockPath2);
   if (lock) {
     for (const line of lock.split("\n")) {
@@ -282153,7 +282396,7 @@ function isActiveCycle(cycleId, repoRoot3, deps) {
   const nowSec2 = deps.nowSec?.() ?? Math.floor(Date.now() / 1e3);
   const HEARTBEAT_STALE_SEC = 300;
   try {
-    const heartbeatPath = join153(repoRoot3, ".roll", "loop", "heartbeat");
+    const heartbeatPath = join154(repoRoot3, ".roll", "loop", "heartbeat");
     const hb = deps.readFile ? deps.readFile(heartbeatPath) : readFileSafe(heartbeatPath);
     if (hb) {
       for (const line of hb.split("\n")) {
@@ -282209,7 +282452,7 @@ function classifyDisposition(rec) {
 function auditWorktrees(deps) {
   const repoRoot3 = resolve13(deps.repoRoot);
   const wtOutput = deps.git ? deps.git(["worktree", "list", "--porcelain"], repoRoot3) : git5(["worktree", "list", "--porcelain"], repoRoot3);
-  const eventsPath4 = join153(repoRoot3, ".roll", "loop", "events.ndjson");
+  const eventsPath4 = join154(repoRoot3, ".roll", "loop", "events.ndjson");
   const cycles = readCycleContext(eventsPath4, deps);
   const entries = [];
   let current = {};