gossipcat 0.4.30 → 0.5.2

package/dist-mcp/mcp-server.js

@@ -734,8 +734,8 @@ var init_agent_registry = __esm({
       setPerformanceReader(reader) {
         this.perfReader = reader;
       }
-      setSuggesterCache(cache2) {
-        this.suggesterCache = cache2;
+      setSuggesterCache(cache3) {
+        this.suggesterCache = cache3;
       }
       getDispatchWeight(agentId) {
         if (this.perfReader?.isCircuitOpen(agentId)) return 0.3;
@@ -11407,11 +11407,11 @@ var init_performance_reader = __esm({
        * Returns false on any IO/parse error — recovery defaults to "no relief"
        * when we can't prove a skill is bound.
        */
-      hasSkillForCategory(agentId, category, cache2) {
+      hasSkillForCategory(agentId, category, cache3) {
         if (!agentId || !category) return false;
         const normalizedTarget = normalizeSkillName(category);
         const cacheKey = agentId + "\0" + normalizedTarget;
-        const cached4 = cache2.get(cacheKey);
+        const cached4 = cache3.get(cacheKey);
         if (cached4 !== void 0) return cached4;
         const indexMap = this.getSkillIndexEnabledMap();
         const agentIndex = indexMap?.[agentId];
@@ -11443,7 +11443,7 @@ var init_performance_reader = __esm({
           }
         } catch {
         }
-        cache2.set(cacheKey, result);
+        cache3.set(cacheKey, result);
         return result;
       }
       /**
@@ -12776,9 +12776,9 @@ function deriveAggregateKey(signal, projectRoot, boundAtCache) {
     timestampMs: ts2
   };
 }
-function resolveBoundAtMs(agentId, category, projectRoot, cache2, fallbackMs) {
+function resolveBoundAtMs(agentId, category, projectRoot, cache3, fallbackMs) {
   const key = agentId + "\0" + category;
-  const cached4 = cache2.get(key);
+  const cached4 = cache3.get(key);
   if (cached4 !== void 0) {
     return cached4 === boundAtMissSentinel ? fallbackMs : cached4;
   }
@@ -12787,13 +12787,13 @@ function resolveBoundAtMs(agentId, category, projectRoot, cache2, fallbackMs) {
     if (typeof boundAt === "string" && boundAt.length > 0) {
       const ms = new Date(boundAt).getTime();
       if (isFinite(ms) && ms > 0) {
-        cache2.set(key, ms);
+        cache3.set(key, ms);
         return ms;
       }
     }
   } catch {
   }
-  cache2.set(key, boundAtMissSentinel);
+  cache3.set(key, boundAtMissSentinel);
   return fallbackMs;
 }
 var import_fs14, import_path15, loggedCounterErrors, MAX_TELEMETRY_BYTES, VALID_CONSENSUS_SIGNALS, VALID_IMPL_SIGNALS, VALID_META_SIGNALS, VALID_PIPELINE_SIGNALS, SYSTEM_SENTINEL_AGENT_ID, rowsWrittenSinceCheck, DRIFT_SAMPLE_INTERVAL, INTERNAL, boundAtMissSentinel, PerformanceWriter;
@@ -17366,9 +17366,9 @@ function getRuntimeFlag(key, defaultValue, registry2 = RUNTIME_FLAG_REGISTRY) {
   if (envVal !== void 0 && envVal !== "") {
     return envVal;
   }
-  const cache2 = ensureLoaded(registry2);
-  if (Object.prototype.hasOwnProperty.call(cache2, key)) {
-    return cache2[key];
+  const cache3 = ensureLoaded(registry2);
+  if (Object.prototype.hasOwnProperty.call(cache3, key)) {
+    return cache3[key];
   }
   if (defaultValue !== void 0) {
     return defaultValue;
@@ -17568,10 +17568,10 @@ async function unsetRuntimeFlag(key, source, reason, registry2 = RUNTIME_FLAG_RE
   }
 }
 function listRuntimeFlags(registry2 = RUNTIME_FLAG_REGISTRY) {
-  const cache2 = ensureLoaded(registry2);
+  const cache3 = ensureLoaded(registry2);
   return Object.entries(registry2).map(([key, spec]) => {
     const envVal = process.env[key];
-    const fileVal = Object.prototype.hasOwnProperty.call(cache2, key) ? cache2[key] : void 0;
+    const fileVal = Object.prototype.hasOwnProperty.call(cache3, key) ? cache3[key] : void 0;
     let value;
     let from;
     if (envVal !== void 0 && envVal !== "") {
@@ -23823,8 +23823,8 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync69, readFileSync: readFileSync62 } = await import("fs");
-        const { join: join82 } = await import("path");
+        const { existsSync: existsSync70, readFileSync: readFileSync64 } = await import("fs");
+        const { join: join83 } = await import("path");
         for (const config2 of this.registry.getAll()) {
           if (config2.native) continue;
           if (this.workers.has(config2.id)) continue;
@@ -23833,8 +23833,8 @@ message: Your question?
             apiKey = await this.keyProviderFn(config2.provider) ?? void 0;
           }
           const llm = createProvider(config2.provider, config2.model, apiKey);
-          const instructionsPath = join82(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
-          const instructions = existsSync69(instructionsPath) ? readFileSync62(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join83(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
+          const instructions = existsSync70(instructionsPath) ? readFileSync64(instructionsPath, "utf-8") : void 0;
           const enableWebSearch = config2.preset === "researcher" || config2.skills.includes("research");
           const worker = new WorkerAgent(config2.id, llm, this.relayUrl, ALL_TOOLS, instructions, enableWebSearch, this.relayApiKey);
           await worker.start();
@@ -24031,8 +24031,8 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync69, readFileSync: readFileSync62 } = await import("fs");
-        const { join: join82 } = await import("path");
+        const { existsSync: existsSync70, readFileSync: readFileSync64 } = await import("fs");
+        const { join: join83 } = await import("path");
         let added = 0;
         for (const ac of this.registry.getAll()) {
           if (ac.native) continue;
@@ -24049,8 +24049,8 @@ message: Your question?
             this.workers.delete(ac.id);
           }
           const llm = createProvider(ac.provider, ac.model, key ?? void 0, void 0, ac.base_url);
-          const instructionsPath = join82(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
-          const instructions = existsSync69(instructionsPath) ? readFileSync62(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join83(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+          const instructions = existsSync70(instructionsPath) ? readFileSync64(instructionsPath, "utf-8") : void 0;
           const enableWebSearch = ac.preset === "researcher" || ac.skills.includes("research");
           const worker = new WorkerAgent(ac.id, llm, this.relayUrl, ALL_TOOLS, instructions, enableWebSearch, this.relayApiKey);
           await worker.start();
@@ -30051,11 +30051,18 @@ async function overviewHandler(projectRoot, ctx2) {
   const now = Date.now();
   const hourMs = 60 * 60 * 1e3;
   const graphPath = (0, import_path53.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if ((0, import_fs49.existsSync)(graphPath)) {
+  const archivePath = graphPath + ".1";
+  if ((0, import_fs49.existsSync)(graphPath) || (0, import_fs49.existsSync)(archivePath)) {
     try {
       const created = /* @__PURE__ */ new Map();
       const finished = /* @__PURE__ */ new Set();
-      const lines = (0, import_fs49.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = [];
+      if ((0, import_fs49.existsSync)(archivePath)) {
+        lines.push(...(0, import_fs49.readFileSync)(archivePath, "utf-8").split("\n").filter(Boolean));
+      }
+      if ((0, import_fs49.existsSync)(graphPath)) {
+        lines.push(...(0, import_fs49.readFileSync)(graphPath, "utf-8").split("\n").filter(Boolean));
+      }
       for (const line of lines) {
         try {
           const ev = JSON.parse(line);
@@ -30332,11 +30339,17 @@ function readForcedDevelops(projectRoot, agentId, category) {
 }
 function readTaskGraphByAgent(projectRoot) {
   const taskGraphPath = (0, import_path55.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  const archivePath = taskGraphPath + ".1";
   const result = /* @__PURE__ */ new Map();
-  if (!(0, import_fs51.existsSync)(taskGraphPath)) return result;
-  let lines;
+  if (!(0, import_fs51.existsSync)(taskGraphPath) && !(0, import_fs51.existsSync)(archivePath)) return result;
+  let lines = [];
   try {
-    lines = (0, import_fs51.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    if ((0, import_fs51.existsSync)(archivePath)) {
+      lines.push(...(0, import_fs51.readFileSync)(archivePath, "utf-8").split("\n").filter(Boolean));
+    }
+    if ((0, import_fs51.existsSync)(taskGraphPath)) {
+      lines.push(...(0, import_fs51.readFileSync)(taskGraphPath, "utf-8").split("\n").filter(Boolean));
+    }
   } catch {
     return result;
   }
@@ -30531,12 +30544,206 @@ var init_api_agents = __esm({
 function isCorrupt(projectRoot, index) {
   return (0, import_fs52.existsSync)((0, import_path56.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
 }
+function readSkillFrontmatter2(projectRoot, agentId, skillName) {
+  try {
+    const path7 = (0, import_path56.join)(projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
+    if (!(0, import_fs52.existsSync)(path7)) return null;
+    const raw = (0, import_fs52.readFileSync)(path7, "utf-8");
+    if (!raw.startsWith("---")) return null;
+    const end = raw.indexOf("\n---", 3);
+    if (end === -1) return null;
+    const block = raw.slice(3, end);
+    const out = {};
+    for (const line of block.split("\n")) {
+      const m = line.match(/^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.+?)\s*$/);
+      if (!m) continue;
+      const key = m[1];
+      let value = m[2];
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      if (key === "status") out.status = value;
+      else if (key === "bound_at") out.bound_at = value;
+      else if (key === "passed_baseline_rate") {
+        const n = Number(value);
+        if (Number.isFinite(n)) out.passed_baseline_rate = n;
+      }
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+function buildSignalIndex(projectRoot) {
+  const idx = { byAgentSkill: /* @__PURE__ */ new Map() };
+  const perfPath = (0, import_path56.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs52.existsSync)(perfPath)) return idx;
+  let raw;
+  try {
+    raw = readJsonlWithRotated(perfPath);
+  } catch {
+    return idx;
+  }
+  if (!raw) return idx;
+  const retracted = /* @__PURE__ */ new Set();
+  const retractedConsensusIds = /* @__PURE__ */ new Set();
+  const rows = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      rows.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  for (const r of rows) {
+    if (r.signal === "consensus_round_retracted") {
+      const cid = r.consensus_id;
+      if (typeof cid === "string" && cid.length > 0) retractedConsensusIds.add(cid);
+      continue;
+    }
+    if (r.signal === "signal_retracted") {
+      const agentId = r.agentId;
+      const taskKey = r.taskId ?? r.timestamp;
+      const retractedSignal = r.retractedSignal;
+      if (!agentId || !taskKey) continue;
+      if (typeof retractedSignal === "string") {
+        retracted.add(`${agentId}:${taskKey}:${retractedSignal}`);
+      } else {
+        retracted.add(`${agentId}:${taskKey}:*`);
+      }
+    }
+  }
+  for (const r of rows) {
+    if (r.type !== "consensus") continue;
+    const signal = r.signal;
+    if (!signal) continue;
+    if (!CORRECT_SIGNALS.has(signal) && !HALLUC_SIGNALS.has(signal)) continue;
+    const agentId = r.agentId;
+    const category = r.category;
+    const tsStr = r.timestamp;
+    if (!agentId || !category || !tsStr) continue;
+    const ts2 = new Date(tsStr).getTime();
+    if (!Number.isFinite(ts2) || ts2 === 0) continue;
+    const taskKey = r.taskId ?? tsStr;
+    if (retracted.has(`${agentId}:${taskKey}:${signal}`)) continue;
+    if (retracted.has(`${agentId}:${taskKey}:*`)) continue;
+    const findingId = r.findingId;
+    if (typeof findingId === "string") {
+      let drop = false;
+      for (const cid of retractedConsensusIds) {
+        if (findingId.startsWith(cid + ":")) {
+          drop = true;
+          break;
+        }
+      }
+      if (drop) continue;
+    }
+    const skillKey = normalizeSkillName(category);
+    if (!skillKey) continue;
+    let perAgent = idx.byAgentSkill.get(agentId);
+    if (!perAgent) {
+      perAgent = /* @__PURE__ */ new Map();
+      idx.byAgentSkill.set(agentId, perAgent);
+    }
+    let arr = perAgent.get(skillKey);
+    if (!arr) {
+      arr = [];
+      perAgent.set(skillKey, arr);
+    }
+    arr.push({ ts: ts2, signal });
+  }
+  for (const perAgent of idx.byAgentSkill.values()) {
+    for (const arr of perAgent.values()) arr.sort((a, b) => a.ts - b.ts);
+  }
+  return idx;
+}
+function deriveEffectiveness(projectRoot, index, signalIdx, nowMs) {
+  const out = [];
+  for (const agentId of index.getAgentIds()) {
+    for (const slot of index.getAgentSlots(agentId)) {
+      if (!slot.enabled) continue;
+      const fm = readSkillFrontmatter2(projectRoot, agentId, slot.skill);
+      const boundAtIso = fm?.bound_at ?? slot.boundAt;
+      const boundAtMs = new Date(boundAtIso).getTime();
+      if (!Number.isFinite(boundAtMs) || boundAtMs <= 0) continue;
+      const windowStartMs = Math.max(boundAtMs, nowMs - WINDOW_MS2);
+      const totalSpan = Math.max(nowMs - windowStartMs, NUM_BUCKETS);
+      const bucketMs = totalSpan / NUM_BUCKETS;
+      const events = signalIdx.byAgentSkill.get(agentId)?.get(normalizeSkillName(slot.skill)) ?? [];
+      const buckets = Array.from(
+        { length: NUM_BUCKETS },
+        () => ({ c: 0, h: 0 })
+      );
+      let n = 0;
+      for (const ev of events) {
+        if (ev.ts < windowStartMs) continue;
+        const rel = ev.ts - windowStartMs;
+        let i = Math.floor(rel / bucketMs);
+        if (i < 0) i = 0;
+        if (i >= NUM_BUCKETS) i = NUM_BUCKETS - 1;
+        if (CORRECT_SIGNALS.has(ev.signal)) buckets[i].c++;
+        else if (HALLUC_SIGNALS.has(ev.signal)) buckets[i].h++;
+        n++;
+      }
+      const curve = buckets.map((b, i) => {
+        const total = b.c + b.h;
+        const t = windowStartMs + (i + 1) * bucketMs;
+        return { t, value: total > 0 ? b.c / total : null };
+      });
+      const threshold = fm?.passed_baseline_rate ?? DEFAULT_THRESHOLD;
+      const status = fm?.status ?? null;
+      out.push({
+        agentId,
+        skill: slot.skill,
+        status,
+        curve,
+        threshold,
+        n,
+        boundAt: boundAtIso
+      });
+    }
+  }
+  return out;
+}
+function jsonlMtime(projectRoot) {
+  try {
+    return (0, import_fs52.statSync)((0, import_path56.join)(projectRoot, ".gossip", "agent-performance.jsonl")).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function cacheHit(projectRoot, nowMs) {
+  const entry = cache2.get(projectRoot);
+  if (!entry) return null;
+  if (nowMs - entry.builtAtMs > CACHE_TTL_MS) return null;
+  if (entry.jsonlMtimeMs !== jsonlMtime(projectRoot)) return null;
+  return entry.payload;
+}
 async function skillsGetHandler(projectRoot) {
+  const nowMs = Date.now();
+  const cached4 = cacheHit(projectRoot, nowMs);
+  if (cached4) return cached4;
   try {
     const index = new SkillIndex(projectRoot);
-    return { index: index.getIndex(), suggestions: [] };
+    let effectiveness = [];
+    try {
+      const signalIdx = buildSignalIndex(projectRoot);
+      effectiveness = deriveEffectiveness(projectRoot, index, signalIdx, nowMs);
+    } catch {
+    }
+    const payload = {
+      index: index.getIndex(),
+      suggestions: [],
+      effectiveness
+    };
+    cache2.set(projectRoot, {
+      payload,
+      builtAtMs: nowMs,
+      jsonlMtimeMs: jsonlMtime(projectRoot)
+    });
+    return payload;
   } catch {
-    return { index: {}, suggestions: [] };
+    return { index: {}, suggestions: [], effectiveness: [] };
   }
 }
 async function skillsBindHandler(projectRoot, body) {
@@ -30553,19 +30760,33 @@ async function skillsBindHandler(projectRoot, body) {
       const changed = index.disable(body.agent_id, body.skill);
       if (!changed) return { success: false, error: "Skill not bound to agent" };
     }
+    cache2.delete(projectRoot);
     return { success: true };
   } catch (err) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
   }
 }
-var import_fs52, import_path56, AGENT_ID_RE2;
+var import_fs52, import_path56, AGENT_ID_RE2, NUM_BUCKETS, WINDOW_MS2, DEFAULT_THRESHOLD, CACHE_TTL_MS, CORRECT_SIGNALS, HALLUC_SIGNALS, cache2;
 var init_api_skills = __esm({
   "packages/relay/src/dashboard/api-skills.ts"() {
     "use strict";
     init_skill_index();
+    init_src4();
     import_fs52 = require("fs");
     import_path56 = require("path");
     AGENT_ID_RE2 = /^[a-zA-Z0-9_-]{1,64}$/;
+    NUM_BUCKETS = 10;
+    WINDOW_MS2 = 7 * 24 * 60 * 60 * 1e3;
+    DEFAULT_THRESHOLD = 0.7;
+    CACHE_TTL_MS = 6e4;
+    CORRECT_SIGNALS = /* @__PURE__ */ new Set([
+      "agreement",
+      "category_confirmed",
+      "consensus_verified",
+      "unique_confirmed"
+    ]);
+    HALLUC_SIGNALS = /* @__PURE__ */ new Set(["disagreement", "hallucination_caught"]);
+    cache2 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -30849,6 +31070,123 @@ var init_api_consensus = __esm({
   }
 });
 
+// packages/relay/src/dashboard/api-consensus-flow.ts
+function isValidConsensusId(id) {
+  return SAFE_CONSENSUS_ID.test(id);
+}
+function familyOf(agentId) {
+  if (agentId.startsWith("sonnet-")) return "sonnet";
+  if (agentId.startsWith("gemini-")) return "gemini";
+  if (agentId.startsWith("opus-")) return "opus";
+  if (agentId.startsWith("haiku-")) return "haiku";
+  return "other";
+}
+function tally(report, bucket) {
+  const arr = report?.[bucket];
+  return Array.isArray(arr) ? arr : [];
+}
+function consensusFlowHandler(projectRoot, query) {
+  const consensusId = query?.get("consensusId")?.trim() ?? "";
+  if (!consensusId) {
+    return { error: "consensusId query parameter is required" };
+  }
+  if (!isValidConsensusId(consensusId)) {
+    return { error: `invalid consensusId shape (expected xxxxxxxx-xxxxxxxx hex)` };
+  }
+  const reportPath = (0, import_path61.join)(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
+  if (!(0, import_fs56.existsSync)(reportPath)) {
+    return { error: `consensus ${consensusId} not found` };
+  }
+  let report;
+  try {
+    report = JSON.parse((0, import_fs56.readFileSync)(reportPath, "utf-8"));
+  } catch (e) {
+    return { error: `failed to parse consensus report: ${e?.message ?? "unknown error"}` };
+  }
+  const buckets = {
+    confirmed: tally(report, "confirmed"),
+    disputed: tally(report, "disputed"),
+    unverified: tally(report, "unverified"),
+    unique: tally(report, "unique")
+  };
+  const newFindings = Array.isArray(report?.newFindings) ? report.newFindings : [];
+  const totalFindings = buckets.confirmed.length + buckets.disputed.length + buckets.unverified.length + buckets.unique.length + newFindings.length;
+  const familyAgents = /* @__PURE__ */ new Map();
+  for (const verdict of ["confirmed", "disputed", "unverified", "unique"]) {
+    for (const f of buckets[verdict]) {
+      const agent = f.originalAgentId;
+      if (!agent) continue;
+      const fam = familyOf(agent);
+      if (!familyAgents.has(fam)) familyAgents.set(fam, /* @__PURE__ */ new Set());
+      familyAgents.get(fam).add(agent);
+    }
+  }
+  const modelFamilyToFindings = Array.from(familyAgents.entries()).map(([family, ids]) => ({
+    family,
+    agentIds: Array.from(ids).sort(),
+    agentCount: ids.size
+  })).sort((a, b) => a.family.localeCompare(b.family));
+  const edgeCounts = /* @__PURE__ */ new Map();
+  for (const verdict of ["confirmed", "disputed", "unverified", "unique"]) {
+    for (const f of buckets[verdict]) {
+      const agent = f.originalAgentId;
+      if (!agent) continue;
+      const fam = familyOf(agent);
+      const key = `${fam}::${verdict}`;
+      edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
+    }
+  }
+  const familyToOutcome = [];
+  for (const [key, count] of edgeCounts) {
+    const [fam, verdict] = key.split("::");
+    const agentCount = familyAgents.get(fam)?.size ?? 0;
+    familyToOutcome.push({
+      from: { family: fam, agentCount },
+      to: { verdict, count },
+      weight: totalFindings > 0 ? count / totalFindings : 0
+    });
+  }
+  familyToOutcome.sort((a, b) => {
+    if (a.from.family !== b.from.family) return a.from.family.localeCompare(b.from.family);
+    return a.to.verdict.localeCompare(b.to.verdict);
+  });
+  const out = {
+    consensusId,
+    timestamp: typeof report?.timestamp === "string" ? report.timestamp : "",
+    agentCount: typeof report?.agentCount === "number" ? report.agentCount : 0,
+    modelFamilyToFindings,
+    familyToOutcome,
+    summary: {
+      totalFindings,
+      confirmed: buckets.confirmed.length,
+      disputed: buckets.disputed.length,
+      unverified: buckets.unverified.length,
+      unique: buckets.unique.length,
+      newFindings: newFindings.length
+    }
+  };
+  if (report?.crossReviewAssignments && typeof report.crossReviewAssignments === "object") {
+    out.crossReviewAssignments = report.crossReviewAssignments;
+  }
+  if (Array.isArray(report?.crossReviewCoverage)) {
+    out.crossReviewCoverage = report.crossReviewCoverage;
+  }
+  if (report?.partialReview === true) out.partialReview = true;
+  if (report?.coverageDegraded && typeof report.coverageDegraded === "object") {
+    out.coverageDegraded = report.coverageDegraded;
+  }
+  return out;
+}
+var import_fs56, import_path61, SAFE_CONSENSUS_ID;
+var init_api_consensus_flow = __esm({
+  "packages/relay/src/dashboard/api-consensus-flow.ts"() {
+    "use strict";
+    import_fs56 = require("fs");
+    import_path61 = require("path");
+    SAFE_CONSENSUS_ID = /^[0-9a-f]{8}-[0-9a-f]{8}$/;
+  }
+});
+
 // packages/relay/src/dashboard/api-signals.ts
 function inferSource(entry) {
   const raw = typeof entry.source === "string" ? entry.source.toLowerCase() : "";
@@ -30874,7 +31212,7 @@ async function signalsHandler(projectRoot, query) {
   const cursor = query?.get("cursor") ?? null;
   const limit = Math.min(Math.max(parseInt(query?.get("limit") ?? "", 10) || DEFAULT_LIMIT, 1), MAX_LIMIT);
   const offset = Math.max(parseInt(query?.get("offset") ?? "", 10) || 0, 0);
-  const perfPath = (0, import_path61.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  const perfPath = (0, import_path62.join)(projectRoot, ".gossip", "agent-performance.jsonl");
   const all = [];
   const roundRetractions = [];
   const signalFilterSet = signalFilters.length ? new Set(signalFilters) : null;
@@ -30936,11 +31274,11 @@ async function signalsHandler(projectRoot, query) {
   if (nextCursor) response.nextCursor = nextCursor;
   return response;
 }
-var import_path61, MAX_LIMIT, DEFAULT_LIMIT, META_SIGNALS;
+var import_path62, MAX_LIMIT, DEFAULT_LIMIT, META_SIGNALS;
 var init_api_signals = __esm({
   "packages/relay/src/dashboard/api-signals.ts"() {
     "use strict";
-    import_path61 = require("path");
+    import_path62 = require("path");
     init_src4();
     MAX_LIMIT = 500;
     DEFAULT_LIMIT = 50;
@@ -30953,7 +31291,7 @@ function extractCitations(findingText, projectRoot) {
   const out = [];
   let realRoot;
   try {
-    realRoot = (0, import_fs56.realpathSync)((0, import_path62.resolve)(projectRoot));
+    realRoot = (0, import_fs57.realpathSync)((0, import_path63.resolve)(projectRoot));
   } catch {
     return out;
   }
@@ -30964,23 +31302,23 @@ function extractCitations(findingText, projectRoot) {
     const line = parseInt(m[2], 10);
     if (!Number.isFinite(line) || line < 1) continue;
     if (filePath.includes("\0")) continue;
-    const abs = (0, import_path62.resolve)(realRoot, filePath);
-    const preRel = (0, import_path62.relative)(realRoot, abs);
+    const abs = (0, import_path63.resolve)(realRoot, filePath);
+    const preRel = (0, import_path63.relative)(realRoot, abs);
     if (preRel === "" || preRel.startsWith("..")) continue;
-    if (!(0, import_fs56.existsSync)(abs)) {
+    if (!(0, import_fs57.existsSync)(abs)) {
       out.push({ file: filePath, line, snippet: "// file not found" });
       continue;
     }
     let realAbs;
     try {
-      realAbs = (0, import_fs56.realpathSync)(abs);
+      realAbs = (0, import_fs57.realpathSync)(abs);
     } catch {
       continue;
     }
-    const rel = (0, import_path62.relative)(realRoot, realAbs);
+    const rel = (0, import_path63.relative)(realRoot, realAbs);
     if (rel === "" || rel.startsWith("..")) continue;
     try {
-      const lines = (0, import_fs56.readFileSync)(realAbs, "utf-8").split("\n");
+      const lines = (0, import_fs57.readFileSync)(realAbs, "utf-8").split("\n");
       const start = Math.max(0, line - 1 - SNIPPET_CONTEXT);
       const end = Math.min(lines.length, line + SNIPPET_CONTEXT);
       out.push({ file: filePath, line, snippet: lines.slice(start, end).join("\n") });
@@ -30993,9 +31331,9 @@ function extractCitations(findingText, projectRoot) {
 async function findingHandler(projectRoot, consensusId, findingId) {
   if (!SAFE_ID.test(consensusId)) throw new Error(`consensus ${consensusId} not found`);
   if (!SAFE_ID.test(findingId)) throw new Error(`finding ${findingId} not found in ${consensusId}`);
-  const reportPath = (0, import_path62.join)(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
-  if (!(0, import_fs56.existsSync)(reportPath)) throw new Error(`consensus ${consensusId} not found`);
-  const report = JSON.parse((0, import_fs56.readFileSync)(reportPath, "utf-8"));
+  const reportPath = (0, import_path63.join)(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
+  if (!(0, import_fs57.existsSync)(reportPath)) throw new Error(`consensus ${consensusId} not found`);
+  const report = JSON.parse((0, import_fs57.readFileSync)(reportPath, "utf-8"));
   const buckets = [
     ["confirmed", "confirmed"],
     ["disputed", "disputed"],
@@ -31016,7 +31354,7 @@ async function findingHandler(projectRoot, consensusId, findingId) {
   }
   if (!found) throw new Error(`finding ${findingId} not found in ${consensusId}`);
   const signals = [];
-  const perfPath = (0, import_path62.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  const perfPath = (0, import_path63.join)(projectRoot, ".gossip", "agent-performance.jsonl");
   try {
     const raw = readJsonlWithRotated(perfPath);
     if (raw) {
@@ -31058,13 +31396,13 @@ async function findingHandler(projectRoot, consensusId, findingId) {
     citations
   };
 }
-var import_fs56, import_path62, SAFE_ID, SNIPPET_CONTEXT, CITE_PATTERN;
+var import_fs57, import_path63, SAFE_ID, SNIPPET_CONTEXT, CITE_PATTERN;
 var init_api_finding = __esm({
   "packages/relay/src/dashboard/api-finding.ts"() {
     "use strict";
-    import_fs56 = require("fs");
+    import_fs57 = require("fs");
     init_src4();
-    import_path62 = require("path");
+    import_path63 = require("path");
     SAFE_ID = /^[\w:.\-]+$/;
     SNIPPET_CONTEXT = 2;
     CITE_PATTERN = /<cite tag="file">([^<:]+):(\d+)<\/cite>/g;
@@ -31077,13 +31415,13 @@ async function openFindingsHandler(projectRoot) {
   let open = 0;
   let resolved = 0;
   let staleAnchor = 0;
-  const findingsPath = (0, import_path63.join)(projectRoot, ".gossip", "implementation-findings.jsonl");
-  if (!(0, import_fs57.existsSync)(findingsPath)) {
+  const findingsPath = (0, import_path64.join)(projectRoot, ".gossip", "implementation-findings.jsonl");
+  if (!(0, import_fs58.existsSync)(findingsPath)) {
     return { rows, totals: { open: 0, resolved: 0, staleAnchor: 0 } };
   }
   let raw;
   try {
-    raw = (0, import_fs57.readFileSync)(findingsPath, "utf-8");
+    raw = (0, import_fs58.readFileSync)(findingsPath, "utf-8");
   } catch {
     return { rows, totals: { open: 0, resolved: 0, staleAnchor: 0 } };
   }
@@ -31121,40 +31459,40 @@ async function openFindingsHandler(projectRoot) {
   }
   return { rows, totals: { open, resolved, staleAnchor } };
 }
-var import_fs57, import_path63;
+var import_fs58, import_path64;
 var init_api_open_findings = __esm({
   "packages/relay/src/dashboard/api-open-findings.ts"() {
     "use strict";
-    import_fs57 = require("fs");
-    import_path63 = require("path");
+    import_fs58 = require("fs");
+    import_path64 = require("path");
   }
 });
 
 // packages/relay/src/dashboard/api-learnings.ts
 async function learningsHandler(projectRoot) {
-  const agentsDir = (0, import_path64.join)(projectRoot, ".gossip", "agents");
-  if (!(0, import_fs58.existsSync)(agentsDir)) return { learnings: [] };
+  const agentsDir = (0, import_path65.join)(projectRoot, ".gossip", "agents");
+  if (!(0, import_fs59.existsSync)(agentsDir)) return { learnings: [] };
   const all = [];
   let agentIds;
   try {
-    agentIds = (0, import_fs58.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
+    agentIds = (0, import_fs59.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
   } catch {
     return { learnings: [] };
   }
   for (const agentId of agentIds) {
-    const knowledgeDir = (0, import_path64.join)(agentsDir, agentId, "memory", "knowledge");
-    if (!(0, import_fs58.existsSync)(knowledgeDir)) continue;
+    const knowledgeDir = (0, import_path65.join)(agentsDir, agentId, "memory", "knowledge");
+    if (!(0, import_fs59.existsSync)(knowledgeDir)) continue;
     let files;
     try {
-      files = (0, import_fs58.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+      files = (0, import_fs59.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
     } catch {
       continue;
     }
     for (const filename of files) {
-      const filepath = (0, import_path64.join)(knowledgeDir, filename);
+      const filepath = (0, import_path65.join)(knowledgeDir, filename);
       try {
-        const stat4 = (0, import_fs58.statSync)(filepath);
-        const raw = (0, import_fs58.readFileSync)(filepath, "utf-8");
+        const stat4 = (0, import_fs59.statSync)(filepath);
+        const raw = (0, import_fs59.readFileSync)(filepath, "utf-8");
         const fm = parseFrontmatter3(raw);
         all.push({
           agentId,
@@ -31181,28 +31519,41 @@ function parseFrontmatter3(raw) {
   }
   return fm;
 }
-var import_fs58, import_path64, MAX_LEARNINGS;
+var import_fs59, import_path65, MAX_LEARNINGS;
 var init_api_learnings = __esm({
   "packages/relay/src/dashboard/api-learnings.ts"() {
     "use strict";
-    import_fs58 = require("fs");
-    import_path64 = require("path");
+    import_fs59 = require("fs");
+    import_path65 = require("path");
     MAX_LEARNINGS = 10;
   }
 });
 
 // packages/relay/src/dashboard/api-tasks.ts
+function readTaskGraphLines(graphPath) {
+  const out = [];
+  const archive = graphPath + ".1";
+  if ((0, import_fs60.existsSync)(archive)) {
+    out.push(...(0, import_fs60.readFileSync)(archive, "utf-8").split("\n").filter(Boolean));
+  }
+  if ((0, import_fs60.existsSync)(graphPath)) {
+    out.push(...(0, import_fs60.readFileSync)(graphPath, "utf-8").split("\n").filter(Boolean));
+  }
+  return out;
+}
 async function tasksHandler(projectRoot, query) {
   const rawLimit = parseInt(query?.get("limit") ?? "50", 10);
   const rawOffset = parseInt(query?.get("offset") ?? "0", 10);
   const limit = isNaN(rawLimit) || rawLimit < 1 ? 50 : Math.min(rawLimit, 2e3);
   const offset = isNaN(rawOffset) || rawOffset < 0 ? 0 : rawOffset;
-  const graphPath = (0, import_path65.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs59.existsSync)(graphPath)) return { items: [], total: 0, offset, limit };
+  const graphPath = (0, import_path66.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs60.existsSync)(graphPath) && !(0, import_fs60.existsSync)(graphPath + ".1")) {
+    return { items: [], total: 0, offset, limit };
+  }
   const created = /* @__PURE__ */ new Map();
   const completed = /* @__PURE__ */ new Map();
   try {
-    const lines = (0, import_fs59.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = readTaskGraphLines(graphPath);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -31258,24 +31609,24 @@ async function tasksHandler(projectRoot, query) {
   tasks.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
   return { items: tasks.slice(offset, offset + limit), total: tasks.length, offset, limit };
 }
-var import_fs59, import_path65;
+var import_fs60, import_path66;
 var init_api_tasks = __esm({
   "packages/relay/src/dashboard/api-tasks.ts"() {
     "use strict";
-    import_fs59 = require("fs");
-    import_path65 = require("path");
+    import_fs60 = require("fs");
+    import_path66 = require("path");
     init_utility_agents();
   }
 });
 
 // packages/relay/src/dashboard/api-active-tasks.ts
 async function activeTasksHandler(projectRoot) {
-  const taskGraphPath = (0, import_path66.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs60.existsSync)(taskGraphPath)) return { tasks: [] };
+  const taskGraphPath = (0, import_path67.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs61.existsSync)(taskGraphPath)) return { tasks: [] };
   const created = /* @__PURE__ */ new Map();
   const finished = /* @__PURE__ */ new Set();
   try {
-    const lines = (0, import_fs60.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs61.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const ev = JSON.parse(line);
@@ -31303,12 +31654,12 @@ async function activeTasksHandler(projectRoot) {
   active.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
   return { tasks: active.slice(0, 10) };
 }
-var import_fs60, import_path66;
+var import_fs61, import_path67;
 var init_api_active_tasks = __esm({
   "packages/relay/src/dashboard/api-active-tasks.ts"() {
     "use strict";
-    import_fs60 = require("fs");
-    import_path66 = require("path");
+    import_fs61 = require("fs");
+    import_path67 = require("path");
     init_utility_agents();
   }
 });
@@ -31322,25 +31673,25 @@ function categorize(text) {
   return "other";
 }
 function logsHandler(projectRoot, query) {
-  const logPath = (0, import_path67.join)(projectRoot, ".gossip", "mcp.log");
-  if (!(0, import_fs61.existsSync)(logPath)) {
+  const logPath = (0, import_path68.join)(projectRoot, ".gossip", "mcp.log");
+  if (!(0, import_fs62.existsSync)(logPath)) {
     return { entries: [], totalLines: 0, fileSize: 0 };
   }
   const filter = query?.get("filter") || void 0;
   const tail = parseInt(query?.get("tail") || "200", 10);
   const clampedTail = Math.min(Math.max(tail, 10), 2e3);
-  const fileSize = (0, import_fs61.statSync)(logPath).size;
+  const fileSize = (0, import_fs62.statSync)(logPath).size;
   const MAX_READ = 512 * 1024;
   const readFrom = Math.max(0, fileSize - MAX_READ);
   const readLen = fileSize - readFrom;
-  const fd = (0, import_fs61.openSync)(logPath, "r");
+  const fd = (0, import_fs62.openSync)(logPath, "r");
   let buf = Buffer.alloc(0);
   try {
     buf = Buffer.allocUnsafe(readLen);
-    const bytesRead = (0, import_fs61.readSync)(fd, buf, 0, readLen, readFrom);
+    const bytesRead = (0, import_fs62.readSync)(fd, buf, 0, readLen, readFrom);
     buf = buf.subarray(0, bytesRead);
   } finally {
-    (0, import_fs61.closeSync)(fd);
+    (0, import_fs62.closeSync)(fd);
   }
   let raw = buf.toString("utf-8");
   let lineOffset = 0;
@@ -31348,13 +31699,13 @@ function logsHandler(projectRoot, query) {
     const nl = raw.indexOf("\n");
     raw = nl >= 0 ? raw.slice(nl + 1) : raw;
     const SCAN_CHUNK = 64 * 1024;
-    const scanFd = (0, import_fs61.openSync)(logPath, "r");
+    const scanFd = (0, import_fs62.openSync)(logPath, "r");
     try {
       let pos = 0;
       const chunk = Buffer.allocUnsafe(SCAN_CHUNK);
       while (pos < readFrom) {
         const len = Math.min(SCAN_CHUNK, readFrom - pos);
-        const n = (0, import_fs61.readSync)(scanFd, chunk, 0, len, pos);
+        const n = (0, import_fs62.readSync)(scanFd, chunk, 0, len, pos);
         if (n === 0) break;
         for (let j = 0; j < n; j++) {
           if (chunk[j] === 10) lineOffset++;
@@ -31362,7 +31713,7 @@ function logsHandler(projectRoot, query) {
         pos += n;
       }
     } finally {
-      (0, import_fs61.closeSync)(scanFd);
+      (0, import_fs62.closeSync)(scanFd);
     }
   }
   const allLines = raw.split("\n").filter(Boolean);
@@ -31380,12 +31731,12 @@ function logsHandler(projectRoot, query) {
   entries = entries.slice(-clampedTail);
   return { entries, totalLines, fileSize, filter };
 }
-var import_fs61, import_path67, CATEGORY_PATTERNS2;
+var import_fs62, import_path68, CATEGORY_PATTERNS2;
 var init_api_logs = __esm({
   "packages/relay/src/dashboard/api-logs.ts"() {
     "use strict";
-    import_fs61 = require("fs");
-    import_path67 = require("path");
+    import_fs62 = require("fs");
+    import_path68 = require("path");
     CATEGORY_PATTERNS2 = [
       [/^\[worker:/, "worker"],
       [/^\[Gemini\]/, "gemini"],
@@ -31417,11 +31768,11 @@ function violationsHandler(projectRoot, query) {
   const page = Math.max(1, parseInt(query?.get("page") ?? "1", 10));
   const pageSize = Math.min(100, Math.max(1, parseInt(query?.get("pageSize") ?? "25", 10)));
   const agentFilter = query?.get("agentId") ?? null;
-  const filePath = (0, import_path68.join)(projectRoot, FILE);
-  if (!(0, import_fs62.existsSync)(filePath)) {
+  const filePath = (0, import_path69.join)(projectRoot, FILE);
+  if (!(0, import_fs63.existsSync)(filePath)) {
     return { items: [], total: 0, page, pageSize };
   }
-  const raw = (0, import_fs62.readFileSync)(filePath, "utf-8");
+  const raw = (0, import_fs63.readFileSync)(filePath, "utf-8");
   const lines = raw.trim().split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines) {
@@ -31441,12 +31792,12 @@ function violationsHandler(projectRoot, query) {
   const start = (page - 1) * pageSize;
   return { items: entries.slice(start, start + pageSize), total, page, pageSize };
 }
-var import_fs62, import_path68, FILE;
+var import_fs63, import_path69, FILE;
 var init_api_violations = __esm({
   "packages/relay/src/dashboard/api-violations.ts"() {
     "use strict";
-    import_fs62 = require("fs");
-    import_path68 = require("path");
+    import_fs63 = require("fs");
+    import_path69 = require("path");
     FILE = ".gossip/process-violations.jsonl";
   }
 });
@@ -31454,15 +31805,15 @@ var init_api_violations = __esm({
 // packages/relay/src/dashboard/routes.ts
 function resolveDashboardRoot(projectRoot) {
   const candidates = [
-    (0, import_path69.resolve)(__dirname, "..", "dist-dashboard"),
+    (0, import_path70.resolve)(__dirname, "..", "dist-dashboard"),
     // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
-    (0, import_path69.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    (0, import_path70.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
     // tsc dev: packages/relay/dist/dashboard → repo-root
-    (0, import_path69.join)(projectRoot, "dist-dashboard")
+    (0, import_path70.join)(projectRoot, "dist-dashboard")
     // legacy dev fallback (git-clone running from repo root)
   ];
   for (const p of candidates) {
-    if ((0, import_fs63.existsSync)(p)) return p;
+    if ((0, import_fs64.existsSync)(p)) return p;
   }
   return null;
 }
@@ -31489,7 +31840,7 @@ function readBody(req) {
     });
   });
 }
-var import_fs63, import_path69, import_crypto25, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
+var import_fs64, import_path70, import_crypto25, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
 var init_routes = __esm({
   "packages/relay/src/dashboard/routes.ts"() {
     "use strict";
@@ -31502,6 +31853,7 @@ var init_routes = __esm({
     init_api_native_memory();
     init_api_gossip_memory();
     init_api_consensus();
+    init_api_consensus_flow();
     init_api_signals();
     init_api_finding();
     init_api_open_findings();
@@ -31510,8 +31862,8 @@ var init_routes = __esm({
     init_api_active_tasks();
     init_api_logs();
     init_api_violations();
-    import_fs63 = require("fs");
-    import_path69 = require("path");
+    import_fs64 = require("fs");
+    import_path70 = require("path");
     import_crypto25 = require("crypto");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
@@ -31574,6 +31926,11 @@ var init_routes = __esm({
         if (url2 === "/dashboard") {
           return this.serveDashboard(res);
         }
+        if (url2 === "/" || url2 === "") {
+          res.writeHead(302, { Location: "/dashboard" });
+          res.end();
+          return true;
+        }
         this.json(res, 404, { error: "Not found" });
         return true;
       }
@@ -31690,6 +32047,24 @@ var init_routes = __esm({
             this.json(res, 200, data);
             return true;
           }
+          if (url2 === "/dashboard/api/consensus-flow" && req.method === "GET") {
+            const consensusId = query?.get("consensusId")?.trim() ?? "";
+            if (!consensusId) {
+              this.json(res, 400, { error: "consensusId query parameter is required" });
+              return true;
+            }
+            if (!isValidConsensusId(consensusId)) {
+              this.json(res, 400, { error: "invalid consensusId shape (expected xxxxxxxx-xxxxxxxx hex)" });
+              return true;
+            }
+            const data = consensusFlowHandler(this.projectRoot, query ?? void 0);
+            if ("error" in data) {
+              this.json(res, 404, data);
+              return true;
+            }
+            this.json(res, 200, data);
+            return true;
+          }
           if (url2 === "/dashboard/api/consensus-reports" && req.method === "GET") {
             const page = parseInt(query?.get("page") || "1", 10);
             const pageSize = parseInt(query?.get("pageSize") || "5", 10);
@@ -31792,13 +32167,13 @@ var init_routes = __esm({
           res.end("Dashboard assets not found. Reinstall gossipcat or rebuild from source.");
           return true;
         }
-        const htmlPath = (0, import_path69.join)(this.dashboardRoot, "index.html");
-        if (!(0, import_fs63.existsSync)(htmlPath)) {
+        const htmlPath = (0, import_path70.join)(this.dashboardRoot, "index.html");
+        if (!(0, import_fs64.existsSync)(htmlPath)) {
           res.writeHead(503, { "Content-Type": "text/plain" });
           res.end(`Dashboard index.html missing at ${this.dashboardRoot}. Reinstall gossipcat.`);
           return true;
         }
-        const html = (0, import_fs63.readFileSync)(htmlPath, "utf-8");
+        const html = (0, import_fs64.readFileSync)(htmlPath, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return true;
@@ -31824,16 +32199,16 @@ var init_routes = __esm({
         const ext = "." + (relativePath.split(".").pop() || "");
         const mime = MIME[ext];
         if (!mime) return false;
-        const filePath = (0, import_path69.join)(this.dashboardRoot, relativePath);
+        const filePath = (0, import_path70.join)(this.dashboardRoot, relativePath);
         try {
-          const realFile = (0, import_fs63.realpathSync)(filePath);
-          const realBase = (0, import_fs63.realpathSync)(this.dashboardRoot);
+          const realFile = (0, import_fs64.realpathSync)(filePath);
+          const realBase = (0, import_fs64.realpathSync)(this.dashboardRoot);
           if (!realFile.startsWith(realBase + "/")) {
             res.writeHead(404);
             res.end();
             return true;
           }
-          const data = (0, import_fs63.readFileSync)(realFile);
+          const data = (0, import_fs64.readFileSync)(realFile);
           res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=86400" });
           res.end(data);
           return true;
@@ -31848,8 +32223,8 @@ var init_routes = __esm({
         return match ? match[1] : null;
       }
       getConsensusReports(page = 1, pageSize = 5) {
-        const { readdirSync: readdirSync22, readFileSync: readFileSync62, existsSync: existsSync69 } = require("fs");
-        const reportsDir = (0, import_path69.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const { readdirSync: readdirSync22, readFileSync: readFileSync64, existsSync: existsSync70 } = require("fs");
+        const reportsDir = (0, import_path70.join)(this.projectRoot, ".gossip", "consensus-reports");
         let retractedConsensusIds = [];
         let roundRetractions = [];
         try {
@@ -31859,13 +32234,13 @@ var init_routes = __esm({
           roundRetractions = reader.getRoundRetractions();
         } catch {
         }
-        if (!existsSync69(reportsDir)) return { reports: [], totalReports: 0, page, pageSize, retractedConsensusIds, roundRetractions };
+        if (!existsSync70(reportsDir)) return { reports: [], totalReports: 0, page, pageSize, retractedConsensusIds, roundRetractions };
         try {
-          const { statSync: statSync34 } = require("fs");
+          const { statSync: statSync35 } = require("fs");
           const allFiles = readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
             try {
-              const aTime = statSync34((0, import_path69.join)(reportsDir, a)).mtimeMs;
-              const bTime = statSync34((0, import_path69.join)(reportsDir, b)).mtimeMs;
+              const aTime = statSync35((0, import_path70.join)(reportsDir, a)).mtimeMs;
+              const bTime = statSync35((0, import_path70.join)(reportsDir, b)).mtimeMs;
               return bTime - aTime;
             } catch {
               return 0;
@@ -31876,13 +32251,13 @@ var init_routes = __esm({
           const clampedPage = Math.max(page, 1);
           const start = (clampedPage - 1) * clampedPageSize;
           const files = allFiles.slice(start, start + clampedPageSize);
-          const realReportsDir = (0, import_fs63.realpathSync)(reportsDir);
+          const realReportsDir = (0, import_fs64.realpathSync)(reportsDir);
           const reports = files.map((f) => {
             try {
-              const filePath = (0, import_path69.join)(reportsDir, f);
-              const realFile = (0, import_fs63.realpathSync)(filePath);
+              const filePath = (0, import_path70.join)(reportsDir, f);
+              const realFile = (0, import_fs64.realpathSync)(filePath);
               if (!realFile.startsWith(realReportsDir + "/")) return null;
-              return JSON.parse(readFileSync62(realFile, "utf-8"));
+              return JSON.parse(readFileSync64(realFile, "utf-8"));
             } catch {
               return null;
             }
@@ -31893,29 +32268,29 @@ var init_routes = __esm({
         }
       }
       archiveFindings() {
-        const { readdirSync: readdirSync22, readFileSync: readFileSync62, renameSync: renameSync15, writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync69 } = require("fs");
-        const reportsDir = (0, import_path69.join)(this.projectRoot, ".gossip", "consensus-reports");
-        const archiveDir = (0, import_path69.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
+        const { readdirSync: readdirSync22, readFileSync: readFileSync64, renameSync: renameSync15, writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync70 } = require("fs");
+        const reportsDir = (0, import_path70.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const archiveDir = (0, import_path70.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
         let archived = 0;
-        if (existsSync69(reportsDir)) {
+        if (existsSync70(reportsDir)) {
           const files = readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).sort().reverse();
           if (files.length > 5) {
             mkdirSync41(archiveDir, { recursive: true });
             const toArchive = files.slice(5);
             for (const f of toArchive) {
               try {
-                renameSync15((0, import_path69.join)(reportsDir, f), (0, import_path69.join)(archiveDir, f));
+                renameSync15((0, import_path70.join)(reportsDir, f), (0, import_path70.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path69.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path70.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
-        if (existsSync69(findingsPath)) {
+        if (existsSync70(findingsPath)) {
           try {
-            const lines = readFileSync62(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
+            const lines = readFileSync64(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
             const kept = lines.filter((line) => {
               try {
                 const entry = JSON.parse(line);
@@ -31932,7 +32307,7 @@ var init_routes = __esm({
           } catch {
           }
         }
-        const remaining = existsSync69(reportsDir) ? readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
+        const remaining = existsSync70(reportsDir) ? readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
         return { archived, remaining, findingsCleared };
       }
       json(res, status, data) {
@@ -31945,14 +32320,14 @@ var init_routes = __esm({
 });
 
 // packages/relay/src/dashboard/ws.ts
-var import_ws3, import_fs64, import_fs65, import_path70, DashboardWs;
+var import_ws3, import_fs65, import_fs66, import_path71, DashboardWs;
 var init_ws = __esm({
   "packages/relay/src/dashboard/ws.ts"() {
     "use strict";
     import_ws3 = require("ws");
-    import_fs64 = require("fs");
     import_fs65 = require("fs");
-    import_path70 = require("path");
+    import_fs66 = require("fs");
+    import_path71 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -31977,15 +32352,15 @@ var init_ws = __esm({
       /** Start watching mcp.log for new lines and broadcasting them to connected clients. */
       startLogWatcher(projectRoot) {
         this.stopLogWatcher();
-        this.logPath = (0, import_path70.join)(projectRoot, ".gossip", "mcp.log");
-        if (!(0, import_fs64.existsSync)(this.logPath)) return;
+        this.logPath = (0, import_path71.join)(projectRoot, ".gossip", "mcp.log");
+        if (!(0, import_fs65.existsSync)(this.logPath)) return;
         try {
-          this.logOffset = (0, import_fs64.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs65.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs65.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs66.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -32002,7 +32377,7 @@ var init_ws = __esm({
         if (this.logReading) return;
         this.logReading = true;
         try {
-          const currentSize = (0, import_fs64.statSync)(this.logPath).size;
+          const currentSize = (0, import_fs65.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -32015,7 +32390,7 @@ var init_ws = __esm({
           const readFrom = capped ? (this.logCarry = "", this.logCapped = true, currentSize - 65536) : (this.logCapped = false, this.logOffset);
           let stream;
           try {
-            stream = (0, import_fs64.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
+            stream = (0, import_fs65.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
           } catch {
             this.logReading = false;
             return;
@@ -32678,14 +33053,14 @@ __export(sandbox_exports, {
 });
 function rotateIfNeeded2(filePath, maxBytes) {
   try {
-    const st = (0, import_fs66.statSync)(filePath);
+    const st = (0, import_fs67.statSync)(filePath);
     if (st.size < maxBytes) return;
     const rotated = filePath + ".1";
     try {
-      if ((0, import_fs66.existsSync)(rotated)) (0, import_fs66.unlinkSync)(rotated);
+      if ((0, import_fs67.existsSync)(rotated)) (0, import_fs67.unlinkSync)(rotated);
     } catch {
     }
-    (0, import_fs66.renameSync)(filePath, rotated);
+    (0, import_fs67.renameSync)(filePath, rotated);
   } catch {
   }
 }
@@ -32758,9 +33133,9 @@ Tests passing is NOT sufficient verification \u2014 the 2026-04-22 incident had
 }
 function readSandboxMode(projectRoot) {
   try {
-    const p = (0, import_path71.join)(projectRoot, ".gossip", "config.json");
-    if (!(0, import_fs66.existsSync)(p)) return "warn";
-    const raw = JSON.parse((0, import_fs66.readFileSync)(p, "utf-8"));
+    const p = (0, import_path72.join)(projectRoot, ".gossip", "config.json");
+    if (!(0, import_fs67.existsSync)(p)) return "warn";
+    const raw = JSON.parse((0, import_fs67.readFileSync)(p, "utf-8"));
     const mode = raw?.sandboxEnforcement;
     if (mode === "off" || mode === "warn" || mode === "block") return mode;
     return "warn";
@@ -32770,8 +33145,8 @@ function readSandboxMode(projectRoot) {
 }
 function recordDispatchMetadata(projectRoot, meta3) {
   try {
-    const dir = (0, import_path71.join)(projectRoot, ".gossip");
-    (0, import_fs66.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path72.join)(projectRoot, ".gossip");
+    (0, import_fs67.mkdirSync)(dir, { recursive: true });
     const snapshotted = { ...meta3 };
     if (meta3.writeMode === "scoped" || meta3.writeMode === "worktree") {
       try {
@@ -32789,15 +33164,15 @@ function recordDispatchMetadata(projectRoot, meta3) {
       } catch {
       }
     }
-    (0, import_fs66.appendFileSync)((0, import_path71.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
+    (0, import_fs67.appendFileSync)((0, import_path72.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
   } catch {
   }
 }
 function updateDispatchMetadata(projectRoot, taskId, patch) {
   try {
-    const p = (0, import_path71.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs66.existsSync)(p)) return false;
-    const raw = (0, import_fs66.readFileSync)(p, "utf-8");
+    const p = (0, import_path72.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs67.existsSync)(p)) return false;
+    const raw = (0, import_fs67.readFileSync)(p, "utf-8");
     const lines = raw.split("\n");
     let patched = false;
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -32815,7 +33190,7 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
       }
     }
     if (!patched) return false;
-    (0, import_fs66.writeFileSync)(p, lines.join("\n"));
+    (0, import_fs67.writeFileSync)(p, lines.join("\n"));
     return true;
   } catch {
     return false;
@@ -32824,14 +33199,14 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
 function stampTaskSentinel(projectRoot, taskId) {
   if (!taskId) return null;
   try {
-    const dir = (0, import_path71.join)(projectRoot, ".gossip", SENTINEL_DIR);
-    (0, import_fs66.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path72.join)(projectRoot, ".gossip", SENTINEL_DIR);
+    (0, import_fs67.mkdirSync)(dir, { recursive: true });
     const slug = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const path7 = (0, import_path71.join)(dir, `${slug}.sentinel`);
-    const fd = (0, import_fs66.openSync)(path7, "w");
-    (0, import_fs66.closeSync)(fd);
+    const path7 = (0, import_path72.join)(dir, `${slug}.sentinel`);
+    const fd = (0, import_fs67.openSync)(path7, "w");
+    (0, import_fs67.closeSync)(fd);
     const stampTime = new Date(Date.now() - 2e3);
-    (0, import_fs66.utimesSync)(path7, stampTime, stampTime);
+    (0, import_fs67.utimesSync)(path7, stampTime, stampTime);
     return path7;
   } catch {
     return null;
@@ -32840,15 +33215,15 @@ function stampTaskSentinel(projectRoot, taskId) {
 function cleanupTaskSentinel(sentinelPath) {
   if (!sentinelPath) return;
   try {
-    (0, import_fs66.unlinkSync)(sentinelPath);
+    (0, import_fs67.unlinkSync)(sentinelPath);
   } catch {
   }
 }
 function lookupDispatchMetadata(projectRoot, taskId) {
   try {
-    const p = (0, import_path71.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs66.existsSync)(p)) return null;
-    const raw = (0, import_fs66.readFileSync)(p, "utf-8");
+    const p = (0, import_path72.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs67.existsSync)(p)) return null;
+    const raw = (0, import_fs67.readFileSync)(p, "utf-8");
     const lines = raw.split("\n").filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
@@ -32880,21 +33255,21 @@ function parseGitStatus(porcelain) {
 function normalizeScope(scope, projectRoot) {
   let s = scope.trim();
   if (!s) return "";
-  if ((0, import_path71.isAbsolute)(s)) {
-    s = (0, import_path71.relative)(projectRoot, s);
+  if ((0, import_path72.isAbsolute)(s)) {
+    s = (0, import_path72.relative)(projectRoot, s);
   } else if (s.startsWith("./")) {
     s = s.slice(2);
   }
-  s = (0, import_path71.normalize)(s).replace(/\/+$/, "");
+  s = (0, import_path72.normalize)(s).replace(/\/+$/, "");
   if (s === "." || s === "") return "";
   return s;
 }
 function isInsideScope(filePath, scope) {
   if (!scope) return true;
-  const f = (0, import_path71.normalize)(filePath).replace(/^\.\//, "");
+  const f = (0, import_path72.normalize)(filePath).replace(/^\.\//, "");
   const s = scope.replace(/^\.\//, "").replace(/\/+$/, "");
   if (f === s) return true;
-  return f.startsWith(s + "/") || f.startsWith(s + import_path71.sep);
+  return f.startsWith(s + "/") || f.startsWith(s + import_path72.sep);
 }
 function detectBoundaryEscapes(meta3, modifiedFiles, projectRoot) {
   const mode = meta3.writeMode;
@@ -32955,8 +33330,8 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
   } catch {
   }
   try {
-    const dir = (0, import_path71.join)(projectRoot, ".gossip");
-    (0, import_fs66.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path72.join)(projectRoot, ".gossip");
+    (0, import_fs67.mkdirSync)(dir, { recursive: true });
     const line = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       taskId: meta3.taskId,
@@ -32967,15 +33342,15 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
       action: mode
       // "warn" or "block"
     };
-    const escapeFile = (0, import_path71.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path72.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs66.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
+    (0, import_fs67.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
   } catch {
   }
 }
 function canonicalize(p) {
   try {
-    return (0, import_path71.resolve)(p).replace(/\/+$/, "") || "/";
+    return (0, import_path72.resolve)(p).replace(/\/+$/, "") || "/";
   } catch {
     return p.replace(/\/+$/, "") || "/";
   }
@@ -33186,7 +33561,7 @@ function buildAuditExclusions(projectRoot, ownWorktree, scope) {
     for (const v of expandTmpVariants(wt)) excl.add(v);
   }
   if (scope) {
-    const s = canonicalize((0, import_path71.join)(projectRoot, scope));
+    const s = canonicalize((0, import_path72.join)(projectRoot, scope));
     for (const v of expandTmpVariants(s)) excl.add(v);
   }
   return Array.from(excl);
@@ -33240,12 +33615,12 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
     return { violations: [], skipped: "win32" };
   }
   const sentinel = meta3.sentinelPath;
-  if (!sentinel || !(0, import_fs66.existsSync)(sentinel)) {
+  if (!sentinel || !(0, import_fs67.existsSync)(sentinel)) {
     return { violations: [], skipped: "sentinel missing" };
   }
   let sentinelMtimeMs = 0;
   try {
-    sentinelMtimeMs = (0, import_fs66.statSync)(sentinel).mtimeMs;
+    sentinelMtimeMs = (0, import_fs67.statSync)(sentinel).mtimeMs;
   } catch {
   }
   if (sentinelMtimeMs === 0) {
@@ -33257,11 +33632,11 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   );
   const exclusions = buildAuditExclusions(projectRoot, meta3.worktreePath, options.scope);
   const findBin = options.findBinary ?? "find";
-  const sentinelDir = canonicalize((0, import_path71.join)(projectRoot, ".gossip", SENTINEL_DIR));
+  const sentinelDir = canonicalize((0, import_path72.join)(projectRoot, ".gossip", SENTINEL_DIR));
   const mainSet = /* @__PURE__ */ new Set();
   const sensitiveSet = /* @__PURE__ */ new Set();
   for (const root of scanRoots) {
-    if (!(0, import_fs66.existsSync)(root)) continue;
+    if (!(0, import_fs67.existsSync)(root)) continue;
     const canonRoot = canonicalize(root);
     const allExcl = [...exclusions, ...expandTmpVariants(sentinelDir)];
     const args = buildFindPruneArgs(canonRoot, allExcl, sentinel);
@@ -33297,7 +33672,7 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   }
   const sensitiveTargets = buildSensitiveTargets(platform2);
   for (const target of sensitiveTargets) {
-    if (!(0, import_fs66.existsSync)(target.path)) continue;
+    if (!(0, import_fs67.existsSync)(target.path)) continue;
     const canonTarget = canonicalize(target.path);
     const args = buildSensitiveFindArgs(
       canonTarget,
@@ -33353,8 +33728,8 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
 }
 function recordLayer3Violations(projectRoot, meta3, violations, source) {
   try {
-    const dir = (0, import_path71.join)(projectRoot, ".gossip");
-    (0, import_fs66.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path72.join)(projectRoot, ".gossip");
+    (0, import_fs67.mkdirSync)(dir, { recursive: true });
     const ts2 = (/* @__PURE__ */ new Date()).toISOString();
     const lines = violations.map(
       (path7) => JSON.stringify({
@@ -33365,9 +33740,9 @@ function recordLayer3Violations(projectRoot, meta3, violations, source) {
         source
       })
     );
-    const escapeFile = (0, import_path71.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path72.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs66.appendFileSync)(escapeFile, lines.join("\n") + "\n");
+    (0, import_fs67.appendFileSync)(escapeFile, lines.join("\n") + "\n");
   } catch {
   }
   if (source === "layer3-sensitive" && violations.length > 0) {
@@ -33424,14 +33799,14 @@ function runLayer3Audit(projectRoot, taskId) {
   }
   return { blockError, warnPrefix };
 }
-var import_child_process10, import_fs66, import_os5, import_path71, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SENTINEL_DIR, MAX_BOUNDARY_ESCAPE_BYTES, MAX_PREMISE_VERIFICATION_BYTES, BOUNDARY_ALLOWLIST, SYSTEM_PREFIXES, SCOPE_NOTE, NUMERAL, TARGETS, MODIFIER, CLAIM_PATTERNS, UNVERIFIED_NOTE_SENTINEL, __test__;
+var import_child_process10, import_fs67, import_os5, import_path72, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SENTINEL_DIR, MAX_BOUNDARY_ESCAPE_BYTES, MAX_PREMISE_VERIFICATION_BYTES, BOUNDARY_ALLOWLIST, SYSTEM_PREFIXES, SCOPE_NOTE, NUMERAL, TARGETS, MODIFIER, CLAIM_PATTERNS, UNVERIFIED_NOTE_SENTINEL, __test__;
 var init_sandbox2 = __esm({
   "apps/cli/src/sandbox.ts"() {
     "use strict";
     import_child_process10 = require("child_process");
-    import_fs66 = require("fs");
+    import_fs67 = require("fs");
     import_os5 = require("os");
-    import_path71 = require("path");
+    import_path72 = require("path");
     METADATA_FILE = "dispatch-metadata.jsonl";
     BOUNDARY_ESCAPE_FILE = "boundary-escapes.jsonl";
     SENTINEL_DIR = "sentinels";
@@ -33502,7 +33877,7 @@ __export(dispatch_prompt_storage_exports, {
   writeDispatchPrompt: () => writeDispatchPrompt
 });
 function dispatchPromptsDir(projectRoot) {
-  return (0, import_path72.join)(projectRoot, ".gossip", DISPATCH_PROMPTS_SUBDIR);
+  return (0, import_path73.join)(projectRoot, ".gossip", DISPATCH_PROMPTS_SUBDIR);
 }
 function assertSafeTaskId(taskId) {
   if (typeof taskId !== "string" || taskId.length === 0) {
@@ -33515,35 +33890,35 @@ function assertSafeTaskId(taskId) {
 function writeDispatchPrompt(projectRoot, taskId, body) {
   assertSafeTaskId(taskId);
   const dir = dispatchPromptsDir(projectRoot);
-  (0, import_fs67.mkdirSync)(dir, { recursive: true });
-  const finalPath = (0, import_path72.join)(dir, `${taskId}.txt`);
-  const tmpPath = (0, import_path72.join)(dir, `${taskId}.txt.${(0, import_crypto27.randomUUID)().slice(0, 8)}.tmp`);
+  (0, import_fs68.mkdirSync)(dir, { recursive: true });
+  const finalPath = (0, import_path73.join)(dir, `${taskId}.txt`);
+  const tmpPath = (0, import_path73.join)(dir, `${taskId}.txt.${(0, import_crypto27.randomUUID)().slice(0, 8)}.tmp`);
   try {
-    (0, import_fs67.writeFileSync)(tmpPath, body, "utf8");
-    (0, import_fs67.renameSync)(tmpPath, finalPath);
+    (0, import_fs68.writeFileSync)(tmpPath, body, "utf8");
+    (0, import_fs68.renameSync)(tmpPath, finalPath);
   } catch (err) {
     try {
-      (0, import_fs67.unlinkSync)(tmpPath);
+      (0, import_fs68.unlinkSync)(tmpPath);
     } catch {
     }
     throw err;
   }
-  return (0, import_path72.resolve)(finalPath);
+  return (0, import_path73.resolve)(finalPath);
 }
 function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TTL_MS, capBytes = DISPATCH_PROMPT_CAP_BYTES) {
   const dir = dispatchPromptsDir(projectRoot);
-  if (!(0, import_fs67.existsSync)(dir)) return { evictedAge: 0, evictedCap: 0 };
+  if (!(0, import_fs68.existsSync)(dir)) return { evictedAge: 0, evictedCap: 0 };
   const now = Date.now();
   let entries = [];
   try {
-    for (const name of (0, import_fs67.readdirSync)(dir)) {
-      const path7 = (0, import_path72.join)(dir, name);
+    for (const name of (0, import_fs68.readdirSync)(dir)) {
+      const path7 = (0, import_path73.join)(dir, name);
       try {
-        const st = (0, import_fs67.statSync)(path7);
+        const st = (0, import_fs68.statSync)(path7);
         if (!st.isFile()) continue;
         entries.push({ name, path: path7, mtimeMs: st.mtimeMs, size: st.size });
       } catch (err) {
-        process.stderr.write(`[gossipcat] dispatch-prompt stat failed for ${(0, import_path72.basename)(path7)}: ${err.message}
+        process.stderr.write(`[gossipcat] dispatch-prompt stat failed for ${(0, import_path73.basename)(path7)}: ${err.message}
 `);
       }
     }
@@ -33557,7 +33932,7 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
   for (const e of entries) {
     if (now - e.mtimeMs > maxAgeMs) {
       try {
-        (0, import_fs67.unlinkSync)(e.path);
+        (0, import_fs68.unlinkSync)(e.path);
         evictedAge++;
       } catch (err) {
         process.stderr.write(`[gossipcat] dispatch-prompt unlink failed for ${e.name}: ${err.message}
@@ -33574,7 +33949,7 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
     for (const e of survivors) {
       if (totalBytes <= capBytes) break;
       try {
-        (0, import_fs67.unlinkSync)(e.path);
+        (0, import_fs68.unlinkSync)(e.path);
         totalBytes -= e.size;
         evictedCap++;
       } catch (err) {
@@ -33587,18 +33962,18 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
 }
 function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAULT_PROMPT_TTL_MS) {
   const dir = dispatchPromptsDir(projectRoot);
-  if (!(0, import_fs67.existsSync)(dir)) return { orphans: 0, aged: 0 };
+  if (!(0, import_fs68.existsSync)(dir)) return { orphans: 0, aged: 0 };
   const now = Date.now();
   let orphans = 0;
   let aged = 0;
   try {
-    for (const name of (0, import_fs67.readdirSync)(dir)) {
+    for (const name of (0, import_fs68.readdirSync)(dir)) {
       if (!name.endsWith(".txt")) continue;
       const taskId = name.slice(0, -4);
-      const path7 = (0, import_path72.join)(dir, name);
+      const path7 = (0, import_path73.join)(dir, name);
       let mtimeMs = 0;
       try {
-        mtimeMs = (0, import_fs67.statSync)(path7).mtimeMs;
+        mtimeMs = (0, import_fs68.statSync)(path7).mtimeMs;
       } catch {
         continue;
       }
@@ -33606,7 +33981,7 @@ function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAUL
       const orphaned = !knownTaskIds.has(taskId);
       if (tooOld || orphaned) {
         try {
-          (0, import_fs67.unlinkSync)(path7);
+          (0, import_fs68.unlinkSync)(path7);
           if (orphaned) orphans++;
           if (tooOld) aged++;
         } catch (err) {
@@ -33623,14 +33998,14 @@ function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAUL
 }
 function dispatchPromptPath(projectRoot, taskId) {
   assertSafeTaskId(taskId);
-  return (0, import_path72.resolve)((0, import_path72.join)(dispatchPromptsDir(projectRoot), `${taskId}.txt`));
+  return (0, import_path73.resolve)((0, import_path73.join)(dispatchPromptsDir(projectRoot), `${taskId}.txt`));
 }
-var import_fs67, import_path72, import_crypto27, SAFE_TASK_ID, DISPATCH_PROMPT_CAP_BYTES, DEFAULT_PROMPT_TTL_MS, DISPATCH_PROMPTS_SUBDIR;
+var import_fs68, import_path73, import_crypto27, SAFE_TASK_ID, DISPATCH_PROMPT_CAP_BYTES, DEFAULT_PROMPT_TTL_MS, DISPATCH_PROMPTS_SUBDIR;
 var init_dispatch_prompt_storage = __esm({
   "apps/cli/src/handlers/dispatch-prompt-storage.ts"() {
     "use strict";
-    import_fs67 = require("fs");
-    import_path72 = require("path");
+    import_fs68 = require("fs");
+    import_path73 = require("path");
     import_crypto27 = require("crypto");
     SAFE_TASK_ID = /^(?!.*\.\.)[A-Za-z0-9._-]{1,64}$/;
     DISPATCH_PROMPT_CAP_BYTES = 100 * 1024 * 1024;
@@ -33684,9 +34059,9 @@ function getCommitRange(preSha, postSha) {
 function appendViolationRecord(record2) {
   try {
     const projectRoot = process.cwd();
-    (0, import_fs68.mkdirSync)((0, import_path73.join)(projectRoot, ".gossip"), { recursive: true });
-    const logPath = (0, import_path73.join)(projectRoot, PROCESS_VIOLATIONS_FILE);
-    (0, import_fs68.appendFileSync)(logPath, JSON.stringify(record2) + "\n", "utf8");
+    (0, import_fs69.mkdirSync)((0, import_path74.join)(projectRoot, ".gossip"), { recursive: true });
+    const logPath = (0, import_path74.join)(projectRoot, PROCESS_VIOLATIONS_FILE);
+    (0, import_fs69.appendFileSync)(logPath, JSON.stringify(record2) + "\n", "utf8");
   } catch (err) {
     process.stderr.write(`[gossipcat] ref-allowlist: failed to append violation record: ${err.message}
 `);
@@ -33736,12 +34111,12 @@ Full audit trail at .gossip/process-violations.jsonl
 `
   );
 }
-var import_fs68, import_path73, import_child_process11, PROCESS_VIOLATIONS_FILE;
+var import_fs69, import_path74, import_child_process11, PROCESS_VIOLATIONS_FILE;
 var init_ref_allowlist_detection = __esm({
   "apps/cli/src/handlers/ref-allowlist-detection.ts"() {
     "use strict";
-    import_fs68 = require("fs");
-    import_path73 = require("path");
+    import_fs69 = require("fs");
+    import_path74 = require("path");
     import_child_process11 = require("child_process");
     PROCESS_VIOLATIONS_FILE = ".gossip/process-violations.jsonl";
   }
@@ -33827,10 +34202,10 @@ function taskWasInConsensusRound(taskId, agentId, rounds, recentTaskIds, recentA
 function appendRelayWarning(projectRoot, entry) {
   try {
     const { appendFileSync: appendFileSync21, mkdirSync: mkdirSync41 } = require("fs");
-    const { join: join82 } = require("path");
-    const dir = join82(projectRoot, ".gossip");
+    const { join: join83 } = require("path");
+    const dir = join83(projectRoot, ".gossip");
     mkdirSync41(dir, { recursive: true });
-    appendFileSync21(join82(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
+    appendFileSync21(join83(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
   } catch (err) {
     process.stderr.write(`[gossipcat] append relay-warning failed: ${err.message}
 `);
@@ -34557,7 +34932,7 @@ function computeSkillFingerprint(paths) {
   const pairs = [];
   for (const p of paths) {
     try {
-      const st = (0, import_fs69.statSync)(p);
+      const st = (0, import_fs70.statSync)(p);
       pairs.push(`${p}:${st.mtimeMs}`);
     } catch {
     }
@@ -34592,7 +34967,7 @@ function setCachedPrompt(k, e) {
       const evicted = promptCache.get(oldestKey);
       promptCache.delete(oldestKey);
       try {
-        (0, import_fs69.unlinkSync)(evicted.skillsSectionPath);
+        (0, import_fs70.unlinkSync)(evicted.skillsSectionPath);
       } catch {
       }
       const evictedAgentId = oldestKey.split("|")[0] ?? "_system";
@@ -34606,7 +34981,7 @@ function invalidateAgent(agentId) {
     if (k.startsWith(`${agentId}|`)) {
       promptCache.delete(k);
       try {
-        (0, import_fs69.unlinkSync)(v.skillsSectionPath);
+        (0, import_fs70.unlinkSync)(v.skillsSectionPath);
       } catch {
       }
       emitCacheEvictedSignal(agentId, "invalidation");
@@ -34619,7 +34994,7 @@ function invalidateAll() {
   const n = promptCache.size;
   for (const v of promptCache.values()) {
     try {
-      (0, import_fs69.unlinkSync)(v.skillsSectionPath);
+      (0, import_fs70.unlinkSync)(v.skillsSectionPath);
     } catch {
     }
   }
@@ -34666,29 +35041,29 @@ function writeCachedSkillsSection(projectRoot, fingerprint2, skillsSection) {
   if (!/^[a-f0-9]{64}$/.test(fingerprint2)) {
     throw new Error(`writeCachedSkillsSection: invalid fingerprint ${JSON.stringify(fingerprint2).slice(0, 32)}`);
   }
-  const dir = (0, import_path74.join)(projectRoot, ".gossip", "dispatch-prompts", "cache");
-  (0, import_fs69.mkdirSync)(dir, { recursive: true });
-  const finalPath = (0, import_path74.join)(dir, `skills-${fingerprint2}.txt`);
-  const tmpPath = (0, import_path74.join)(dir, `skills-${fingerprint2}.txt.${(0, import_crypto30.randomUUID)().slice(0, 8)}.tmp`);
+  const dir = (0, import_path75.join)(projectRoot, ".gossip", "dispatch-prompts", "cache");
+  (0, import_fs70.mkdirSync)(dir, { recursive: true });
+  const finalPath = (0, import_path75.join)(dir, `skills-${fingerprint2}.txt`);
+  const tmpPath = (0, import_path75.join)(dir, `skills-${fingerprint2}.txt.${(0, import_crypto30.randomUUID)().slice(0, 8)}.tmp`);
   try {
-    (0, import_fs69.writeFileSync)(tmpPath, skillsSection, "utf8");
-    (0, import_fs69.renameSync)(tmpPath, finalPath);
+    (0, import_fs70.writeFileSync)(tmpPath, skillsSection, "utf8");
+    (0, import_fs70.renameSync)(tmpPath, finalPath);
   } catch (err) {
     try {
-      (0, import_fs69.unlinkSync)(tmpPath);
+      (0, import_fs70.unlinkSync)(tmpPath);
     } catch {
     }
     throw err;
   }
-  return (0, import_path74.resolve)(finalPath);
+  return (0, import_path75.resolve)(finalPath);
 }
-var import_crypto29, import_fs69, import_path74, import_crypto30, DISPATCH_PROMPT_CACHE_MAX_ENTRIES, promptCache;
+var import_crypto29, import_fs70, import_path75, import_crypto30, DISPATCH_PROMPT_CACHE_MAX_ENTRIES, promptCache;
 var init_dispatch_prompt_cache = __esm({
   "apps/cli/src/handlers/dispatch-prompt-cache.ts"() {
     "use strict";
     import_crypto29 = require("crypto");
-    import_fs69 = require("fs");
-    import_path74 = require("path");
+    import_fs70 = require("fs");
+    import_path75 = require("path");
     import_crypto30 = require("crypto");
     DISPATCH_PROMPT_CACHE_MAX_ENTRIES = 64;
     promptCache = /* @__PURE__ */ new Map();
@@ -34711,18 +35086,18 @@ __export(config_exports, {
 function findConfigPath(projectRoot) {
   const root = projectRoot || process.cwd();
   const candidates = [
-    (0, import_path75.resolve)(root, ".gossip", "config.json"),
-    (0, import_path75.resolve)(root, "gossip.agents.json"),
-    (0, import_path75.resolve)(root, "gossip.agents.yaml"),
-    (0, import_path75.resolve)(root, "gossip.agents.yml")
+    (0, import_path76.resolve)(root, ".gossip", "config.json"),
+    (0, import_path76.resolve)(root, "gossip.agents.json"),
+    (0, import_path76.resolve)(root, "gossip.agents.yaml"),
+    (0, import_path76.resolve)(root, "gossip.agents.yml")
   ];
   for (const p of candidates) {
-    if ((0, import_fs70.existsSync)(p)) return p;
+    if ((0, import_fs71.existsSync)(p)) return p;
   }
   return null;
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs70.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs71.readFileSync)(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -34812,19 +35187,19 @@ function configToAgentConfigs(config2) {
 }
 function loadClaudeSubagents(projectRoot, existingIds) {
   const root = projectRoot || process.cwd();
-  const agentsDir = (0, import_path75.join)(root, ".claude", "agents");
-  if (!(0, import_fs70.existsSync)(agentsDir)) return [];
+  const agentsDir = (0, import_path76.join)(root, ".claude", "agents");
+  if (!(0, import_fs71.existsSync)(agentsDir)) return [];
   let files;
   try {
-    files = (0, import_fs70.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
+    files = (0, import_fs71.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const agents = [];
   for (const file2 of files) {
-    const filePath = (0, import_path75.join)(agentsDir, file2);
+    const filePath = (0, import_path76.join)(agentsDir, file2);
     try {
-      const content = (0, import_fs70.readFileSync)(filePath, "utf-8");
+      const content = (0, import_fs71.readFileSync)(filePath, "utf-8");
       const frontmatter = content.match(/^---\n([\s\S]*?)\n---/);
       if (!frontmatter) continue;
       const fm = frontmatter[1];
@@ -34879,12 +35254,12 @@ function inferSkills(description, name) {
   if (skills.length === 0) skills.push("general");
   return skills;
 }
-var import_fs70, import_path75, VALID_PROVIDERS, VALID_MAIN_PROVIDERS, CLAUDE_MODEL_MAP;
+var import_fs71, import_path76, VALID_PROVIDERS, VALID_MAIN_PROVIDERS, CLAUDE_MODEL_MAP;
 var init_config = __esm({
   "apps/cli/src/config.ts"() {
     "use strict";
-    import_fs70 = require("fs");
-    import_path75 = require("path");
+    import_fs71 = require("fs");
+    import_path76 = require("path");
     VALID_PROVIDERS = ["anthropic", "openai", "openclaw", "google", "local", "native", "none"];
     VALID_MAIN_PROVIDERS = VALID_PROVIDERS.filter((p) => p !== "native");
     CLAUDE_MODEL_MAP = {
@@ -34954,11 +35329,11 @@ function startConsensusTimeout(consensusId) {
       const report = await engine.synthesizeWithCrossReview(snapshot.allResults, allEntries, consensusId, snapshot.relayCrossReviewSkipped);
       try {
         const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41 } = require("fs");
-        const { join: join82 } = require("path");
-        const reportsDir = join82(process.cwd(), ".gossip", "consensus-reports");
+        const { join: join83 } = require("path");
+        const reportsDir = join83(process.cwd(), ".gossip", "consensus-reports");
         mkdirSync41(reportsDir, { recursive: true });
         const topic = snapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
-        writeFileSync34(join82(reportsDir, `${consensusId}.json`), JSON.stringify({
+        writeFileSync34(join83(reportsDir, `${consensusId}.json`), JSON.stringify({
           id: consensusId,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           topic,
@@ -35126,10 +35501,10 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
     );
     try {
       const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41 } = require("fs");
-      const { join: join82 } = require("path");
-      const reportsDir = join82(process.cwd(), ".gossip", "consensus-reports");
+      const { join: join83 } = require("path");
+      const reportsDir = join83(process.cwd(), ".gossip", "consensus-reports");
       mkdirSync41(reportsDir, { recursive: true });
-      const reportPath = join82(reportsDir, `${consensus_id}.json`);
+      const reportPath = join83(reportsDir, `${consensus_id}.json`);
       const topic = synthSnapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
       writeFileSync34(reportPath, JSON.stringify({
         id: consensus_id,
@@ -35175,8 +35550,8 @@ function persistPendingConsensus() {
     const projectRoot = ctx.mainAgent?.projectRoot;
     if (!projectRoot) return;
     const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41 } = require("fs");
-    const { join: join82 } = require("path");
-    const dir = join82(projectRoot, ".gossip");
+    const { join: join83 } = require("path");
+    const dir = join83(projectRoot, ".gossip");
     mkdirSync41(dir, { recursive: true });
     const rounds = {};
     for (const [id, round] of ctx.pendingConsensusRounds) {
@@ -35202,7 +35577,7 @@ function persistPendingConsensus() {
         resolutionRoots: round.resolutionRoots ? [...round.resolutionRoots] : void 0
       };
     }
-    writeFileSync34(join82(dir, CONSENSUS_FILE), JSON.stringify(rounds));
+    writeFileSync34(join83(dir, CONSENSUS_FILE), JSON.stringify(rounds));
   } catch (err) {
     process.stderr.write(`[gossipcat] persistPendingConsensus failed: ${err.message}
 `);
@@ -35210,11 +35585,11 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync69, readFileSync: readFileSync62, unlinkSync: unlinkSync13 } = require("fs");
-    const { join: join82 } = require("path");
-    const filePath = join82(projectRoot, ".gossip", CONSENSUS_FILE);
-    if (!existsSync69(filePath)) return;
-    const raw = JSON.parse(readFileSync62(filePath, "utf-8"));
+    const { existsSync: existsSync70, readFileSync: readFileSync64, unlinkSync: unlinkSync13 } = require("fs");
+    const { join: join83 } = require("path");
+    const filePath = join83(projectRoot, ".gossip", CONSENSUS_FILE);
+    if (!existsSync70(filePath)) return;
+    const raw = JSON.parse(readFileSync64(filePath, "utf-8"));
     const now = Date.now();
     for (const [id, data] of Object.entries(raw)) {
       if (now > data.deadline + 3e5) {
@@ -35322,31 +35697,31 @@ __export(check_effectiveness_runner_exports, {
   runCheckEffectivenessForAllSkills: () => runCheckEffectivenessForAllSkills
 });
 function writeHealthAtomic(projectRoot, record2) {
-  const dir = (0, import_path77.join)(projectRoot, ".gossip");
-  const finalPath = (0, import_path77.join)(dir, "skill-runner-health.json");
+  const dir = (0, import_path78.join)(projectRoot, ".gossip");
+  const finalPath = (0, import_path78.join)(dir, "skill-runner-health.json");
   const tmpPath = finalPath + ".tmp";
   try {
-    (0, import_fs73.mkdirSync)(dir, { recursive: true });
-    (0, import_fs73.writeFileSync)(tmpPath, JSON.stringify(record2, null, 2));
-    (0, import_fs73.renameSync)(tmpPath, finalPath);
+    (0, import_fs74.mkdirSync)(dir, { recursive: true });
+    (0, import_fs74.writeFileSync)(tmpPath, JSON.stringify(record2, null, 2));
+    (0, import_fs74.renameSync)(tmpPath, finalPath);
   } catch (e) {
     process.stderr.write(`[gossipcat] checkEffectiveness: health write failed: ${e.message}
 `);
     try {
-      if ((0, import_fs73.existsSync)(tmpPath)) (0, import_fs73.unlinkSync)(tmpPath);
+      if ((0, import_fs74.existsSync)(tmpPath)) (0, import_fs74.unlinkSync)(tmpPath);
     } catch {
     }
   }
 }
 async function runCheckEffectivenessForAllSkills(opts) {
   const startedAt = Date.now();
-  const baseDir = (0, import_path77.join)(opts.projectRoot, ".gossip", "agents");
+  const baseDir = (0, import_path78.join)(opts.projectRoot, ".gossip", "agents");
   let agentDirs = [];
   let canonicalBaseDir;
-  if ((0, import_fs73.existsSync)(baseDir)) {
+  if ((0, import_fs74.existsSync)(baseDir)) {
     try {
-      canonicalBaseDir = (0, import_fs73.realpathSync)(baseDir);
-      agentDirs = (0, import_fs73.readdirSync)(canonicalBaseDir);
+      canonicalBaseDir = (0, import_fs74.realpathSync)(baseDir);
+      agentDirs = (0, import_fs74.readdirSync)(canonicalBaseDir);
     } catch {
     }
   }
@@ -35365,11 +35740,11 @@ async function runCheckEffectivenessForAllSkills(opts) {
     for (const agentId of agentDirs) {
       if (agentId.startsWith("_")) continue;
       if (!SAFE_NAME2.test(agentId)) continue;
-      const skillsDir = (0, import_path77.join)(canonicalBaseDir, agentId, "skills");
-      if (!(0, import_fs73.existsSync)(skillsDir)) continue;
+      const skillsDir = (0, import_path78.join)(canonicalBaseDir, agentId, "skills");
+      if (!(0, import_fs74.existsSync)(skillsDir)) continue;
       let canonicalSkillsDir;
       try {
-        canonicalSkillsDir = (0, import_fs73.realpathSync)(skillsDir);
+        canonicalSkillsDir = (0, import_fs74.realpathSync)(skillsDir);
       } catch {
         continue;
       }
@@ -35380,7 +35755,7 @@ async function runCheckEffectivenessForAllSkills(opts) {
       }
       const role = opts.registryGet(agentId)?.role;
       if (role === "implementer") continue;
-      const files = (0, import_fs73.readdirSync)(canonicalSkillsDir).filter((f) => f.endsWith(".md"));
+      const files = (0, import_fs74.readdirSync)(canonicalSkillsDir).filter((f) => f.endsWith(".md"));
       for (const file2 of files) {
         const category = file2.replace(/\.md$/, "");
         if (!SAFE_NAME2.test(category)) continue;
@@ -35427,12 +35802,12 @@ async function runCheckEffectivenessForAllSkills(opts) {
     last_error: lastError
   });
 }
-var import_fs73, import_path77, SAFE_NAME2;
+var import_fs74, import_path78, SAFE_NAME2;
 var init_check_effectiveness_runner = __esm({
   "apps/cli/src/handlers/check-effectiveness-runner.ts"() {
     "use strict";
-    import_fs73 = require("fs");
-    import_path77 = require("path");
+    import_fs74 = require("fs");
+    import_path78 = require("path");
     init_dispatch_prompt_cache();
     SAFE_NAME2 = /^(?!.*\.\.)[a-zA-Z0-9._-]+$/;
   }
@@ -35445,20 +35820,20 @@ __export(skill_develop_audit_exports, {
 });
 function appendSkillDevelopAudit(entry) {
   try {
-    const gossipDir = (0, import_path78.join)(process.cwd(), ".gossip");
-    (0, import_fs74.mkdirSync)(gossipDir, { recursive: true });
+    const gossipDir = (0, import_path79.join)(process.cwd(), ".gossip");
+    (0, import_fs75.mkdirSync)(gossipDir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs74.appendFileSync)((0, import_path78.join)(gossipDir, AUDIT_FILE2), line);
-    (0, import_fs74.appendFileSync)((0, import_path78.join)(gossipDir, LEGACY_FILE), line);
+    (0, import_fs75.appendFileSync)((0, import_path79.join)(gossipDir, AUDIT_FILE2), line);
+    (0, import_fs75.appendFileSync)((0, import_path79.join)(gossipDir, LEGACY_FILE), line);
   } catch {
   }
 }
-var import_fs74, import_path78, AUDIT_FILE2, LEGACY_FILE;
+var import_fs75, import_path79, AUDIT_FILE2, LEGACY_FILE;
 var init_skill_develop_audit = __esm({
   "apps/cli/src/handlers/skill-develop-audit.ts"() {
     "use strict";
-    import_fs74 = require("fs");
-    import_path78 = require("path");
+    import_fs75 = require("fs");
+    import_path79 = require("path");
     AUDIT_FILE2 = "skill-develop-audit.jsonl";
     LEGACY_FILE = "forced-skill-develops.jsonl";
   }
@@ -35469,14 +35844,14 @@ var keychain_exports = {};
 __export(keychain_exports, {
   Keychain: () => Keychain
 });
-var import_child_process12, import_os6, import_fs78, import_path82, import_crypto32, DEFAULT_SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
+var import_child_process12, import_os6, import_fs79, import_path83, import_crypto32, DEFAULT_SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
 var init_keychain = __esm({
   "apps/cli/src/keychain.ts"() {
     "use strict";
     import_child_process12 = require("child_process");
     import_os6 = require("os");
-    import_fs78 = require("fs");
-    import_path82 = require("path");
+    import_fs79 = require("fs");
+    import_path83 = require("path");
     import_crypto32 = require("crypto");
     DEFAULT_SERVICE_NAME = "gossip-mesh";
     VALID_PROVIDERS2 = /^[a-zA-Z0-9_-]{1,32}$/;
@@ -35520,10 +35895,10 @@ var init_keychain = __esm({
         return (0, import_crypto32.pbkdf2Sync)(seed, salt, 6e5, 32, "sha256");
       }
       loadEncryptedFile() {
-        const filePath = (0, import_path82.join)(process.cwd(), ENCRYPTED_FILE);
-        if (!(0, import_fs78.existsSync)(filePath)) return;
+        const filePath = (0, import_path83.join)(process.cwd(), ENCRYPTED_FILE);
+        if (!(0, import_fs79.existsSync)(filePath)) return;
         try {
-          const raw = (0, import_fs78.readFileSync)(filePath);
+          const raw = (0, import_fs79.readFileSync)(filePath);
           if (raw.length < 61) return;
           const salt = raw.subarray(0, 32);
           const iv = raw.subarray(32, 44);
@@ -35541,9 +35916,9 @@ var init_keychain = __esm({
         }
       }
       saveEncryptedFile() {
-        const filePath = (0, import_path82.join)(process.cwd(), ENCRYPTED_FILE);
-        const dir = (0, import_path82.join)(process.cwd(), ".gossip");
-        if (!(0, import_fs78.existsSync)(dir)) (0, import_fs78.mkdirSync)(dir, { recursive: true });
+        const filePath = (0, import_path83.join)(process.cwd(), ENCRYPTED_FILE);
+        const dir = (0, import_path83.join)(process.cwd(), ".gossip");
+        if (!(0, import_fs79.existsSync)(dir)) (0, import_fs79.mkdirSync)(dir, { recursive: true });
         const data = JSON.stringify(Object.fromEntries(this.inMemoryStore));
         const salt = (0, import_crypto32.randomBytes)(32);
         const iv = (0, import_crypto32.randomBytes)(12);
@@ -35551,7 +35926,7 @@ var init_keychain = __esm({
         const cipher = (0, import_crypto32.createCipheriv)(ALGO, key, iv);
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
-        (0, import_fs78.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
+        (0, import_fs79.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
       }
       isKeychainAvailable() {
         if ((0, import_os6.platform)() === "darwin") {
@@ -35651,17 +36026,17 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path83.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path84.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs79.readFileSync)(saltPath, "utf-8").trim();
+    return (0, import_fs80.readFileSync)(saltPath, "utf-8").trim();
   } catch {
     const salt = (0, import_crypto33.randomBytes)(16).toString("hex");
-    (0, import_fs79.mkdirSync)((0, import_path83.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs80.mkdirSync)((0, import_path84.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs79.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs80.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs79.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs80.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
@@ -35711,12 +36086,12 @@ function getProjectId(projectRoot) {
   }
   return (0, import_crypto33.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 16);
 }
-var import_fs79, import_path83, import_crypto33, import_child_process13;
+var import_fs80, import_path84, import_crypto33, import_child_process13;
 var init_identity = __esm({
   "apps/cli/src/identity.ts"() {
     "use strict";
-    import_fs79 = require("fs");
-    import_path83 = require("path");
+    import_fs80 = require("fs");
+    import_path84 = require("path");
     import_crypto33 = require("crypto");
     import_child_process13 = require("child_process");
   }
@@ -35738,9 +36113,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path84.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path85.resolve)(__dirname, "..", "..", "..", "..");
   if (process.env.npm_config_global === "true") return "global";
-  if ((0, import_fs80.existsSync)((0, import_path84.join)(packageRoot, ".git"))) return "git-clone";
+  if ((0, import_fs81.existsSync)((0, import_path85.join)(packageRoot, ".git"))) return "git-clone";
   return "local";
 }
 function updateCommand(method, version2) {
@@ -35795,7 +36170,7 @@ Check your internet connection or visit https://www.npmjs.com/package/gossipcat
   try {
     (0, import_child_process14.execSync)(command, {
       stdio: "inherit",
-      cwd: method === "git-clone" ? (0, import_path84.resolve)(__dirname, "..", "..", "..", "..") : process.cwd(),
+      cwd: method === "git-clone" ? (0, import_path85.resolve)(__dirname, "..", "..", "..", "..") : process.cwd(),
       env: scrubbedEnv
     });
   } catch (err) {
@@ -35818,13 +36193,13 @@ Run /mcp reconnect in Claude Code to load the new version.`
     }]
   };
 }
-var import_child_process14, import_fs80, import_path84;
+var import_child_process14, import_fs81, import_path85;
 var init_gossip_update = __esm({
   "apps/cli/src/handlers/gossip-update.ts"() {
     "use strict";
     import_child_process14 = require("child_process");
-    import_fs80 = require("fs");
-    import_path84 = require("path");
+    import_fs81 = require("fs");
+    import_path85 = require("path");
     init_version();
   }
 });
@@ -36035,8 +36410,8 @@ __export(mcp_server_sdk_exports, {
   createMcpServer: () => createMcpServer
 });
 module.exports = __toCommonJS(mcp_server_sdk_exports);
-var import_fs81 = require("fs");
-var import_path85 = require("path");
+var import_fs82 = require("fs");
+var import_path86 = require("path");
 
 // apps/cli/src/hook-run.ts
 var import_fs = require("fs");
@@ -49939,15 +50314,15 @@ init_native_tasks();
 
 // apps/cli/src/handlers/dispatch.ts
 var import_crypto31 = require("crypto");
-var import_fs71 = require("fs");
-var import_path76 = require("path");
+var import_fs72 = require("fs");
+var import_path77 = require("path");
 init_src4();
 init_src3();
 init_mcp_context();
 init_native_tasks();
 init_dispatch_prompt_storage();
 init_dispatch_prompt_cache();
-var import_fs72 = require("fs");
+var import_fs73 = require("fs");
 
 // apps/cli/src/handlers/relay-tasks.ts
 init_mcp_context();
@@ -50040,10 +50415,16 @@ function stampConcurrencyTaint(map2) {
   }
   return true;
 }
-function elidePromptIfRequested(projectRoot, taskId, agentPrompt, promptFormat, warmCached = false) {
+function elidePromptIfRequested(projectRoot, taskId, agentPrompt, promptFormat, warmCached = false, writeMode) {
   if (promptFormat !== "elided") return { elided: false };
-  const bytes = Buffer.byteLength(agentPrompt, "utf8");
-  const promptPath = writeDispatchPrompt(projectRoot, taskId, agentPrompt);
+  const body = writeMode === "worktree" ? `// GOSSIP_ISOLATION: worktree
+// This task was dispatched with write_mode: "worktree".
+// The orchestrator MUST invoke Agent() with isolation: "worktree".
+// Do not paraphrase this requirement.
+
+` + agentPrompt : agentPrompt;
+  const bytes = Buffer.byteLength(body, "utf8");
+  const promptPath = writeDispatchPrompt(projectRoot, taskId, body);
   const warmSuffix = warmCached ? " \u2014 warm-cached (skills) + live task" : "";
   const marker = `[skills section elided: see ${promptPath}, ${bytes} bytes${warmSuffix} \u2014 READ this file and pass its CONTENTS verbatim as the Agent(prompt: ...) value. Do NOT pass the path string.]`;
   return { elided: true, promptPath, marker, bytes };
@@ -50054,7 +50435,7 @@ function tryWarmCacheHit(liveTaskBlock, cacheKey, promptFormat) {
   const cached4 = getCachedPrompt(cacheKey);
   if (!cached4) return null;
   if (cached4.skillFingerprint !== cacheKey.skillFingerprint) return null;
-  if (!(0, import_fs72.existsSync)(cached4.skillsSectionPath)) return null;
+  if (!(0, import_fs73.existsSync)(cached4.skillsSectionPath)) return null;
   try {
     const skillsSection = require("fs").readFileSync(cached4.skillsSectionPath, "utf8");
     return skillsSection + liveTaskBlock;
@@ -50131,9 +50512,9 @@ function formatFalsifiedNote(block, verdicts) {
 }
 function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
   try {
-    const logPath = (0, import_path76.join)(projectRoot, PREMISE_VERIFICATION_LOG);
+    const logPath = (0, import_path77.join)(projectRoot, PREMISE_VERIFICATION_LOG);
     rotateIfNeeded2(logPath, MAX_PREMISE_VERIFICATION_BYTES);
-    (0, import_fs71.mkdirSync)((0, import_path76.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs72.mkdirSync)((0, import_path77.join)(projectRoot, ".gossip"), { recursive: true });
     const row = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       consensus_id: null,
@@ -50147,7 +50528,7 @@ function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
       skill_bound: opts.skill_bound
     };
     if (opts.schema_lint) row.schema_lint = opts.schema_lint;
-    (0, import_fs71.appendFileSync)(logPath, JSON.stringify(row) + "\n");
+    (0, import_fs72.appendFileSync)(logPath, JSON.stringify(row) + "\n");
   } catch {
   }
 }
@@ -50259,7 +50640,7 @@ var AGENT_PROVIDER_MAP = {
 };
 function readQuotaState() {
   try {
-    const raw = (0, import_fs71.readFileSync)((0, import_path76.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
+    const raw = (0, import_fs72.readFileSync)((0, import_path77.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -50415,17 +50796,31 @@ Task: ${task}`;
       worktreePath: void 0,
       timestamp: Date.now()
     });
-    const elision = elidePromptIfRequested(process.cwd(), taskId, agentPrompt, prompt_format, singleWarm);
+    const elision = elidePromptIfRequested(
+      process.cwd(),
+      taskId,
+      agentPrompt,
+      prompt_format,
+      singleWarm,
+      useWorktree ? "worktree" : void 0
+    );
     if (elision.elided) {
       const info = ctx.nativeTaskMap.get(taskId);
       if (info) info.promptPath = elision.promptPath;
     }
     persistNativeTaskMap();
+    const promptRef = elision.elided ? "<file contents>" : `<AGENT_PROMPT:${taskId} below>`;
+    const agentCall = useWorktree ? `Agent(
+  model: "${nativeConfig.model}",
+  prompt: ${promptRef},
+  isolation: "worktree",           // REQUIRED \u2014 do not omit
+  run_in_background: true
+)` : `Agent(model: "${nativeConfig.model}", prompt: ${promptRef}, run_in_background: true)`;
     const promptInstruction = elision.elided ? `Step 1 \u2014 ${elision.marker}
-Agent(model: "${nativeConfig.model}", prompt: <file contents>${useWorktree ? ', isolation: "worktree"' : ""}, run_in_background: true)
+${agentCall}
 
 ` : `Step 1 \u2014 Pass the AGENT_PROMPT:${taskId} content item below verbatim to Agent(prompt: ...):
-Agent(model: "${nativeConfig.model}", prompt: <AGENT_PROMPT:${taskId} below>${useWorktree ? ', isolation: "worktree"' : ""}, run_in_background: true)
+${agentCall}
 
 `;
     return { content: [
@@ -50437,8 +50832,10 @@ NATIVE_DISPATCH: Execute this via Claude Code Agent tool, then relay the result.
 Task ID: ${taskId}
 Agent: ${agent_id}
 Model: ${nativeConfig.model}
+` + (useWorktree ? `Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"
 
-` + promptInstruction + `Step 2 \u2014 REQUIRED after agent completes:
+` : `
+`) + promptInstruction + `Step 2 \u2014 REQUIRED after agent completes:
 gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<agent output>")
 (VERBATIM \u2014 pass the agent's raw output; do NOT paraphrase or summarize, or <agent_finding> tags will be lost)
 
@@ -50680,15 +51077,24 @@ Task: ${def.task}`;
       worktreePath: void 0,
       timestamp: Date.now()
     });
-    const parallelElision = elidePromptIfRequested(process.cwd(), taskId, agentPrompt, prompt_format, parallelWarm);
+    const parallelElision = elidePromptIfRequested(process.cwd(), taskId, agentPrompt, prompt_format, parallelWarm, def.write_mode);
     if (parallelElision.elided) {
       const info = ctx.nativeTaskMap.get(taskId);
       if (info) info.promptPath = parallelElision.promptPath;
     }
     const parallelPromptRef = parallelElision.elided ? parallelElision.marker : `<AGENT_PROMPT:${taskId} below>`;
+    const parallelUseWorktree = def.write_mode === "worktree";
+    const parallelWorktreeBanner = parallelUseWorktree ? `
+  Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"` : "";
+    const parallelAgentCall = parallelUseWorktree ? `Agent(
+  model: "${nativeConfig.model}",
+  prompt: ${parallelPromptRef},
+  isolation: "worktree",           // REQUIRED \u2014 do not omit
+  run_in_background: true
+)` : `Agent(model: "${nativeConfig.model}", prompt: ${parallelPromptRef}, run_in_background: true)`;
     lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via Agent tool)`);
     nativeInstructions.push(
-      `[${taskId}] Agent(model: "${nativeConfig.model}", prompt: ${parallelPromptRef}${def.write_mode === "worktree" ? ', isolation: "worktree"' : ""}, run_in_background: true)
+      `[${taskId}] ${parallelAgentCall}${parallelWorktreeBanner}
   \u2192 then: gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<output>")`
     );
     if (!parallelElision.elided) {
@@ -50898,16 +51304,25 @@ Task: ${def.task}`;
       }
     }
     agentPrompt = maybeApplyUnverifiedNote(agentPrompt, def.task, def.agent_id);
-    const consensusElision = elidePromptIfRequested(process.cwd(), taskId, agentPrompt, prompt_format, consensusWarm);
+    const consensusElision = elidePromptIfRequested(process.cwd(), taskId, agentPrompt, prompt_format, consensusWarm, def.write_mode);
     if (consensusElision.elided) {
       const info = ctx.nativeTaskMap.get(taskId);
       if (info) info.promptPath = consensusElision.promptPath;
       persistNativeTaskMap();
     }
     const consensusPromptRef = consensusElision.elided ? consensusElision.marker : `<AGENT_PROMPT:${taskId} below>`;
+    const consensusUseWorktree = def.write_mode === "worktree";
+    const consensusWorktreeBanner = consensusUseWorktree ? `
+  Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"` : "";
+    const consensusAgentCall = consensusUseWorktree ? `Agent(
+  model: "${nativeConfig.model}",
+  prompt: ${consensusPromptRef},
+  isolation: "worktree",           // REQUIRED \u2014 do not omit
+  run_in_background: true
+)` : `Agent(model: "${nativeConfig.model}", prompt: ${consensusPromptRef}, run_in_background: true)`;
     lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via Agent tool)`);
     nativeInstructions.push(
-      `[${taskId}] Agent(model: "${nativeConfig.model}", prompt: ${consensusPromptRef}, run_in_background: true)
+      `[${taskId}] ${consensusAgentCall}${consensusWorktreeBanner}
   \u2192 then: gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<output>")`
     );
     if (!consensusElision.elided) {
@@ -51053,13 +51468,13 @@ function buildAutoVerifyDispatch(binding) {
 var _autoResolverErrors = /* @__PURE__ */ new Set();
 var _autoResolverLockWarned = false;
 var CONSENSUS_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{8}$/;
-function isValidConsensusId(id) {
+function isValidConsensusId2(id) {
   return typeof id === "string" && CONSENSUS_ID_RE.test(id);
 }
 function extractConsensusIdFromFindingId(findingId) {
   if (typeof findingId !== "string") return void 0;
   const first = findingId.split(":")[0];
-  return isValidConsensusId(first) ? first : void 0;
+  return isValidConsensusId2(first) ? first : void 0;
 }
 function reconcilerFindingsAll(consensusReport) {
   return [
@@ -51761,7 +52176,7 @@ ${np.user}
         ...consensusReport.unique || []
       ];
       const authoritativeId = consensusReport?.signals?.[0]?.consensusId;
-      const provisionalConsensusId = (isValidConsensusId(authoritativeId) ? authoritativeId : void 0) ?? (allFindings.length > 0 ? extractConsensusIdFromFindingId(allFindings[0].id) : void 0);
+      const provisionalConsensusId = (isValidConsensusId2(authoritativeId) ? authoritativeId : void 0) ?? (allFindings.length > 0 ? extractConsensusIdFromFindingId(allFindings[0].id) : void 0);
       const provisionalSignals = allFindings.filter((f) => !isFindingAlreadySignaled(alreadySignaled, f)).map((f) => {
         const extracted = extractCategories2(f.finding || "");
         const category = f.category || extracted[0] || void 0;
@@ -52009,19 +52424,19 @@ function filterWatchEvents(rawJsonl, opts) {
 }
 
 // apps/cli/src/stickyPort.ts
-var import_fs75 = require("fs");
-var import_path79 = require("path");
+var import_fs76 = require("fs");
+var import_path80 = require("path");
 var import_net = require("net");
-var RELAY_STICKY_FILE = (0, import_path79.join)(".gossip", "relay.port");
-var HTTP_MCP_STICKY_FILE = (0, import_path79.join)(".gossip", "http-mcp.port");
+var RELAY_STICKY_FILE = (0, import_path80.join)(".gossip", "relay.port");
+var HTTP_MCP_STICKY_FILE = (0, import_path80.join)(".gossip", "http-mcp.port");
 function stickyPath(filename) {
-  return (0, import_path79.join)(process.cwd(), filename);
+  return (0, import_path80.join)(process.cwd(), filename);
 }
 function readStickyPort(filename) {
   const p = stickyPath(filename);
-  if (!(0, import_fs75.existsSync)(p)) return null;
+  if (!(0, import_fs76.existsSync)(p)) return null;
   try {
-    const raw = (0, import_fs75.readFileSync)(p, "utf-8").trim();
+    const raw = (0, import_fs76.readFileSync)(p, "utf-8").trim();
     const n = parseInt(raw, 10);
     if (!Number.isFinite(n) || n < 1 || n > 65535) return null;
     return n;
@@ -52033,8 +52448,8 @@ function writeStickyPort(filename, port) {
   if (!Number.isFinite(port) || port < 1 || port > 65535) return;
   const p = stickyPath(filename);
   try {
-    (0, import_fs75.mkdirSync)((0, import_path79.dirname)(p), { recursive: true });
-    (0, import_fs75.writeFileSync)(p, String(port), "utf-8");
+    (0, import_fs76.mkdirSync)((0, import_path80.dirname)(p), { recursive: true });
+    (0, import_fs76.writeFileSync)(p, String(port), "utf-8");
   } catch {
   }
 }
@@ -52098,22 +52513,22 @@ function buildDashboardAdvisory(input) {
 }
 
 // apps/cli/src/native-agent-cache.ts
-var import_fs76 = require("fs");
-var import_path80 = require("path");
+var import_fs77 = require("fs");
+var import_path81 = require("path");
 var realFs = {
-  existsSync: import_fs76.existsSync,
-  readFileSync: import_fs76.readFileSync,
-  statSync: (p) => ({ mtimeMs: (0, import_fs76.statSync)(p).mtimeMs })
+  existsSync: import_fs77.existsSync,
+  readFileSync: import_fs77.readFileSync,
+  statSync: (p) => ({ mtimeMs: (0, import_fs77.statSync)(p).mtimeMs })
 };
 function modelTierFromId(modelId) {
   if (modelId.includes("opus")) return "opus";
   if (modelId.includes("haiku")) return "haiku";
   return "sonnet";
 }
-function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs6 = realFs) {
-  const claudeAgentPath = (0, import_path80.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
-  const instrPath = (0, import_path80.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
-  const prev = cache2.get(ac.id);
+function refreshNativeAgentFromDisk(ac, cache3, projectRoot, fs6 = realFs) {
+  const claudeAgentPath = (0, import_path81.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
+  const instrPath = (0, import_path81.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+  const prev = cache3.get(ac.id);
   let sourcePath = null;
   let stripFrontmatter = false;
   if (fs6.existsSync(claudeAgentPath)) {
@@ -52127,7 +52542,7 @@ function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs6 = realFs) {
     if (prev && prev.instructions.length > 0) {
       return;
     }
-    cache2.set(ac.id, {
+    cache3.set(ac.id, {
       model: modelTierFromId(ac.model),
       instructions: "",
       description: ac.role || ac.preset || "",
@@ -52143,7 +52558,7 @@ function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs6 = realFs) {
     if (prev && prev.instructions.length > 0) {
       return;
     }
-    cache2.set(ac.id, {
+    cache3.set(ac.id, {
       model: modelTierFromId(ac.model),
       instructions: "",
       description: ac.role || ac.preset || "",
@@ -52161,7 +52576,7 @@ function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs6 = realFs) {
   if (instructions.length === 0 && prev && prev.instructions.length > 0) {
     return;
   }
-  cache2.set(ac.id, {
+  cache3.set(ac.id, {
     model: modelTierFromId(ac.model),
     instructions,
     description: ac.role || ac.preset || "",
@@ -52171,16 +52586,16 @@ function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs6 = realFs) {
 }
 
 // apps/cli/src/rules-content.ts
-var import_fs77 = require("fs");
-var import_path81 = require("path");
+var import_fs78 = require("fs");
+var import_path82 = require("path");
 var AGENT_LIST_PLACEHOLDER = "{{AGENT_LIST}}";
 function resolveRulesPath() {
   const candidates = [
-    (0, import_path81.join)(process.cwd(), "docs", "RULES.md"),
-    (0, import_path81.join)(__dirname, "..", "docs", "RULES.md"),
-    (0, import_path81.join)(__dirname, "docs", "RULES.md")
+    (0, import_path82.join)(process.cwd(), "docs", "RULES.md"),
+    (0, import_path82.join)(__dirname, "..", "docs", "RULES.md"),
+    (0, import_path82.join)(__dirname, "docs", "RULES.md")
   ];
-  return candidates.find((p) => (0, import_fs77.existsSync)(p)) ?? null;
+  return candidates.find((p) => (0, import_fs78.existsSync)(p)) ?? null;
 }
 function generateRulesContent(agentList) {
   const rulesPath = resolveRulesPath();
@@ -52189,7 +52604,7 @@ function generateRulesContent(agentList) {
       `[gossipcat] generateRulesContent: docs/RULES.md not found in any fallback path (cwd=${process.cwd()}, dirname=${__dirname}). Expected docs/RULES.md tracked in the gossipcat repo or shipped alongside the MCP bundle. If running from a fresh install, re-run \`npm run build:mcp\` to copy docs/RULES.md into dist-mcp/docs/.`
     );
   }
-  const template = (0, import_fs77.readFileSync)(rulesPath, "utf-8");
+  const template = (0, import_fs78.readFileSync)(rulesPath, "utf-8");
   return template.split(AGENT_LIST_PLACEHOLDER).join(agentList);
 }
 
@@ -52259,12 +52674,12 @@ function isReservedAgentId(id) {
   }
 }
 if (process.env.GOSSIPCAT_MCP_NO_MAIN !== "1") {
-  const gossipDir = (0, import_path85.join)(process.cwd(), ".gossip");
+  const gossipDir = (0, import_path86.join)(process.cwd(), ".gossip");
   try {
-    (0, import_fs81.mkdirSync)(gossipDir, { recursive: true });
+    (0, import_fs82.mkdirSync)(gossipDir, { recursive: true });
   } catch {
   }
-  const logStream = (0, import_fs81.createWriteStream)((0, import_path85.join)(gossipDir, "mcp.log"), { flags: "a" });
+  const logStream = (0, import_fs82.createWriteStream)((0, import_path86.join)(gossipDir, "mcp.log"), { flags: "a" });
   process.stderr.write = ((chunk, ...args) => {
     return logStream.write(chunk, ...args);
   });
@@ -52275,7 +52690,7 @@ try {
 } catch {
 }
 function memoryDirForProject(cwd) {
-  return (0, import_path85.join)((0, import_os7.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
+  return (0, import_path86.join)((0, import_os7.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
 }
 function detectEnvironment() {
   if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE_ENTRYPOINT) {
@@ -52330,14 +52745,14 @@ var _pendingPlanData = /* @__PURE__ */ new Map();
 var _utilityGuardSnapshots = /* @__PURE__ */ new Map();
 var _modules = null;
 function lookupFindingSeverity(findingId, projectRoot) {
-  const { existsSync: existsSync69, readdirSync: readdirSync22, readFileSync: readFileSync62 } = require("fs");
-  const { join: join82 } = require("path");
-  const reportsDir = join82(projectRoot, ".gossip", "consensus-reports");
-  if (!existsSync69(reportsDir)) return null;
+  const { existsSync: existsSync70, readdirSync: readdirSync22, readFileSync: readFileSync64 } = require("fs");
+  const { join: join83 } = require("path");
+  const reportsDir = join83(projectRoot, ".gossip", "consensus-reports");
+  if (!existsSync70(reportsDir)) return null;
   try {
     const files = readdirSync22(reportsDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const report = JSON.parse(readFileSync62(join82(reportsDir, file2), "utf-8"));
+      const report = JSON.parse(readFileSync64(join83(reportsDir, file2), "utf-8"));
       for (const bucket of ["confirmed", "disputed", "unverified", "unique"]) {
         for (const finding of report[bucket] || []) {
           if (finding.id === findingId && finding.severity) {
@@ -52415,7 +52830,7 @@ async function doBoot() {
   const agentConfigs = m.configToAgentConfigs(config2);
   ctx.keychain = new m.Keychain();
   const { existsSync: pidExists, readFileSync: readPid, writeFileSync: writePid, unlinkSync: delPid } = require("fs");
-  const pidFile = (0, import_path85.join)(process.cwd(), ".gossip", "relay.pid");
+  const pidFile = (0, import_path86.join)(process.cwd(), ".gossip", "relay.pid");
   if (pidExists(pidFile)) {
     const oldPid = parseInt(readPid(pidFile, "utf-8").trim(), 10);
     if (!isNaN(oldPid) && oldPid !== process.pid) {
@@ -52525,10 +52940,10 @@ async function doBoot() {
     }
     const key = await ctx.keychain.getKey(ac.provider);
     const llm = m.createProvider(ac.provider, ac.model, key ?? void 0, void 0, ac.base_url);
-    const { existsSync: existsSync69, readFileSync: readFileSync62 } = require("fs");
-    const { join: join82 } = require("path");
-    const instructionsPath = join82(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
-    const baseInstructions = existsSync69(instructionsPath) ? readFileSync62(instructionsPath, "utf-8") : "";
+    const { existsSync: existsSync70, readFileSync: readFileSync64 } = require("fs");
+    const { join: join83 } = require("path");
+    const instructionsPath = join83(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
+    const baseInstructions = existsSync70(instructionsPath) ? readFileSync64(instructionsPath, "utf-8") : "";
     const identity = ctx.identityRegistry.get(ac.id);
     const identityBlock = identity ? m.formatIdentityBlock(identity) + "\n" : "";
     const instructions = (identityBlock + baseInstructions).trim() || void 0;
@@ -53363,7 +53778,7 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       }
       try {
         const { readFileSync: rfHealth } = await import("fs");
-        const healthPath = (0, import_path85.join)(process.cwd(), ".gossip", "skill-runner-health.json");
+        const healthPath = (0, import_path86.join)(process.cwd(), ".gossip", "skill-runner-health.json");
         const raw = rfHealth(healthPath, "utf8");
         const h = JSON.parse(raw);
         const lastMs = h.last_run_at ? new Date(h.last_run_at).getTime() : NaN;
@@ -53379,9 +53794,9 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
         lines.push("  Skill graduation: never run since session start (expected after first gossip_collect)");
       }
       try {
-        const { readFileSync: readFileSync62 } = await import("fs");
-        const quotaPath = (0, import_path85.join)(process.cwd(), ".gossip", "quota-state.json");
-        const quotaRaw = readFileSync62(quotaPath, "utf8");
+        const { readFileSync: readFileSync64 } = await import("fs");
+        const quotaPath = (0, import_path86.join)(process.cwd(), ".gossip", "quota-state.json");
+        const quotaRaw = readFileSync64(quotaPath, "utf8");
         const quotaState = JSON.parse(quotaRaw);
         for (const [provider, state] of Object.entries(quotaState)) {
           const now = Date.now();
@@ -53395,19 +53810,19 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       } catch {
       }
       try {
-        const { readdirSync: readdirSync22, statSync: statSync34 } = await import("fs");
+        const { readdirSync: readdirSync22, statSync: statSync35 } = await import("fs");
         const { readJsonlWithRotated: readJsonlRotated1506 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
-        const reportsDir = (0, import_path85.join)(process.cwd(), ".gossip", "consensus-reports");
-        const perfPath = (0, import_path85.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
-        const WINDOW_MS2 = 24 * 60 * 60 * 1e3;
+        const reportsDir = (0, import_path86.join)(process.cwd(), ".gossip", "consensus-reports");
+        const perfPath = (0, import_path86.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
+        const WINDOW_MS3 = 24 * 60 * 60 * 1e3;
         const now = Date.now();
         const recentReports = [];
         try {
           for (const fname of readdirSync22(reportsDir)) {
             if (!fname.endsWith(".json")) continue;
-            const fpath = (0, import_path85.join)(reportsDir, fname);
-            const st = statSync34(fpath);
-            if (now - st.mtimeMs > WINDOW_MS2) continue;
+            const fpath = (0, import_path86.join)(reportsDir, fname);
+            const st = statSync35(fpath);
+            if (now - st.mtimeMs > WINDOW_MS3) continue;
             recentReports.push({ id: fname.replace(/\.json$/, ""), mtimeMs: st.mtimeMs });
           }
         } catch {
@@ -53771,8 +54186,8 @@ ${body}`
         }
         return { content: [{ type: "text", text: results.join("\n") }] };
       }
-      const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync69 } = require("fs");
-      const { join: join82 } = require("path");
+      const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync70 } = require("fs");
+      const { join: join83 } = require("path");
       const root = process.cwd();
       const CLAUDE_MODEL_MAP2 = {
         opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -53786,8 +54201,8 @@ ${body}`
       let existingAgents = {};
       if (mode === "merge") {
         try {
-          const { readFileSync: readFileSync62 } = require("fs");
-          const existing = JSON.parse(readFileSync62(join82(root, ".gossip", "config.json"), "utf-8"));
+          const { readFileSync: readFileSync64 } = require("fs");
+          const existing = JSON.parse(readFileSync64(join83(root, ".gossip", "config.json"), "utf-8"));
           existingAgents = existing.agents || {};
         } catch {
         }
@@ -53818,9 +54233,9 @@ ${body}`
             "",
             body
           ].join("\n");
-          const agentsDir = join82(root, ".claude", "agents");
+          const agentsDir = join83(root, ".claude", "agents");
           mkdirSync41(agentsDir, { recursive: true });
-          writeFileSync34(join82(agentsDir, `${agent.id}.md`), md, "utf-8");
+          writeFileSync34(join83(agentsDir, `${agent.id}.md`), md, "utf-8");
           nativeCreated.push(agent.id);
           configAgents[agent.id] = {
             provider: mapped.provider,
@@ -53838,8 +54253,8 @@ ${body}`
             errors.push(`${agent.id}: custom agent requires "custom_model" field`);
             continue;
           }
-          const nativeFile = join82(root, ".claude", "agents", `${agent.id}.md`);
-          const wasNative = existingAgents[agent.id]?.native || existsSync69(nativeFile);
+          const nativeFile = join83(root, ".claude", "agents", `${agent.id}.md`);
+          const wasNative = existingAgents[agent.id]?.native || existsSync70(nativeFile);
           if (wasNative) {
             errors.push(`${agent.id}: cannot re-register native agent as custom \u2014 .claude/agents/${agent.id}.md exists. Remove the file first or keep it as native.`);
             continue;
@@ -53853,9 +54268,9 @@ ${body}`
           };
           customCreated.push(agent.id);
           if (agent.instructions) {
-            const instrDir = join82(root, ".gossip", "agents", agent.id);
+            const instrDir = join83(root, ".gossip", "agents", agent.id);
             mkdirSync41(instrDir, { recursive: true });
-            writeFileSync34(join82(instrDir, "instructions.md"), agent.instructions, "utf-8");
+            writeFileSync34(join83(instrDir, "instructions.md"), agent.instructions, "utf-8");
           }
         }
       }
@@ -53869,8 +54284,8 @@ ${body}`
       } catch (err) {
         return { content: [{ type: "text", text: `Invalid config: ${err.message}` }] };
       }
-      mkdirSync41(join82(root, ".gossip"), { recursive: true });
-      writeFileSync34(join82(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
+      mkdirSync41(join83(root, ".gossip"), { recursive: true });
+      writeFileSync34(join83(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
       let hookSummary = "";
       try {
         const { installWorktreeSandboxHook: installWorktreeSandboxHook2, writeOrchestratorRoleMarker: writeOrchestratorRoleMarker2 } = (init_src4(), __toCommonJS(src_exports3));
@@ -53947,8 +54362,8 @@ ${body}`
         }
       }
       const agentList = Object.entries(config2.agents).map(([id, a]) => `- ${id}: ${a.provider}/${a.model} (${a.preset || "custom"})${a.native ? " \u2014 native" : ""}`).join("\n");
-      const rulesDir = join82(root, env.rulesDir);
-      const rulesFile = join82(root, env.rulesFile);
+      const rulesDir = join83(root, env.rulesDir);
+      const rulesFile = join83(root, env.rulesFile);
       mkdirSync41(rulesDir, { recursive: true });
       writeFileSync34(rulesFile, generateRulesContent(agentList));
       const lines = [`Host: ${env.host}`, ""];
@@ -54245,11 +54660,11 @@ The original signal remains in the audit log but will be excluded from scoring.`
         const fid = finding_id.trim();
         const cwd = process.cwd();
         const findingsPath = require("path").join(cwd, ".gossip", "implementation-findings.jsonl");
-        const { readFileSync: readFileSync62, existsSync: existsSync69, writeFileSync: writeFileSync34, renameSync: renameSync15 } = require("fs");
-        if (!existsSync69(findingsPath)) {
+        const { readFileSync: readFileSync64, existsSync: existsSync70, writeFileSync: writeFileSync34, renameSync: renameSync15 } = require("fs");
+        if (!existsSync70(findingsPath)) {
           return { content: [{ type: "text", text: `No implementation-findings.jsonl found at ${findingsPath}` }] };
         }
-        const lines = readFileSync62(findingsPath, "utf-8").split("\n");
+        const lines = readFileSync64(findingsPath, "utf-8").split("\n");
         let matched = false;
         let alreadyTarget = false;
         let matchedEntry = null;
@@ -54337,18 +54752,18 @@ The original signal remains in the audit log but will be excluded from scoring.`
           return { content: [{ type: "text", text: "Error: consensus_id is required for bulk_from_consensus." }] };
         }
         try {
-          const { readFileSync: readFileSync62 } = await import("fs");
-          const { join: join82 } = await import("path");
-          const reportPath = join82(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
+          const { readFileSync: readFileSync64 } = await import("fs");
+          const { join: join83 } = await import("path");
+          const reportPath = join83(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
           let report;
           try {
-            report = JSON.parse(readFileSync62(reportPath, "utf-8"));
+            report = JSON.parse(readFileSync64(reportPath, "utf-8"));
           } catch {
             return { content: [{ type: "text", text: `Error: consensus report not found: ${consensus_id}` }] };
           }
           const existingFindingIds = /* @__PURE__ */ new Set();
           try {
-            const perfPath = join82(process.cwd(), ".gossip", "agent-performance.jsonl");
+            const perfPath = join83(process.cwd(), ".gossip", "agent-performance.jsonl");
             const { readJsonlWithRotated: readJsonlRotated2570 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
             const lines = readJsonlRotated2570(perfPath).split("\n").filter(Boolean);
             for (const line of lines) {
@@ -55364,16 +55779,16 @@ ${preview}` }]
       const { SkillGapTracker: SkillGapTracker2, parseSkillFrontmatter: parseSkillFrontmatter2, normalizeSkillName: normalizeSkillName2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
       const tracker = new SkillGapTracker2(process.cwd());
       if (skills && skills.length > 0) {
-        const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync69, readFileSync: readFileSync62 } = require("fs");
-        const { join: join82 } = require("path");
-        const dir = join82(process.cwd(), ".gossip", "skills");
+        const { writeFileSync: writeFileSync34, mkdirSync: mkdirSync41, existsSync: existsSync70, readFileSync: readFileSync64 } = require("fs");
+        const { join: join83 } = require("path");
+        const dir = join83(process.cwd(), ".gossip", "skills");
         mkdirSync41(dir, { recursive: true });
         const results = [];
         for (const sk of skills) {
           const name = normalizeSkillName2(sk.name);
-          const filePath = join82(dir, `${name}.md`);
-          if (existsSync69(filePath)) {
-            const existing = readFileSync62(filePath, "utf-8");
+          const filePath = join83(dir, `${name}.md`);
+          if (existsSync70(filePath)) {
+            const existing = readFileSync64(filePath, "utf-8");
             const fm = parseSkillFrontmatter2(existing);
             if (fm) {
               if (fm.generated_by === "manual") {
@@ -56209,9 +56624,9 @@ ${p.user}
       max_events: external_exports.number().int().positive().max(WATCH_MAX_EVENTS).optional().describe(`Cap events returned (default ${WATCH_MAX_EVENTS}).`)
     },
     async ({ cursor, max_events }) => {
-      const { join: join82 } = await import("node:path");
+      const { join: join83 } = await import("node:path");
       const { readJsonlWithRotated: readJsonlWithRotated2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
-      const perfPath = join82(process.cwd(), ".gossip", "agent-performance.jsonl");
+      const perfPath = join83(process.cwd(), ".gossip", "agent-performance.jsonl");
       const raw = readJsonlWithRotated2(perfPath);
       const result = filterWatchEvents(raw, { cursor, maxEvents: max_events });
       return { content: [{ type: "text", text: JSON.stringify(result) }] };