gossipcat 0.4.22 → 0.4.23

package/dist-mcp/mcp-server.js

@@ -3405,9 +3405,18 @@ var init_src2 = __esm({
 });
 
 // packages/orchestrator/src/task-stream.ts
+var TaskStreamEventType;
 var init_task_stream = __esm({
   "packages/orchestrator/src/task-stream.ts"() {
     "use strict";
+    TaskStreamEventType = /* @__PURE__ */ ((TaskStreamEventType2) => {
+      TaskStreamEventType2["LOG"] = "log";
+      TaskStreamEventType2["PROGRESS"] = "progress";
+      TaskStreamEventType2["PARTIAL_RESULT"] = "partial_result";
+      TaskStreamEventType2["FINAL_RESULT"] = "final_result";
+      TaskStreamEventType2["ERROR"] = "error";
+      return TaskStreamEventType2;
+    })(TaskStreamEventType || {});
   }
 });
 
@@ -8776,7 +8785,15 @@ var init_tool_server = __esm({
       }
       assignRoot(agentId, root) {
         const abs = (0, import_path8.resolve)(root);
-        this.agentRoots.set(agentId, canonicalizeForBoundary(abs));
+        const canonical = canonicalizeForBoundary(abs);
+        const existing = this.agentRoots.get(agentId);
+        if (existing && existing !== canonical) {
+          process.stderr.write(
+            `[gossipcat] assignRoot collision: agent=${agentId} replacing root ${existing} \u2192 ${canonical} (Option B last-write-wins)
+`
+          );
+        }
+        this.agentRoots.set(agentId, canonical);
         this.writeAgents.add(agentId);
       }
       releaseAgent(agentId) {
@@ -9447,118 +9464,6 @@ var init_types2 = __esm({
   }
 });
 
-// packages/orchestrator/src/skill-parser.ts
-function parseSkillFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return null;
-  const lines = match[1].split("\n");
-  const fields = {};
-  for (const line of lines) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) continue;
-    const key = line.slice(0, colonIdx).trim();
-    let value = line.slice(colonIdx + 1).trim();
-    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    }
-    fields[key] = value;
-  }
-  if (!fields.name || !fields.description || !fields.status) return null;
-  let keywords = [];
-  if (fields.keywords) {
-    const raw = fields.keywords;
-    if (raw.startsWith("[") && raw.endsWith("]")) {
-      keywords = raw.slice(1, -1).split(",").map((k) => k.trim().replace(/^['"]|['"]$/g, "").slice(0, 100)).filter(Boolean);
-    } else {
-      keywords = raw.split(",").map((k) => k.trim().slice(0, 100)).filter(Boolean);
-    }
-  }
-  const rawTaskType = fields.task_type;
-  const task_type = rawTaskType === "review" || rawTaskType === "implement" || rawTaskType === "research" || rawTaskType === "any" ? rawTaskType : "any";
-  let scope;
-  if (fields.scope) {
-    const raw = fields.scope.trim();
-    let tokens;
-    if (raw.startsWith("[") && raw.endsWith("]")) {
-      tokens = raw.slice(1, -1).split(",").map((t) => t.trim().replace(/^['"]|['"]$/g, ""));
-    } else {
-      tokens = [raw.replace(/^['"]|['"]$/g, "")];
-    }
-    const valid = tokens.filter(
-      (t) => t === "review" || t === "implement" || t === "research"
-    );
-    if (valid.length > 0) scope = valid;
-  }
-  return {
-    name: normalizeSkillName(fields.name),
-    description: fields.description,
-    keywords,
-    category: fields.category || void 0,
-    mode: fields.mode === "contextual" ? "contextual" : fields.mode === "permanent" ? "permanent" : void 0,
-    generated_by: fields.generated_by,
-    sources: fields.sources,
-    status: fields.status,
-    task_type,
-    scope
-  };
-}
-var init_skill_parser = __esm({
-  "packages/orchestrator/src/skill-parser.ts"() {
-    "use strict";
-    init_skill_name();
-  }
-});
-
-// packages/orchestrator/src/memory-config.ts
-function loadMemoryConfig(projectRoot) {
-  const configPath = (0, import_path9.resolve)(projectRoot, ".gossip", "memory-config.json");
-  if (!(0, import_fs8.existsSync)(configPath)) {
-    return { ...DEFAULTS, bundledMemories: { ...DEFAULTS.bundledMemories } };
-  }
-  let raw;
-  try {
-    raw = (0, import_fs8.readFileSync)(configPath, "utf-8");
-  } catch (err) {
-    log("memory-config", `WARNING: failed to read ${configPath}: ${err?.message ?? err} \u2014 using defaults`);
-    return { ...DEFAULTS, bundledMemories: { ...DEFAULTS.bundledMemories } };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (err) {
-    log("memory-config", `WARNING: malformed JSON in ${configPath}: ${err?.message ?? err} \u2014 using defaults`);
-    return { ...DEFAULTS, bundledMemories: { ...DEFAULTS.bundledMemories } };
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    log("memory-config", `WARNING: ${configPath} must be a JSON object \u2014 using defaults`);
-    return { ...DEFAULTS, bundledMemories: { ...DEFAULTS.bundledMemories } };
-  }
-  const obj = parsed;
-  const bm = obj.bundledMemories;
-  if (typeof bm !== "object" || bm === null || Array.isArray(bm)) {
-    return { ...DEFAULTS, bundledMemories: { ...DEFAULTS.bundledMemories } };
-  }
-  const bmObj = bm;
-  const enabled = typeof bmObj.enabled === "boolean" ? bmObj.enabled : DEFAULTS.bundledMemories.enabled;
-  const exclude = Array.isArray(bmObj.exclude) ? bmObj.exclude.filter((x) => typeof x === "string") : DEFAULTS.bundledMemories.exclude;
-  return { bundledMemories: { enabled, exclude } };
-}
-var import_fs8, import_path9, DEFAULTS;
-var init_memory_config = __esm({
-  "packages/orchestrator/src/memory-config.ts"() {
-    "use strict";
-    import_fs8 = require("fs");
-    import_path9 = require("path");
-    init_log();
-    DEFAULTS = {
-      bundledMemories: {
-        enabled: true,
-        exclude: []
-      }
-    };
-  }
-});
-
 // packages/orchestrator/src/consensus-types.ts
 function classifySignal(signalName) {
   if (PERFORMANCE_SIGNAL_NAMES.has(signalName)) return "performance";
@@ -9593,7 +9498,8 @@ var init_consensus_types = __esm({
       "citation_fabricated",
       "finding_dropped_format",
       "consensus_round_retracted",
-      "unverified"
+      "unverified",
+      "transport_failure"
     ]);
   }
 });
@@ -9688,7 +9594,28 @@ function bump(projectRoot, consensusId) {
     const next = (inMemoryFallback.get(fbk) ?? 0) + 1;
     inMemoryFallback.set(fbk, next);
   } else {
-    inMemoryFallback.delete(fbk);
+    const priorCount = inMemoryFallback.get(fbk) ?? 0;
+    if (priorCount > 0) {
+      const toFlush = Math.min(priorCount, MAX_BACKFILL_PER_BUMP);
+      let remaining = priorCount;
+      for (let i = 0; i < toFlush; i++) {
+        const backfillRecord = {
+          type: "_meta",
+          signal: "round_counter_bumped",
+          consensusId,
+          bumpedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          _emission_path: "round-counter-bump-backfill"
+        };
+        if (!appendMetaRecord(projectRoot, backfillRecord)) break;
+        remaining -= 1;
+        inMemoryFallback.set(fbk, remaining);
+      }
+      if (remaining === 0) {
+        inMemoryFallback.delete(fbk);
+      }
+    } else {
+      inMemoryFallback.delete(fbk);
+    }
   }
 }
 function get(projectRoot, consensusId) {
@@ -9730,7 +9657,7 @@ function makeBumpRecord(consensusId, emissionPath) {
     _emission_path: emissionPath
   };
 }
-var fs, path, JSONL_FILENAME, inMemoryFallback, fallbackKey, scanCache;
+var fs, path, JSONL_FILENAME, inMemoryFallback, MAX_BACKFILL_PER_BUMP, fallbackKey, scanCache;
 var init_round_counter = __esm({
   "packages/orchestrator/src/round-counter.ts"() {
     "use strict";
@@ -9738,6 +9665,7 @@ var init_round_counter = __esm({
     path = __toESM(require("path"));
     JSONL_FILENAME = "agent-performance.jsonl";
     inMemoryFallback = /* @__PURE__ */ new Map();
+    MAX_BACKFILL_PER_BUMP = 100;
     fallbackKey = (projectRoot, consensusId) => `${projectRoot} ${consensusId}`;
     scanCache = /* @__PURE__ */ new Map();
   }
@@ -9810,8 +9738,8 @@ function escapeControlChars(s) {
 function readTail(filePath, n) {
   const lines = [];
   try {
-    if ((0, import_fs9.existsSync)(filePath)) {
-      const raw = (0, import_fs9.readFileSync)(filePath, "utf8");
+    if ((0, import_fs8.existsSync)(filePath)) {
+      const raw = (0, import_fs8.readFileSync)(filePath, "utf8");
       if (raw.length > 0) {
         const split = raw.split("\n").filter((l) => l.length > 0);
         lines.push(...split);
@@ -9822,8 +9750,8 @@ function readTail(filePath, n) {
   if (lines.length < n) {
     try {
       const rotated = filePath + ".1";
-      if ((0, import_fs9.existsSync)(rotated)) {
-        const raw = (0, import_fs9.readFileSync)(rotated, "utf8");
+      if ((0, import_fs8.existsSync)(rotated)) {
+        const raw = (0, import_fs8.readFileSync)(rotated, "utf8");
         const split = raw.split("\n").filter((l) => l.length > 0);
         lines.unshift(...split);
       }
@@ -9832,16 +9760,16 @@ function readTail(filePath, n) {
   }
   return lines.slice(-n);
 }
-var import_fs9, import_path10, import_crypto7, DEFAULTS2, ALLOWLIST_SET, PipelineDriftDetector;
+var import_fs8, import_path9, import_crypto7, DEFAULTS, ALLOWLIST_SET, PipelineDriftDetector;
 var init_pipeline_drift_detector = __esm({
   "packages/orchestrator/src/pipeline-drift-detector.ts"() {
     "use strict";
-    import_fs9 = require("fs");
-    import_path10 = require("path");
+    import_fs8 = require("fs");
+    import_path9 = require("path");
     import_crypto7 = require("crypto");
     init_completion_signals_allowlist();
     init_performance_writer();
-    DEFAULTS2 = {
+    DEFAULTS = {
       windowSize: 500,
       bypassThreshold: 1,
       unknownThresholdRate: 0.01,
@@ -9856,23 +9784,23 @@ var init_pipeline_drift_detector = __esm({
       dir;
       opts;
       constructor(projectRoot, options = {}) {
-        this.dir = (0, import_path10.join)(projectRoot, ".gossip");
-        this.perfPath = (0, import_path10.join)(this.dir, "agent-performance.jsonl");
-        this.driftPath = (0, import_path10.join)(this.dir, "pipeline-drift.jsonl");
-        this.statePath = (0, import_path10.join)(this.dir, "pipeline-drift.state");
+        this.dir = (0, import_path9.join)(projectRoot, ".gossip");
+        this.perfPath = (0, import_path9.join)(this.dir, "agent-performance.jsonl");
+        this.driftPath = (0, import_path9.join)(this.dir, "pipeline-drift.jsonl");
+        this.statePath = (0, import_path9.join)(this.dir, "pipeline-drift.state");
         this.opts = {
-          windowSize: options.windowSize ?? DEFAULTS2.windowSize,
-          bypassThreshold: options.bypassThreshold ?? DEFAULTS2.bypassThreshold,
-          unknownThresholdRate: options.unknownThresholdRate ?? DEFAULTS2.unknownThresholdRate,
-          minDenominator: options.minDenominator ?? DEFAULTS2.minDenominator,
-          enabled: options.enabled ?? DEFAULTS2.enabled
+          windowSize: options.windowSize ?? DEFAULTS.windowSize,
+          bypassThreshold: options.bypassThreshold ?? DEFAULTS.bypassThreshold,
+          unknownThresholdRate: options.unknownThresholdRate ?? DEFAULTS.unknownThresholdRate,
+          minDenominator: options.minDenominator ?? DEFAULTS.minDenominator,
+          enabled: options.enabled ?? DEFAULTS.enabled
         };
       }
       /** Read the last detection row from `pipeline-drift.jsonl`, or null. */
       readLastReport() {
         try {
-          if (!(0, import_fs9.existsSync)(this.driftPath)) return null;
-          const raw = (0, import_fs9.readFileSync)(this.driftPath, "utf8");
+          if (!(0, import_fs8.existsSync)(this.driftPath)) return null;
+          const raw = (0, import_fs8.readFileSync)(this.driftPath, "utf8");
           const lines = raw.split("\n").filter((l) => l.length > 0);
           if (lines.length === 0) return null;
           const last = lines[lines.length - 1];
@@ -9962,9 +9890,9 @@ var init_pipeline_drift_detector = __esm({
         const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
         const row = { ...result, detectedAt };
         try {
-          if (!(0, import_fs9.existsSync)(this.dir)) (0, import_fs9.mkdirSync)(this.dir, { recursive: true });
+          if (!(0, import_fs8.existsSync)(this.dir)) (0, import_fs8.mkdirSync)(this.dir, { recursive: true });
           rotateJsonlIfNeeded2(this.driftPath);
-          (0, import_fs9.appendFileSync)(this.driftPath, JSON.stringify(row) + "\n");
+          (0, import_fs8.appendFileSync)(this.driftPath, JSON.stringify(row) + "\n");
         } catch (err) {
           try {
             process.stderr.write(`[gossipcat] drift jsonl write failed: ${err.message}
@@ -9977,8 +9905,8 @@ var init_pipeline_drift_detector = __esm({
           const safeSignal = first ? escapeControlChars(first.signal) : "";
           const safePath = first ? escapeControlChars(first.emissionPath) : "";
           const safeTask = first ? escapeControlChars(first.taskId) : "";
-          const mcpLog = (0, import_path10.join)(this.dir, "mcp.log");
-          (0, import_fs9.appendFileSync)(
+          const mcpLog = (0, import_path9.join)(this.dir, "mcp.log");
+          (0, import_fs8.appendFileSync)(
             mcpLog,
             `[drift] bypass=${bypassCount}/${rows.length} unknown=${unknownCount}/${postEpochCount} first_offender={path=${safePath} signal=${safeSignal} task=${safeTask}}
 `
@@ -9990,8 +9918,8 @@ var init_pipeline_drift_detector = __esm({
       }
       readState() {
         try {
-          if (!(0, import_fs9.existsSync)(this.statePath)) return {};
-          const raw = (0, import_fs9.readFileSync)(this.statePath, "utf8");
+          if (!(0, import_fs8.existsSync)(this.statePath)) return {};
+          const raw = (0, import_fs8.readFileSync)(this.statePath, "utf8");
           const parsed = JSON.parse(raw);
           return parsed && typeof parsed === "object" ? parsed : {};
         } catch {
@@ -10000,8 +9928,8 @@ var init_pipeline_drift_detector = __esm({
       }
       writeState(next) {
         try {
-          if (!(0, import_fs9.existsSync)(this.dir)) (0, import_fs9.mkdirSync)(this.dir, { recursive: true });
-          (0, import_fs9.writeFileSync)(this.statePath, JSON.stringify(next));
+          if (!(0, import_fs8.existsSync)(this.dir)) (0, import_fs8.mkdirSync)(this.dir, { recursive: true });
+          (0, import_fs8.writeFileSync)(this.statePath, JSON.stringify(next));
         } catch {
         }
       }
@@ -10012,9 +9940,9 @@ var init_pipeline_drift_detector = __esm({
 // packages/orchestrator/src/performance-writer.ts
 function rotateJsonlIfNeeded2(filePath, maxBytes = MAX_TELEMETRY_BYTES) {
   try {
-    const st = (0, import_fs10.statSync)(filePath);
+    const st = (0, import_fs9.statSync)(filePath);
     if (st.size < maxBytes) return;
-    (0, import_fs10.renameSync)(filePath, filePath + ".1");
+    (0, import_fs9.renameSync)(filePath, filePath + ".1");
   } catch {
   }
 }
@@ -10077,12 +10005,12 @@ function bumpSampleCounter(projectRoot, delta) {
     }
   }
 }
-var import_fs10, import_path11, 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, PerformanceWriter;
+var import_fs9, import_path10, 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, PerformanceWriter;
 var init_performance_writer = __esm({
   "packages/orchestrator/src/performance-writer.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path11 = require("path");
+    import_fs9 = require("fs");
+    import_path10 = require("path");
     init_consensus_types();
     init_round_counter();
     loggedCounterErrors = /* @__PURE__ */ new Set();
@@ -10109,7 +10037,12 @@ var init_performance_writer = __esm({
       "consensus_coverage_degraded",
       // Sandbox policy violation — recorded for observability, zero weight in scoring.
       // Consensus round bb03845d-64264402 (7/7 confirmed).
-      "boundary_escape"
+      "boundary_escape",
+      // Transport-layer failure (relay-worker resolutionRoots gap, missing/deleted
+      // worktree, cwd misrouting). Excluded from accuracy/uniqueness arithmetic
+      // per performance-reader.ts:950 + L75. Pre-PR #329: rejected by validateSignal
+      // and silently dropped, masking the fail-closed signal emit added in PR #328.
+      "transport_failure"
     ]);
     VALID_IMPL_SIGNALS = /* @__PURE__ */ new Set([
       "impl_test_pass",
@@ -10149,9 +10082,9 @@ var init_performance_writer = __esm({
       filePath;
       projectRoot;
       constructor(projectRoot) {
-        const dir = (0, import_path11.join)(projectRoot, ".gossip");
-        if (!(0, import_fs10.existsSync)(dir)) (0, import_fs10.mkdirSync)(dir, { recursive: true });
-        this.filePath = (0, import_path11.join)(dir, "agent-performance.jsonl");
+        const dir = (0, import_path10.join)(projectRoot, ".gossip");
+        if (!(0, import_fs9.existsSync)(dir)) (0, import_fs9.mkdirSync)(dir, { recursive: true });
+        this.filePath = (0, import_path10.join)(dir, "agent-performance.jsonl");
         this.projectRoot = projectRoot;
       }
       /**
@@ -10205,7 +10138,7 @@ var init_performance_writer = __esm({
             }
           }
           try {
-            (0, import_fs10.appendFileSync)(this.filePath, payload);
+            (0, import_fs9.appendFileSync)(this.filePath, payload);
           } catch (writeErr) {
             const cid = deriveConsensusId(signal);
             if (cid) {
@@ -10253,7 +10186,7 @@ var init_performance_writer = __esm({
           const data = parts.join("\n") + "\n";
           rotateJsonlIfNeeded2(this.filePath);
           try {
-            (0, import_fs10.appendFileSync)(this.filePath, data);
+            (0, import_fs9.appendFileSync)(this.filePath, data);
           } catch (writeErr) {
             for (const s of signals) {
               const cid = deriveConsensusId(s);
@@ -10313,7 +10246,7 @@ var init_performance_writer = __esm({
         validateSignal(classStamped);
         const stamped = { ...classStamped, _emission_path: "mcp-server-signals" };
         try {
-          (0, import_fs10.appendFileSync)(this.filePath, JSON.stringify(stamped) + "\n");
+          (0, import_fs9.appendFileSync)(this.filePath, JSON.stringify(stamped) + "\n");
         } finally {
           try {
             reset(this.projectRoot, consensusId);
@@ -10405,6 +10338,118 @@ var init_signal_helpers = __esm({
   }
 });
 
+// packages/orchestrator/src/skill-parser.ts
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const lines = match[1].split("\n");
+  const fields = {};
+  for (const line of lines) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    let value = line.slice(colonIdx + 1).trim();
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    fields[key] = value;
+  }
+  if (!fields.name || !fields.description || !fields.status) return null;
+  let keywords = [];
+  if (fields.keywords) {
+    const raw = fields.keywords;
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      keywords = raw.slice(1, -1).split(",").map((k) => k.trim().replace(/^['"]|['"]$/g, "").slice(0, 100)).filter(Boolean);
+    } else {
+      keywords = raw.split(",").map((k) => k.trim().slice(0, 100)).filter(Boolean);
+    }
+  }
+  const rawTaskType = fields.task_type;
+  const task_type = rawTaskType === "review" || rawTaskType === "implement" || rawTaskType === "research" || rawTaskType === "any" ? rawTaskType : "any";
+  let scope;
+  if (fields.scope) {
+    const raw = fields.scope.trim();
+    let tokens;
+    if (raw.startsWith("[") && raw.endsWith("]")) {
+      tokens = raw.slice(1, -1).split(",").map((t) => t.trim().replace(/^['"]|['"]$/g, ""));
+    } else {
+      tokens = [raw.replace(/^['"]|['"]$/g, "")];
+    }
+    const valid = tokens.filter(
+      (t) => t === "review" || t === "implement" || t === "research"
+    );
+    if (valid.length > 0) scope = valid;
+  }
+  return {
+    name: normalizeSkillName(fields.name),
+    description: fields.description,
+    keywords,
+    category: fields.category || void 0,
+    mode: fields.mode === "contextual" ? "contextual" : fields.mode === "permanent" ? "permanent" : void 0,
+    generated_by: fields.generated_by,
+    sources: fields.sources,
+    status: fields.status,
+    task_type,
+    scope
+  };
+}
+var init_skill_parser = __esm({
+  "packages/orchestrator/src/skill-parser.ts"() {
+    "use strict";
+    init_skill_name();
+  }
+});
+
+// packages/orchestrator/src/memory-config.ts
+function loadMemoryConfig(projectRoot) {
+  const configPath = (0, import_path11.resolve)(projectRoot, ".gossip", "memory-config.json");
+  if (!(0, import_fs10.existsSync)(configPath)) {
+    return { ...DEFAULTS2, bundledMemories: { ...DEFAULTS2.bundledMemories } };
+  }
+  let raw;
+  try {
+    raw = (0, import_fs10.readFileSync)(configPath, "utf-8");
+  } catch (err) {
+    log("memory-config", `WARNING: failed to read ${configPath}: ${err?.message ?? err} \u2014 using defaults`);
+    return { ...DEFAULTS2, bundledMemories: { ...DEFAULTS2.bundledMemories } };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    log("memory-config", `WARNING: malformed JSON in ${configPath}: ${err?.message ?? err} \u2014 using defaults`);
+    return { ...DEFAULTS2, bundledMemories: { ...DEFAULTS2.bundledMemories } };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    log("memory-config", `WARNING: ${configPath} must be a JSON object \u2014 using defaults`);
+    return { ...DEFAULTS2, bundledMemories: { ...DEFAULTS2.bundledMemories } };
+  }
+  const obj = parsed;
+  const bm = obj.bundledMemories;
+  if (typeof bm !== "object" || bm === null || Array.isArray(bm)) {
+    return { ...DEFAULTS2, bundledMemories: { ...DEFAULTS2.bundledMemories } };
+  }
+  const bmObj = bm;
+  const enabled = typeof bmObj.enabled === "boolean" ? bmObj.enabled : DEFAULTS2.bundledMemories.enabled;
+  const exclude = Array.isArray(bmObj.exclude) ? bmObj.exclude.filter((x) => typeof x === "string") : DEFAULTS2.bundledMemories.exclude;
+  return { bundledMemories: { enabled, exclude } };
+}
+var import_fs10, import_path11, DEFAULTS2;
+var init_memory_config = __esm({
+  "packages/orchestrator/src/memory-config.ts"() {
+    "use strict";
+    import_fs10 = require("fs");
+    import_path11 = require("path");
+    init_log();
+    DEFAULTS2 = {
+      bundledMemories: {
+        enabled: true,
+        exclude: []
+      }
+    };
+  }
+});
+
 // packages/orchestrator/src/skill-loader.ts
 function categoryBoost(skillCategory, categories) {
   if (!skillCategory || categories.length === 0) return 0;
@@ -11039,6 +11084,7 @@ ${content}
           }
           const confirmed = entry.confirmedBy;
           if (!Array.isArray(confirmed) || confirmed.length === 0) continue;
+          if (entry.type === "insight") continue;
           const ts2 = entry.timestamp;
           if (ts2) {
             const ms = typeof ts2 === "number" ? ts2 : new Date(ts2).getTime();
@@ -14471,7 +14517,13 @@ var init_performance_reader = __esm({
       boundary_escape: true,
       task_timeout: true,
       task_empty: true,
-      consensus_coverage_degraded: true
+      consensus_coverage_degraded: true,
+      // Operational rewrite from hallucination_caught when the relay worker ran
+      // without the dispatched resolutionRoots (Path 2, spec
+      // docs/specs/2026-04-29-relay-worker-resolution-roots.md). Listed here so the
+      // scoring switch's exhaustiveness check holds; it's a no-op for accuracy /
+      // uniqueness / circuit breaker — only `transport_failure_count` is bumped.
+      transport_failure: true
     };
     SEVERITY_MULTIPLIER = {
       critical: 4,
@@ -14609,9 +14661,9 @@ var init_performance_reader = __esm({
       /** Get a reliability multiplier for dispatch weighting (0.3 to 2.0) */
       getDispatchWeight(agentId) {
         const score = this.getAgentScore(agentId);
-        if (!score || score.totalSignals < 3) return 1;
+        if (!score || score.scoringSignals < 3) return 1;
         if (score.circuitOpen) return 0.3;
-        const confidence = 1 - Math.exp(-score.totalSignals / 10);
+        const confidence = 1 - Math.exp(-score.scoringSignals / 10);
         const consensusAdjusted = 0.5 + (score.reliability - 0.5) * confidence;
         return clamp(0.3 + consensusAdjusted * 1.7, 0.3, 2);
       }
@@ -14696,8 +14748,8 @@ var init_performance_reader = __esm({
       isBenched(agentId, categories, allAgentIds) {
         const score = this.getAgentScore(agentId);
         if (!score) return { benched: false };
-        const ruleA = score.accuracy < 0.3 && score.totalSignals >= 200;
-        const hallRate = score.totalSignals > 0 ? score.weightedHallucinations / score.totalSignals : 0;
+        const ruleA = score.accuracy < 0.3 && score.scoringSignals >= 200;
+        const hallRate = score.scoringSignals > 0 ? score.weightedHallucinations / score.scoringSignals : 0;
         const ruleB = score.weightedHallucinations >= 5 && hallRate > 0.4;
         if (!ruleA && !ruleB) return { benched: false };
         const reason = ruleA ? "chronic-low-accuracy" : "burst-hallucination";
@@ -14910,10 +14962,12 @@ var init_performance_reader = __esm({
             unverifiedsEmitted: 0,
             unverifiedsReceived: 0,
             totalSignals: 0,
+            scoringSignals: 0,
             lastSignalMs: 0,
             categoryStrengths: {},
             categoryCorrect: {},
-            categoryHallucinated: {}
+            categoryHallucinated: {},
+            transportFailures: 0
           });
           return acc.get(id);
         };
@@ -15017,6 +15071,7 @@ var init_performance_reader = __esm({
             case "category_confirmed":
             case "consensus_verified": {
               const diversityMul = signal.signal === "agreement" ? peerDiversity.get(signal.agentId) ?? 1 : 1;
+              a.scoringSignals++;
               a.weightedCorrect += sevMul * decay * diversityMul;
               a.weightedTotal += sevMul * decay * diversityMul;
               a.agreements++;
@@ -15030,8 +15085,9 @@ var init_performance_reader = __esm({
             }
             case "disagreement": {
               if (!signal.category) {
-                continue;
+                break;
               }
+              a.scoringSignals++;
               a.weightedTotal += sevMul * decay;
               a.disagreements++;
               if (signal.counterpartId && signal.counterpartId.length > 0) {
@@ -15047,6 +15103,7 @@ var init_performance_reader = __esm({
               break;
             }
             case "unverified": {
+              a.scoringSignals++;
               a.weightedTotal += decay * 0.02;
               a.unverifiedsEmitted++;
               if (signal.counterpartId && signal.counterpartId.length > 0) {
@@ -15056,6 +15113,7 @@ var init_performance_reader = __esm({
               break;
             }
             case "unique_confirmed": {
+              a.scoringSignals++;
               a.weightedCorrect += sevMul * decay;
               a.weightedTotal += sevMul * decay;
               a.weightedUnique += 0.2 * sevMul * decay;
@@ -15068,11 +15126,13 @@ var init_performance_reader = __esm({
               break;
             }
             case "unique_unconfirmed": {
+              a.scoringSignals++;
               a.weightedUnique += 0.05 * decay;
               a.uniqueFindings++;
               break;
             }
             case "new_finding": {
+              a.scoringSignals++;
               a.weightedUnique += 0.15 * decay;
               a.uniqueFindings++;
               break;
@@ -15099,6 +15159,7 @@ var init_performance_reader = __esm({
                   }
                 }
               }
+              a.scoringSignals++;
               a.weightedHallucinations += severity * hallucDecay * gatedMultiplier;
               a.weightedTotal += decay;
               a.hallucinations++;
@@ -15110,6 +15171,9 @@ var init_performance_reader = __esm({
             case "task_timeout":
             case "task_empty":
               break;
+            case "transport_failure":
+              a.transportFailures++;
+              break;
             case "boundary_escape":
               break;
           }
@@ -15118,6 +15182,7 @@ var init_performance_reader = __esm({
         const signalsByAgent = /* @__PURE__ */ new Map();
         for (const signal of consensusSignals) {
           if (!KNOWN_SIGNALS[signal.signal]) continue;
+          if (signal.signal === "transport_failure") continue;
           const list = signalsByAgent.get(signal.agentId) || [];
           list.push(signal);
           signalsByAgent.set(signal.agentId, list);
@@ -15180,6 +15245,7 @@ var init_performance_reader = __esm({
             reliability,
             impactScore,
             totalSignals: a.totalSignals,
+            scoringSignals: a.scoringSignals,
             agreements: a.agreements,
             disagreements: a.disagreements,
             uniqueFindings: a.uniqueFindings,
@@ -15192,7 +15258,8 @@ var init_performance_reader = __esm({
             categoryStrengths: a.categoryStrengths,
             categoryCorrect: { ...a.categoryCorrect },
             categoryHallucinated: { ...a.categoryHallucinated },
-            categoryAccuracy
+            categoryAccuracy,
+            transport_failure_count: a.transportFailures
           });
         }
         for (const [agentId, consec] of consecutiveFailures) {
@@ -15204,6 +15271,7 @@ var init_performance_reader = __esm({
               reliability: 0.5,
               impactScore: 0.5,
               totalSignals: 0,
+              scoringSignals: 0,
               agreements: 0,
               disagreements: 0,
               uniqueFindings: 0,
@@ -15216,7 +15284,8 @@ var init_performance_reader = __esm({
               categoryStrengths: {},
               categoryCorrect: {},
               categoryHallucinated: {},
-              categoryAccuracy: {}
+              categoryAccuracy: {},
+              transport_failure_count: 0
             });
           }
         }
@@ -18263,6 +18332,8 @@ var init_dispatch_pipeline = __esm({
     import_fs27 = require("fs");
     import_path29 = require("path");
     init_types2();
+    init_worker_agent();
+    init_signal_helpers();
     init_skill_loader();
     init_prompt_assembler();
     init_agent_memory();
@@ -18493,10 +18564,14 @@ var init_dispatch_pipeline = __esm({
         entry.scope = options?.scope;
         entry.planId = options?.planId;
         entry.planStep = options?.step;
+        if (options?.resolutionRoots && options.resolutionRoots.length > 0) {
+          entry.resolutionRoots = options.resolutionRoots;
+        }
         if (options?.writeMode === "scoped" && options.scope) {
           this.scopeTracker.register(options.scope, taskId);
         }
         const prevSequential = options?.writeMode === "sequential" ? this.sequentialQueues.get(agentId) : void 0;
+        let resolutionRootAssigned = false;
         const runTask = async () => {
           if (prevSequential) await prevSequential.catch(() => {
           });
@@ -18505,6 +18580,37 @@ var init_dispatch_pipeline = __esm({
             entry.worktreeInfo = wtInfo;
             this.toolServer?.assignRoot(agentId, wtInfo.path);
           }
+          const rrCandidate = options?.resolutionRoots?.[0];
+          if (rrCandidate && worker instanceof WorkerAgent) {
+            let dirOk = false;
+            try {
+              dirOk = (0, import_fs27.existsSync)(rrCandidate) && (0, import_fs27.statSync)(rrCandidate).isDirectory();
+            } catch {
+              dirOk = false;
+            }
+            if (!dirOk) {
+              const errMsg = `resolutionRoots[0] does not exist or is not a directory: ${rrCandidate}`;
+              try {
+                emitConsensusSignals(this.projectRoot, [{
+                  type: "consensus",
+                  signal: "transport_failure",
+                  agentId,
+                  taskId,
+                  evidence: `dispatch failed: ${errMsg}`,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  source: "auto"
+                }]);
+              } catch {
+              }
+              throw new Error(errMsg);
+            }
+            if (this.toolServer) {
+              this.toolServer.assignRoot(agentId, rrCandidate);
+              resolutionRootAssigned = true;
+              entry.resolutionRootAssigned = true;
+              gossipLog(`\u2192 resolutionRoots: assignRoot(${agentId}, ${rrCandidate}) [taskId=${taskId}]`);
+            }
+          }
           const stream = worker.executeTask(task, options?.lens, promptContent, taskId);
           entry.stream = stream;
           for await (const event of stream) {
@@ -18523,6 +18629,10 @@ var init_dispatch_pipeline = __esm({
                 entry.completedAt = Date.now();
                 entry.memoryQueryCalled = event.payload.memoryQueryCalled ?? false;
                 if (entry.writeMode === "scoped") this.scopeTracker.release(entry.id);
+                if (resolutionRootAssigned) {
+                  this.toolServer?.releaseAgent(agentId);
+                  resolutionRootAssigned = false;
+                }
                 try {
                   const elapsedMs = (entry.completedAt ?? Date.now()) - entry.startedAt;
                   gossipLog(`\u2705 relay \u2190 ${entry.agentId} [${entry.id}] OK (${(elapsedMs / 1e3).toFixed(1)}s, ${(event.payload.result || "").length} chars)`);
@@ -18557,6 +18667,10 @@ var init_dispatch_pipeline = __esm({
                   this.worktreeManager.cleanup(entry.id, entry.worktreeInfo.path).catch(() => {
                   });
                 }
+                if (resolutionRootAssigned) {
+                  this.toolServer?.releaseAgent(agentId);
+                  resolutionRootAssigned = false;
+                }
                 try {
                   const elapsedMs = (entry.completedAt ?? Date.now()) - entry.startedAt;
                   gossipLog(`\u274C relay \u2190 ${entry.agentId} [${entry.id}] FAILED (${(elapsedMs / 1e3).toFixed(1)}s) \u2014 ${event.payload.error}`);
@@ -18603,7 +18717,8 @@ var init_dispatch_pipeline = __esm({
           agentId: t.agentId,
           task: t.task,
           startedAt: t.startedAt,
-          timeoutMs: 3e5
+          timeoutMs: 3e5,
+          ...t.resolutionRoots && t.resolutionRoots.length > 0 ? { resolutionRoots: t.resolutionRoots } : {}
         }));
       }
       /** Get a health summary of all active tasks — for diagnostics when user asks "is it working?" */
@@ -18655,6 +18770,10 @@ var init_dispatch_pipeline = __esm({
               });
               this.toolServer?.releaseAgent(task.agentId);
             }
+            if (task.resolutionRootAssigned) {
+              this.toolServer?.releaseAgent(task.agentId);
+              task.resolutionRootAssigned = false;
+            }
             cancelled++;
           }
         }
@@ -18826,6 +18945,10 @@ Worktree merge: CONFLICT
             if (t.writeMode === "worktree") {
               this.toolServer?.releaseAgent(t.agentId);
             }
+            if (t.resolutionRootAssigned) {
+              this.toolServer?.releaseAgent(t.agentId);
+              t.resolutionRootAssigned = false;
+            }
           }
         }
         const results = [
@@ -20143,8 +20266,8 @@ Keep it SHORT \u2014 under 30 lines. This is a working document, not a design do
         ]);
         const specContent = response.text || "";
         try {
-          const { mkdirSync: mkdirSync30, writeFileSync: writeFS } = require("fs");
-          mkdirSync30((0, import_path30.join)(this.projectRoot, ".gossip"), { recursive: true });
+          const { mkdirSync: mkdirSync33, writeFileSync: writeFS } = require("fs");
+          mkdirSync33((0, import_path30.join)(this.projectRoot, ".gossip"), { recursive: true });
           writeFS(specPath, specContent, "utf-8");
         } catch (err) {
           return { text: `Spec generated but failed to save: ${err.message}
@@ -21088,8 +21211,8 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync61, readFileSync: readFileSync59 } = await import("fs");
-        const { join: join70 } = await import("path");
+        const { existsSync: existsSync64, readFileSync: readFileSync61 } = await import("fs");
+        const { join: join73 } = await import("path");
         for (const config2 of this.registry.getAll()) {
           if (config2.native) continue;
           if (this.workers.has(config2.id)) continue;
@@ -21098,8 +21221,8 @@ message: Your question?
             apiKey = await this.keyProviderFn(config2.provider) ?? void 0;
           }
           const llm = createProvider(config2.provider, config2.model, apiKey);
-          const instructionsPath = join70(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
-          const instructions = existsSync61(instructionsPath) ? readFileSync59(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join73(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
+          const instructions = existsSync64(instructionsPath) ? readFileSync61(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();
@@ -21292,8 +21415,8 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync61, readFileSync: readFileSync59 } = await import("fs");
-        const { join: join70 } = await import("path");
+        const { existsSync: existsSync64, readFileSync: readFileSync61 } = await import("fs");
+        const { join: join73 } = await import("path");
         let added = 0;
         for (const ac of this.registry.getAll()) {
           if (ac.native) continue;
@@ -21310,8 +21433,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 = join70(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
-          const instructions = existsSync61(instructionsPath) ? readFileSync59(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join73(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+          const instructions = existsSync64(instructionsPath) ? readFileSync61(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();
@@ -24249,6 +24372,86 @@ var init_memory_searcher = __esm({
   }
 });
 
+// packages/orchestrator/src/transport-failure-detector.ts
+function shouldRewriteToTransportFailure(signalName, ctx2) {
+  if (signalName !== "hallucination_caught") return false;
+  if (ctx2.isNativeAgent) return false;
+  if (!ctx2.hadResolutionRoots) return false;
+  if (!ctx2.findingText) return false;
+  if (!TRANSPORT_FAILURE_PATTERN.test(ctx2.findingText)) return false;
+  if (CITE_ANCHOR_PATTERN.test(ctx2.findingText)) return false;
+  return true;
+}
+function appendTransportRewrite(projectRoot, audit) {
+  try {
+    const filePath = (0, import_path45.join)(projectRoot, ".gossip", "transport-rewrites.jsonl");
+    (0, import_fs42.mkdirSync)((0, import_path45.dirname)(filePath), { recursive: true });
+    (0, import_fs42.appendFileSync)(filePath, JSON.stringify(audit) + "\n", "utf-8");
+  } catch (err) {
+    process.stderr.write(
+      `[gossipcat] appendTransportRewrite failed: ${err.message}
+`
+    );
+  }
+}
+function lookupRoundResolutionRoots(projectRoot, consensusId) {
+  try {
+    const reportPath = (0, import_path45.join)(
+      projectRoot,
+      ".gossip",
+      "consensus-reports",
+      `${consensusId}.json`
+    );
+    if (!(0, import_fs42.existsSync)(reportPath)) return [];
+    const raw = (0, import_fs42.readFileSync)(reportPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed.resolutionRoots) ? parsed.resolutionRoots : [];
+  } catch {
+    return [];
+  }
+}
+function extractConsensusId(findingId) {
+  if (!findingId) return void 0;
+  const match = findingId.match(/^([0-9a-f]{8}-[0-9a-f]{8})(?::|$)/);
+  return match ? match[1] : void 0;
+}
+function maybeRewriteHallucinationToTransportFailure(projectRoot, signal, isNativeAgent) {
+  if (signal.signal !== "hallucination_caught") return signal;
+  const consensusId = extractConsensusId(signal.findingId) ?? signal.consensusId ?? void 0;
+  if (!consensusId) return signal;
+  const roots = lookupRoundResolutionRoots(projectRoot, consensusId);
+  const findingText = `${signal.evidence ?? ""} ${signal.finding ?? ""}`.trim();
+  const ctx2 = {
+    isNativeAgent: isNativeAgent(signal.agentId),
+    hadResolutionRoots: roots.length > 0,
+    findingText
+  };
+  if (!shouldRewriteToTransportFailure(signal.signal, ctx2)) return signal;
+  appendTransportRewrite(projectRoot, {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    consensus_id: consensusId,
+    finding_id: signal.findingId,
+    agent_id: signal.agentId,
+    original_signal: "hallucination_caught",
+    rewritten_to: "transport_failure",
+    finding_excerpt: (signal.evidence ?? "").slice(0, 200)
+  });
+  return {
+    ...signal,
+    signal: "transport_failure"
+  };
+}
+var import_fs42, import_path45, TRANSPORT_FAILURE_PATTERN, CITE_ANCHOR_PATTERN;
+var init_transport_failure_detector = __esm({
+  "packages/orchestrator/src/transport-failure-detector.ts"() {
+    "use strict";
+    import_fs42 = require("fs");
+    import_path45 = require("path");
+    TRANSPORT_FAILURE_PATTERN = /files? (?:are )?(?:not present|missing)|empty diff|empty workspace|cannot be (?:read|located)|not (?:found|present) (?:on|in)(?: the)? (?:disk|filesystem|worktree)/i;
+    CITE_ANCHOR_PATTERN = /<cite\s+tag=["']file["']\s*>[^<]+<\/cite>/i;
+  }
+});
+
 // packages/orchestrator/src/_sanitize.ts
 function sanitizeForLog(raw, maxChars = 200) {
   let s = raw.replace(CONTROL_CHAR_RE, "\uFFFD");
@@ -24521,28 +24724,28 @@ var init_claim_types = __esm({
 function containWithinProject(projectRoot, input) {
   let resolved;
   try {
-    resolved = (0, import_path45.resolve)(projectRoot, input);
+    resolved = (0, import_path46.resolve)(projectRoot, input);
   } catch {
     return null;
   }
   let finalPath = resolved;
   try {
-    if ((0, import_fs42.existsSync)(resolved)) {
-      finalPath = (0, import_fs42.realpathSync)(resolved);
+    if ((0, import_fs43.existsSync)(resolved)) {
+      finalPath = (0, import_fs43.realpathSync)(resolved);
     }
   } catch {
     return null;
   }
   let rootReal = projectRoot;
   try {
-    if ((0, import_fs42.existsSync)(projectRoot)) {
-      rootReal = (0, import_fs42.realpathSync)(projectRoot);
+    if ((0, import_fs43.existsSync)(projectRoot)) {
+      rootReal = (0, import_fs43.realpathSync)(projectRoot);
     }
   } catch {
     return null;
   }
   if (finalPath === rootReal) return finalPath;
-  if (finalPath.startsWith(rootReal + import_path45.sep)) return finalPath;
+  if (finalPath.startsWith(rootReal + import_path46.sep)) return finalPath;
   return null;
 }
 function getModality(claim) {
@@ -24555,7 +24758,7 @@ function runRg(symbol2, scope, projectRoot, remainingMs) {
       return;
     }
     const scopePath = containWithinProject(projectRoot, scope);
-    if (scopePath === null || !(0, import_fs42.existsSync)(scopePath)) {
+    if (scopePath === null || !(0, import_fs43.existsSync)(scopePath)) {
       resolvePromise({ total: 0, error: "missing_path" });
       return;
     }
@@ -24656,12 +24859,12 @@ async function verifyCallsiteCount(claim, idx, projectRoot, remainingMs) {
 async function verifyFileLine(claim, idx, projectRoot) {
   const modality = getModality(claim);
   const filePath = containWithinProject(projectRoot, claim.path);
-  if (filePath === null || !(0, import_fs42.existsSync)(filePath)) {
+  if (filePath === null || !(0, import_fs43.existsSync)(filePath)) {
     return { claim_index: idx, status: "unverifiable_by_grep", reason: "file_not_found" };
   }
   let st;
   try {
-    st = (0, import_fs42.statSync)(filePath);
+    st = (0, import_fs43.statSync)(filePath);
   } catch {
     return { claim_index: idx, status: "unverifiable_by_grep", reason: "stat_failed" };
   }
@@ -24670,7 +24873,7 @@ async function verifyFileLine(claim, idx, projectRoot) {
   }
   let text;
   try {
-    text = (0, import_fs42.readFileSync)(filePath, "utf-8");
+    text = (0, import_fs43.readFileSync)(filePath, "utf-8");
   } catch {
     return { claim_index: idx, status: "unverifiable_by_grep", reason: "read_failed" };
   }
@@ -24821,13 +25024,13 @@ async function verifyClaims(block, projectRoot) {
   }
   return verdicts;
 }
-var import_child_process6, import_fs42, import_path45, MAX_CLAIMS_PER_BLOCK, PER_BLOCK_DEADLINE_MS;
+var import_child_process6, import_fs43, import_path46, MAX_CLAIMS_PER_BLOCK, PER_BLOCK_DEADLINE_MS;
 var init_claim_verifier = __esm({
   "packages/orchestrator/src/claim-verifier.ts"() {
     "use strict";
     import_child_process6 = require("child_process");
-    import_fs42 = require("fs");
-    import_path45 = require("path");
+    import_fs43 = require("fs");
+    import_path46 = require("path");
     init_sanitize();
     MAX_CLAIMS_PER_BLOCK = 16;
     PER_BLOCK_DEADLINE_MS = 500;
@@ -25182,42 +25385,81 @@ function runUnderLock(projectRoot, opts) {
       if (inferred) symbolsToCheck.add(inferred);
     }
     if (symbolsToCheck.size === 0) continue;
-    let allClear = true;
+    let sawAbsentEverywhere = false;
+    let sawPresentElsewhere = false;
+    let sawPresentAtAnchor = false;
+    let sawCiteWithoutLine = false;
+    let readFailure = false;
     for (const fc of safeFileCites) {
       let body;
       try {
         body = fs4.readFileSync(fc.absPath, "utf8");
       } catch {
-        allClear = false;
+        readFailure = true;
         break;
       }
       const stripped = stripJsTsComments(body);
       for (const sym of symbolsToCheck) {
-        if (containsToken(stripped, sym)) {
-          allClear = false;
-          break;
+        const presence = classifyPresence(
+          body,
+          stripped,
+          sym,
+          fc.line,
+          LINE_ANCHORED_WINDOW
+        );
+        if (presence.kind === "absent_everywhere") {
+          sawAbsentEverywhere = true;
+        } else if (presence.kind === "present_at_anchor") {
+          sawPresentAtAnchor = true;
+        } else {
+          sawPresentElsewhere = true;
+          if (fc.line === void 0) sawCiteWithoutLine = true;
         }
       }
-      if (!allClear) break;
     }
-    if (!allClear) continue;
+    if (readFailure) continue;
+    const allAbsentEverywhere = sawAbsentEverywhere && !sawPresentElsewhere && !sawPresentAtAnchor;
+    const allPresentElsewhere = sawPresentElsewhere && !sawAbsentEverywhere && !sawPresentAtAnchor && !sawCiteWithoutLine;
+    if (!allAbsentEverywhere && !(opts.lineAnchored && allPresentElsewhere)) {
+      continue;
+    }
     const findingId = String(entry.taskId ?? entry.findingId ?? "");
     const beforeQuote = Array.from(symbolsToCheck).slice(0, 3).join(", ");
-    const resolvedBy = headSha ? `commit:${headSha}` : "manual";
+    const useStaleAnchor = !allAbsentEverywhere && allPresentElsewhere;
+    const resolvedBy = useStaleAnchor ? "stale_anchor" : headSha ? `commit:${headSha}` : "manual";
     try {
       entry.status = "resolved";
       entry.resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
       entry.resolvedBy = resolvedBy;
       row.raw = JSON.stringify(entry);
-      appendChainedEntry(projectRoot, {
-        ts: entry.resolvedAt,
-        finding_id: findingId,
-        action: "resolve",
-        resolved_by: resolvedBy,
-        before_quote: beforeQuote,
-        after_check: "absent",
-        operator: "auto"
-      });
+      if (useStaleAnchor) {
+        const firstCite = safeFileCites[0];
+        if (firstCite.line === void 0) {
+          throw new Error("finding-resolver invariant: stale_anchor path reached with undefined cited line");
+        }
+        const citedLine = firstCite.line;
+        appendChainedEntry(projectRoot, {
+          ts: entry.resolvedAt,
+          finding_id: findingId,
+          action: "resolve",
+          resolved_by: "stale_anchor",
+          before_quote: beforeQuote,
+          after_check: "present_elsewhere_only",
+          operator: "auto",
+          cited_line: citedLine,
+          window: LINE_ANCHORED_WINDOW
+        });
+      } else {
+        appendChainedEntry(projectRoot, {
+          ts: entry.resolvedAt,
+          finding_id: findingId,
+          action: "resolve",
+          resolved_by: resolvedBy,
+          before_quote: beforeQuote,
+          after_check: "absent",
+          operator: "auto"
+        });
+      }
       resolvedCount++;
       resolvedFindingIds.push(findingId);
     } catch (err) {
@@ -25374,6 +25616,20 @@ function containsToken(haystack, token) {
   const re = new RegExp(`(^|[^A-Za-z0-9_$.])${escaped}(?![A-Za-z0-9_$])`);
   return re.test(haystack);
 }
+function classifyPresence(body, stripped, symbol2, citedLine, window) {
+  const inFile = containsToken(stripped, symbol2);
+  if (!inFile) return { kind: "absent_everywhere" };
+  if (citedLine === void 0) {
+    return { kind: "present_elsewhere" };
+  }
+  const lines = body.split("\n");
+  if (lines.length === 0) return { kind: "present_elsewhere" };
+  const lo = Math.max(0, citedLine - 1 - window);
+  const hi = Math.min(lines.length - 1, citedLine - 1 + window);
+  const windowText = lines.slice(lo, hi + 1).join("\n");
+  const inWindow = containsToken(windowText, symbol2);
+  return inWindow ? { kind: "present_at_anchor" } : { kind: "present_elsewhere" };
+}
 function loadConsensusReport(projectRoot, consensusId) {
   if (!/^[A-Za-z0-9_-]+$/.test(consensusId)) return null;
   const reportPath = path5.join(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
@@ -25500,7 +25756,7 @@ function computeTouchedSet(projectRoot, opts, gitRoot) {
   }
   return set2;
 }
-var fs4, os, path5, import_child_process7, FINDINGS_FILENAME, WATERMARK_FILENAME, COLD_START_SINCE, PATH_REJECT_REASONS, FILE_CITE_RE, FN_CITE_RE, PLAIN_FILE_CITE_RE, INFER_SKIP_LIST, SHA_RE, FINDING_RESOLVER_INTERNALS;
+var fs4, os, path5, import_child_process7, FINDINGS_FILENAME, WATERMARK_FILENAME, COLD_START_SINCE, LINE_ANCHORED_WINDOW, PATH_REJECT_REASONS, FILE_CITE_RE, FN_CITE_RE, PLAIN_FILE_CITE_RE, INFER_SKIP_LIST, SHA_RE, FINDING_RESOLVER_INTERNALS;
 var init_finding_resolver = __esm({
   "packages/orchestrator/src/finding-resolver.ts"() {
     "use strict";
@@ -25513,6 +25769,7 @@ var init_finding_resolver = __esm({
     FINDINGS_FILENAME = "implementation-findings.jsonl";
     WATERMARK_FILENAME = "last-resolve-scan.sha";
     COLD_START_SINCE = "90.days";
+    LINE_ANCHORED_WINDOW = 5;
     PATH_REJECT_REASONS = {
       TRAVERSAL: 'path contains ".." traversal',
       NUL: "path contains NUL byte",
@@ -25595,11 +25852,13 @@ __export(src_exports3, {
   MemoryCompactor: () => MemoryCompactor,
   MemorySearcher: () => MemorySearcher,
   MemoryWriter: () => MemoryWriter,
+  OPERATIONAL_SIGNAL_NAMES: () => OPERATIONAL_SIGNAL_NAMES,
   OllamaProvider: () => OllamaProvider,
   OpenAIProvider: () => OpenAIProvider,
   OverlapDetector: () => OverlapDetector,
   PARSE_FINDINGS_LIMITS: () => PARSE_FINDINGS_LIMITS,
   PENDING_PLAN_CHOICES: () => PENDING_PLAN_CHOICES,
+  PERFORMANCE_SIGNAL_NAMES: () => PERFORMANCE_SIGNAL_NAMES,
   PER_BLOCK_DEADLINE_MS: () => PER_BLOCK_DEADLINE_MS,
   PLAN_CHOICES: () => PLAN_CHOICES,
   PerformanceReader: () => PerformanceReader,
@@ -25619,9 +25878,11 @@ __export(src_exports3, {
   TIMEOUT_DAYS: () => TIMEOUT_DAYS,
   TIMEOUT_MS: () => TIMEOUT_MS,
   TOOL_SCHEMAS: () => TOOL_SCHEMAS2,
+  TRANSPORT_FAILURE_PATTERN: () => TRANSPORT_FAILURE_PATTERN,
   TaskDispatcher: () => TaskDispatcher,
   TaskGraph: () => TaskGraph,
   TaskGraphSync: () => TaskGraphSync,
+  TaskStreamEventType: () => TaskStreamEventType,
   TeamManager: () => TeamManager,
   ToolExecutor: () => ToolExecutor,
   ToolRouter: () => ToolRouter,
@@ -25631,6 +25892,7 @@ __export(src_exports3, {
   ZERO_HASH: () => ZERO_HASH,
   Z_CRITICAL: () => Z_CRITICAL,
   appendChainedEntry: () => appendChainedEntry,
+  appendTransportRewrite: () => appendTransportRewrite,
   applyStatusTags: () => applyStatusTags,
   assemblePrompt: () => assemblePrompt,
   assembleUtilityPrompt: () => assembleUtilityPrompt,
@@ -25638,6 +25900,7 @@ __export(src_exports3, {
   buildToolSystemPrompt: () => buildToolSystemPrompt,
   buildUtilityAgentPrompt: () => buildUtilityAgentPrompt,
   bumpRoundCounter: () => bump,
+  classifyPresence: () => classifyPresence,
   classifySignal: () => classifySignal,
   computeCooldown: () => computeCooldown,
   computeDedupeKey: () => computeDedupeKey,
@@ -25657,6 +25920,7 @@ __export(src_exports3, {
   emitScoringAdjustmentSignals: () => emitScoringAdjustmentSignals,
   ensureRulesFile: () => ensureRulesFile,
   extractCategories: () => extractCategories,
+  extractConsensusId: () => extractConsensusId,
   extractSpecReferences: () => extractSpecReferences,
   findBundledHook: () => findBundledHook,
   findBundledRules: () => findBundledRules,
@@ -25672,6 +25936,8 @@ __export(src_exports3, {
   loadMemoryConfig: () => loadMemoryConfig,
   loadSkills: () => loadSkills,
   logUncategorizedFinding: () => logUncategorizedFinding,
+  lookupRoundResolutionRoots: () => lookupRoundResolutionRoots,
+  maybeRewriteHallucinationToTransportFailure: () => maybeRewriteHallucinationToTransportFailure,
   normalizeSkillName: () => normalizeSkillName,
   oneSidedZTest: () => oneSidedZTest,
   parseAgentFindingsStrict: () => parseAgentFindingsStrict,
@@ -25691,6 +25957,7 @@ __export(src_exports3, {
   sanitizeForLog: () => sanitizeForLog,
   seedMemoryHygiene: () => seedMemoryHygiene,
   selectCrossReviewers: () => selectCrossReviewers,
+  shouldRewriteToTransportFailure: () => shouldRewriteToTransportFailure,
   shouldSkipConsensus: () => shouldSkipConsensus,
   stableStringify: () => stableStringify,
   stripJsTsComments: () => stripJsTsComments,
@@ -25761,6 +26028,7 @@ var init_src4 = __esm({
     init_check_effectiveness();
     init_completion_signals();
     init_signal_helpers();
+    init_transport_failure_detector();
     init_completion_signals_allowlist();
     init_pipeline_drift_detector();
     init_memory_config();
@@ -25771,6 +26039,7 @@ var init_src4 = __esm({
     init_file_lock();
     init_audit_log_chain();
     init_finding_resolver();
+    init_task_stream();
   }
 });
 
@@ -26535,7 +26804,7 @@ var init_utility_agents = __esm({
 // packages/relay/src/dashboard/api-overview.ts
 function readSkillStatus(path6) {
   try {
-    const content = (0, import_fs43.readFileSync)(path6, "utf-8");
+    const content = (0, import_fs44.readFileSync)(path6, "utf-8");
     const m = content.match(/^---\n([\s\S]*?)\n---/);
     if (!m) return null;
     const block = m[1];
@@ -26549,24 +26818,24 @@ function readSkillStatus(path6) {
   }
 }
 function computeSkillVerdictSummary(projectRoot) {
-  const agentsDir = (0, import_path46.join)(projectRoot, ".gossip", "agents");
-  if (!(0, import_fs43.existsSync)(agentsDir)) return void 0;
+  const agentsDir = (0, import_path47.join)(projectRoot, ".gossip", "agents");
+  if (!(0, import_fs44.existsSync)(agentsDir)) return void 0;
   const summary = { pending: 0, passed: 0, failed: 0, silent_skill: 0, insufficient_evidence: 0, inconclusive: 0 };
   let seen = false;
   try {
-    const agentIds = (0, import_fs43.readdirSync)(agentsDir);
+    const agentIds = (0, import_fs44.readdirSync)(agentsDir);
     for (const agentId of agentIds) {
-      const skillsDir = (0, import_path46.join)(agentsDir, agentId, "skills");
-      if (!(0, import_fs43.existsSync)(skillsDir)) continue;
+      const skillsDir = (0, import_path47.join)(agentsDir, agentId, "skills");
+      if (!(0, import_fs44.existsSync)(skillsDir)) continue;
       let entries;
       try {
-        entries = (0, import_fs43.readdirSync)(skillsDir);
+        entries = (0, import_fs44.readdirSync)(skillsDir);
       } catch {
         continue;
       }
       for (const entry of entries) {
         if (!entry.endsWith(".md")) continue;
-        const status = readSkillStatus((0, import_path46.join)(skillsDir, entry));
+        const status = readSkillStatus((0, import_path47.join)(skillsDir, entry));
         if (!status) continue;
         seen = true;
         if (status === "pending") summary.pending++;
@@ -26583,13 +26852,13 @@ function computeSkillVerdictSummary(projectRoot) {
   return seen ? summary : summary;
 }
 function computeDroppedFindingTypeCounts(projectRoot) {
-  const dir = (0, import_path46.join)(projectRoot, ".gossip", "consensus-reports");
-  if (!(0, import_fs43.existsSync)(dir)) return void 0;
+  const dir = (0, import_path47.join)(projectRoot, ".gossip", "consensus-reports");
+  if (!(0, import_fs44.existsSync)(dir)) return void 0;
   try {
-    const files = (0, import_fs43.readdirSync)(dir).filter((f) => f.endsWith(".json")).map((f) => {
-      const full = (0, import_path46.join)(dir, f);
+    const files = (0, import_fs44.readdirSync)(dir).filter((f) => f.endsWith(".json")).map((f) => {
+      const full = (0, import_path47.join)(dir, f);
       try {
-        return { full, mtime: (0, import_fs43.statSync)(full).mtimeMs };
+        return { full, mtime: (0, import_fs44.statSync)(full).mtimeMs };
       } catch {
         return null;
       }
@@ -26598,7 +26867,7 @@ function computeDroppedFindingTypeCounts(projectRoot) {
     let seen = false;
     for (const { full } of files) {
       try {
-        const report = JSON.parse((0, import_fs43.readFileSync)(full, "utf-8"));
+        const report = JSON.parse((0, import_fs44.readFileSync)(full, "utf-8"));
         const dropped = report?.droppedFindingsByType;
         if (!dropped || typeof dropped !== "object") continue;
         for (const [type, count] of Object.entries(dropped)) {
@@ -26627,12 +26896,12 @@ async function overviewHandler(projectRoot, ctx2) {
   const hourlyActivity = new Array(12).fill(0);
   const now = Date.now();
   const hourMs = 60 * 60 * 1e3;
-  const graphPath = (0, import_path46.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if ((0, import_fs43.existsSync)(graphPath)) {
+  const graphPath = (0, import_path47.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if ((0, import_fs44.existsSync)(graphPath)) {
     try {
       const created = /* @__PURE__ */ new Map();
       const finished = /* @__PURE__ */ new Set();
-      const lines = (0, import_fs43.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = (0, import_fs44.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const ev = JSON.parse(line);
@@ -26685,10 +26954,10 @@ async function overviewHandler(projectRoot, ctx2) {
   let lastConsensusTimestamp = "";
   let actionableFindings = 0;
   const runBuckets = /* @__PURE__ */ new Map();
-  const perfPath = (0, import_path46.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if ((0, import_fs43.existsSync)(perfPath)) {
+  const perfPath = (0, import_path47.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if ((0, import_fs44.existsSync)(perfPath)) {
     try {
-      const lines = (0, import_fs43.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = (0, import_fs44.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const entry = JSON.parse(line);
@@ -26738,12 +27007,12 @@ async function overviewHandler(projectRoot, ctx2) {
   const droppedFindingTypeCounts = computeDroppedFindingTypeCounts(projectRoot);
   return { agentsOnline, relayCount, relayConnected, nativeCount, consensusRuns, totalFindings, confirmedFindings, totalSignals, tasksCompleted, tasksFailed, avgDurationMs, lastConsensusTimestamp, actionableFindings, hourlyActivity, skillVerdictSummary, droppedFindingTypeCounts };
 }
-var import_fs43, import_path46;
+var import_fs44, import_path47;
 var init_api_overview = __esm({
   "packages/relay/src/dashboard/api-overview.ts"() {
     "use strict";
-    import_fs43 = require("fs");
-    import_path46 = require("path");
+    import_fs44 = require("fs");
+    import_path47 = require("path");
     init_utility_agents();
   }
 });
@@ -26769,16 +27038,16 @@ function cacheSet(key, value) {
 async function fleetTrendHandler(projectRoot, query) {
   const rawDays = parseInt(query?.get("days") ?? "", 10);
   const days = isNaN(rawDays) || rawDays < 1 ? DEFAULT_DAYS : Math.min(rawDays, MAX_DAYS);
-  const perfPath = (0, import_path47.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs44.existsSync)(perfPath)) return { days, points: [] };
-  const mtime = (0, import_fs44.statSync)(perfPath).mtimeMs;
+  const perfPath = (0, import_path48.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs45.existsSync)(perfPath)) return { days, points: [] };
+  const mtime = (0, import_fs45.statSync)(perfPath).mtimeMs;
   const cacheKey = `${projectRoot}::${days}`;
   const cached3 = cacheGet(cacheKey);
   if (cached3 && cached3.mtime === mtime) return cached3.payload;
   const cutoff = Date.now() - days * DAY_MS2;
   const buckets = /* @__PURE__ */ new Map();
   try {
-    const lines = (0, import_fs44.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs45.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -26815,18 +27084,18 @@ async function fleetTrendHandler(projectRoot, query) {
   const payload = { days, points };
   let postMtime = null;
   try {
-    postMtime = (0, import_fs44.statSync)(perfPath).mtimeMs;
+    postMtime = (0, import_fs45.statSync)(perfPath).mtimeMs;
   } catch {
   }
   if (postMtime === mtime) cacheSet(cacheKey, { mtime, payload });
   return payload;
 }
-var import_fs44, import_path47, DEFAULT_DAYS, MAX_DAYS, DAY_MS2, CACHE_MAX, cache;
+var import_fs45, import_path48, DEFAULT_DAYS, MAX_DAYS, DAY_MS2, CACHE_MAX, cache;
 var init_api_fleet_trend = __esm({
   "packages/relay/src/dashboard/api-fleet-trend.ts"() {
     "use strict";
-    import_fs44 = require("fs");
-    import_path47 = require("path");
+    import_fs45 = require("fs");
+    import_path48 = require("path");
     DEFAULT_DAYS = 30;
     MAX_DAYS = 90;
     DAY_MS2 = 24 * 60 * 60 * 1e3;
@@ -26838,9 +27107,9 @@ var init_api_fleet_trend = __esm({
 // packages/relay/src/dashboard/api-agents.ts
 function readSkillFrontmatter(projectRoot, agentId, skillName) {
   try {
-    const path6 = (0, import_path48.join)(projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
-    if (!(0, import_fs45.existsSync)(path6)) return null;
-    const raw = (0, import_fs45.readFileSync)(path6, "utf-8");
+    const path6 = (0, import_path49.join)(projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
+    if (!(0, import_fs46.existsSync)(path6)) return null;
+    const raw = (0, import_fs46.readFileSync)(path6, "utf-8");
     if (!raw.startsWith("---")) return null;
     const end = raw.indexOf("\n---", 3);
     if (end === -1) return null;
@@ -26876,9 +27145,9 @@ function normalizeCategory(s) {
 }
 function readForcedDevelops(projectRoot, agentId, category) {
   try {
-    const path6 = (0, import_path48.join)(projectRoot, ".gossip", "forced-skill-develops.jsonl");
-    if (!(0, import_fs45.existsSync)(path6)) return [];
-    const raw = (0, import_fs45.readFileSync)(path6, "utf-8");
+    const path6 = (0, import_path49.join)(projectRoot, ".gossip", "forced-skill-develops.jsonl");
+    if (!(0, import_fs46.existsSync)(path6)) return [];
+    const raw = (0, import_fs46.readFileSync)(path6, "utf-8");
     const target = normalizeCategory(category);
     const out = [];
     for (const line of raw.split("\n")) {
@@ -26901,17 +27170,18 @@ function readForcedDevelops(projectRoot, agentId, category) {
   }
 }
 function readTaskGraphByAgent(projectRoot) {
-  const taskGraphPath = (0, import_path48.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  const taskGraphPath = (0, import_path49.join)(projectRoot, ".gossip", "task-graph.jsonl");
   const result = /* @__PURE__ */ new Map();
-  if (!(0, import_fs45.existsSync)(taskGraphPath)) return result;
+  if (!(0, import_fs46.existsSync)(taskGraphPath)) return result;
   let lines;
   try {
-    lines = (0, import_fs45.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    lines = (0, import_fs46.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
   } catch {
     return result;
   }
   const created = /* @__PURE__ */ new Map();
   const completed = /* @__PURE__ */ new Map();
+  const failed = /* @__PURE__ */ new Set();
   for (const line of lines) {
     let entry;
     try {
@@ -26927,18 +27197,23 @@ function readTaskGraphByAgent(projectRoot) {
         outputTokens: entry.outputTokens ?? 0,
         timestamp: entry.timestamp ?? ""
       });
+    } else if (entry.type === "task.failed" && entry.taskId) {
+      failed.add(entry.taskId);
     }
   }
   for (const [taskId, createdData] of created) {
     const { agentId, task, timestamp } = createdData;
     if (isUtilityAgent(agentId)) continue;
     if (!result.has(agentId)) {
-      result.set(agentId, { totalTokens: 0, lastTask: null });
+      result.set(agentId, { totalTokens: 0, lastTask: null, tasksCompleted: 0, tasksFailed: 0 });
     }
     const agentData = result.get(agentId);
     const comp = completed.get(taskId);
     if (comp) {
       agentData.totalTokens += comp.inputTokens + comp.outputTokens;
+      agentData.tasksCompleted++;
+    } else if (failed.has(taskId)) {
+      agentData.tasksFailed++;
     }
     if (!agentData.lastTask || timestamp > agentData.lastTask.timestamp) {
       agentData.lastTask = { task, timestamp };
@@ -26963,7 +27238,7 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
   const allIds = configs.map((c) => c.id);
   return configs.map((config2) => {
     const score = scores.get(config2.id) ?? { ...DEFAULT_SCORE, agentId: config2.id };
-    const agentTask = taskDataByAgent.get(config2.id) ?? { totalTokens: 0, lastTask: null };
+    const agentTask = taskDataByAgent.get(config2.id) ?? { totalTokens: 0, lastTask: null, tasksCompleted: 0, tasksFailed: 0 };
     const categories = Object.keys({ ...score.categoryCorrect, ...score.categoryHallucinated });
     const benchResult = reader.isBenched(config2.id, categories, allIds);
     const benchState = benchResult.benched ? "benched" : benchResult.safeguardBlocked ? "kept-for-coverage" : "none";
@@ -26996,6 +27271,9 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
       }
     } catch {
     }
+    const { tasksCompleted, tasksFailed } = agentTask;
+    const completionDenominator = tasksCompleted + tasksFailed;
+    const taskCompletionRate = completionDenominator > 0 ? tasksCompleted / completionDenominator : null;
     return {
       id: config2.id,
       provider: config2.provider,
@@ -27011,6 +27289,7 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
         accuracy: score.accuracy,
         uniqueness: score.uniqueness,
         reliability: score.reliability,
+        taskCompletionRate,
         impactScore: score.impactScore ?? 0.5,
         dispatchWeight: reader.getDispatchWeight(config2.id),
         signals: score.totalSignals,
@@ -27020,6 +27299,7 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
         uniqueFindings: score.uniqueFindings ?? 0,
         unverifiedsEmitted: score.unverifiedsEmitted ?? 0,
         unverifiedsReceived: score.unverifiedsReceived ?? 0,
+        transportFailureCount: score.transport_failure_count ?? 0,
         consecutiveFailures: score.consecutiveFailures ?? 0,
         circuitOpen: score.circuitOpen ?? false,
         bench,
@@ -27041,14 +27321,14 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
     };
   });
 }
-var import_fs45, import_path48, DEFAULT_SCORE;
+var import_fs46, import_path49, DEFAULT_SCORE;
 var init_api_agents = __esm({
   "packages/relay/src/dashboard/api-agents.ts"() {
     "use strict";
     init_performance_reader();
     init_skill_index();
-    import_fs45 = require("fs");
-    import_path48 = require("path");
+    import_fs46 = require("fs");
+    import_path49 = require("path");
     init_utility_agents();
     DEFAULT_SCORE = {
       agentId: "",
@@ -27057,6 +27337,7 @@ var init_api_agents = __esm({
       reliability: 0.5,
       impactScore: 0.5,
       totalSignals: 0,
+      scoringSignals: 0,
       agreements: 0,
       disagreements: 0,
       uniqueFindings: 0,
@@ -27069,14 +27350,15 @@ var init_api_agents = __esm({
       categoryStrengths: {},
       categoryCorrect: {},
       categoryHallucinated: {},
-      categoryAccuracy: {}
+      categoryAccuracy: {},
+      transport_failure_count: 0
     };
   }
 });
 
 // packages/relay/src/dashboard/api-skills.ts
 function isCorrupt(projectRoot, index) {
-  return (0, import_fs46.existsSync)((0, import_path49.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
+  return (0, import_fs47.existsSync)((0, import_path50.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
 }
 async function skillsGetHandler(projectRoot) {
   try {
@@ -27105,13 +27387,13 @@ async function skillsBindHandler(projectRoot, body) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
   }
 }
-var import_fs46, import_path49, AGENT_ID_RE2;
+var import_fs47, import_path50, AGENT_ID_RE2;
 var init_api_skills = __esm({
   "packages/relay/src/dashboard/api-skills.ts"() {
     "use strict";
     init_skill_index();
-    import_fs46 = require("fs");
-    import_path49 = require("path");
+    import_fs47 = require("fs");
+    import_path50 = require("path");
     AGENT_ID_RE2 = /^[a-zA-Z0-9_-]{1,64}$/;
   }
 });
@@ -27119,25 +27401,25 @@ var init_api_skills = __esm({
 // packages/relay/src/dashboard/api-memory.ts
 async function memoryHandler(projectRoot, agentId) {
   if (!agentId || !AGENT_ID_RE3.test(agentId) || DANGEROUS_IDS.has(agentId)) throw new Error("Invalid agent ID");
-  const memDir = (0, import_path50.join)(projectRoot, ".gossip", "agents", agentId, "memory");
+  const memDir = (0, import_path51.join)(projectRoot, ".gossip", "agents", agentId, "memory");
   let index = "";
-  const indexPath = (0, import_path50.join)(memDir, "MEMORY.md");
-  if ((0, import_fs47.existsSync)(indexPath)) {
+  const indexPath = (0, import_path51.join)(memDir, "MEMORY.md");
+  if ((0, import_fs48.existsSync)(indexPath)) {
     try {
-      index = (0, import_fs47.readFileSync)(indexPath, "utf-8");
+      index = (0, import_fs48.readFileSync)(indexPath, "utf-8");
     } catch {
     }
   }
   const knowledge = [];
-  const knowledgeDir = (0, import_path50.join)(memDir, "knowledge");
+  const knowledgeDir = (0, import_path51.join)(memDir, "knowledge");
   const knowledgeDirs = [knowledgeDir, memDir];
   for (const dir of knowledgeDirs) {
-    if (!(0, import_fs47.existsSync)(dir)) continue;
+    if (!(0, import_fs48.existsSync)(dir)) continue;
     try {
-      const files = (0, import_fs47.readdirSync)(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+      const files = (0, import_fs48.readdirSync)(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
       for (const filename of files) {
         try {
-          const raw = (0, import_fs47.readFileSync)((0, import_path50.join)(dir, filename), "utf-8");
+          const raw = (0, import_fs48.readFileSync)((0, import_path51.join)(dir, filename), "utf-8");
           const { frontmatter, content } = parseFrontmatter(raw);
           knowledge.push({ filename, frontmatter, content });
         } catch {
@@ -27147,10 +27429,10 @@ async function memoryHandler(projectRoot, agentId) {
     }
   }
   const tasks = [];
-  const tasksPath = (0, import_path50.join)(memDir, "tasks.jsonl");
-  if ((0, import_fs47.existsSync)(tasksPath)) {
+  const tasksPath = (0, import_path51.join)(memDir, "tasks.jsonl");
+  if ((0, import_fs48.existsSync)(tasksPath)) {
     try {
-      const lines = (0, import_fs47.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
+      const lines = (0, import_fs48.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
       for (const line of lines) {
         try {
           tasks.push(JSON.parse(line));
@@ -27178,12 +27460,12 @@ function parseFrontmatter(raw) {
   }
   return { frontmatter: fm, content: raw.slice(end + 3).trim() };
 }
-var import_fs47, import_path50, AGENT_ID_RE3, DANGEROUS_IDS;
+var import_fs48, import_path51, AGENT_ID_RE3, DANGEROUS_IDS;
 var init_api_memory = __esm({
   "packages/relay/src/dashboard/api-memory.ts"() {
     "use strict";
-    import_fs47 = require("fs");
-    import_path50 = require("path");
+    import_fs48 = require("fs");
+    import_path51 = require("path");
     AGENT_ID_RE3 = /^[a-zA-Z0-9_-]{1,64}$/;
     DANGEROUS_IDS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   }
@@ -27192,25 +27474,25 @@ var init_api_memory = __esm({
 // packages/relay/src/dashboard/api-native-memory.ts
 function autoMemoryDir(projectRoot, home) {
   const h = home ?? (0, import_os2.homedir)();
-  return (0, import_path51.join)(h, ".claude", "projects", projectRoot.replaceAll("/", "-"), "memory");
+  return (0, import_path52.join)(h, ".claude", "projects", projectRoot.replaceAll("/", "-"), "memory");
 }
 async function autoMemoryHandler(projectRoot, home) {
   const dir = autoMemoryDir(projectRoot, home);
-  if (!(0, import_fs48.existsSync)(dir)) return { knowledge: [] };
+  if (!(0, import_fs49.existsSync)(dir)) return { knowledge: [] };
   let entries;
   try {
-    entries = (0, import_fs48.readdirSync)(dir);
+    entries = (0, import_fs49.readdirSync)(dir);
   } catch {
     return { knowledge: [] };
   }
   const knowledge = [];
   for (const filename of entries) {
     if (!FILENAME_RE.test(filename)) continue;
-    const full = (0, import_path51.join)(dir, filename);
+    const full = (0, import_path52.join)(dir, filename);
     try {
-      const st = (0, import_fs48.statSync)(full);
+      const st = (0, import_fs49.statSync)(full);
       if (!st.isFile()) continue;
-      const raw = (0, import_fs48.readFileSync)(full, "utf-8");
+      const raw = (0, import_fs49.readFileSync)(full, "utf-8");
       const { frontmatter, content } = parseFrontmatter2(raw);
       knowledge.push({ filename, frontmatter, content, agentId: "_auto" });
     } catch {
@@ -27232,12 +27514,12 @@ function parseFrontmatter2(raw) {
   if (rest.startsWith("\n")) rest = rest.slice(1);
   return { frontmatter: fm, content: rest.trim() };
 }
-var import_fs48, import_path51, import_os2, FILENAME_RE;
+var import_fs49, import_path52, import_os2, FILENAME_RE;
 var init_api_native_memory = __esm({
   "packages/relay/src/dashboard/api-native-memory.ts"() {
     "use strict";
-    import_fs48 = require("fs");
-    import_path51 = require("path");
+    import_fs49 = require("fs");
+    import_path52 = require("path");
     import_os2 = require("os");
     FILENAME_RE = /^[A-Za-z0-9_.-]+\.md$/;
   }
@@ -27245,25 +27527,25 @@ var init_api_native_memory = __esm({
 
 // packages/relay/src/dashboard/api-gossip-memory.ts
 function gossipMemoryDir(projectRoot) {
-  return (0, import_path52.join)(projectRoot, ".gossip", "memory");
+  return (0, import_path53.join)(projectRoot, ".gossip", "memory");
 }
 async function gossipMemoryHandler(projectRoot) {
   const dir = gossipMemoryDir(projectRoot);
-  if (!(0, import_fs49.existsSync)(dir)) return { knowledge: [] };
+  if (!(0, import_fs50.existsSync)(dir)) return { knowledge: [] };
   let entries;
   try {
-    entries = (0, import_fs49.readdirSync)(dir);
+    entries = (0, import_fs50.readdirSync)(dir);
   } catch {
     return { knowledge: [] };
   }
   const knowledge = [];
   for (const filename of entries) {
     if (!FILENAME_RE2.test(filename)) continue;
-    const full = (0, import_path52.join)(dir, filename);
+    const full = (0, import_path53.join)(dir, filename);
     try {
-      const st = (0, import_fs49.statSync)(full);
+      const st = (0, import_fs50.statSync)(full);
       if (!st.isFile()) continue;
-      const raw = (0, import_fs49.readFileSync)(full, "utf-8");
+      const raw = (0, import_fs50.readFileSync)(full, "utf-8");
       const { frontmatter, content } = parseFrontmatter2(raw);
       knowledge.push({ filename, frontmatter, content, agentId: "_gossip" });
     } catch {
@@ -27271,12 +27553,12 @@ async function gossipMemoryHandler(projectRoot) {
   }
   return { knowledge };
 }
-var import_fs49, import_path52, FILENAME_RE2;
+var import_fs50, import_path53, FILENAME_RE2;
 var init_api_gossip_memory = __esm({
   "packages/relay/src/dashboard/api-gossip-memory.ts"() {
     "use strict";
-    import_fs49 = require("fs");
-    import_path52 = require("path");
+    import_fs50 = require("fs");
+    import_path53 = require("path");
     init_api_native_memory();
     FILENAME_RE2 = /^[A-Za-z0-9_.-]+\.md$/;
   }
@@ -27288,7 +27570,7 @@ async function consensusHandler(projectRoot, query) {
   const rawPageSize = parseInt(query?.get("pageSize") ?? "", 10);
   const page = isNaN(rawPage) || rawPage < 1 ? 1 : rawPage;
   const pageSize = isNaN(rawPageSize) || rawPageSize < 1 ? DEFAULT_PAGE_SIZE : Math.min(rawPageSize, MAX_PAGE_SIZE);
-  const perfPath = (0, import_path53.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  const perfPath = (0, import_path54.join)(projectRoot, ".gossip", "agent-performance.jsonl");
   let retractedIds = /* @__PURE__ */ new Set();
   let roundRetractions = [];
   try {
@@ -27303,10 +27585,10 @@ async function consensusHandler(projectRoot, query) {
     retractionByConsensusId.set(r.consensus_id, { reason: r.reason, retracted_at: r.retracted_at });
   }
   const retractedConsensusIds = Array.from(retractedIds);
-  if (!(0, import_fs50.existsSync)(perfPath)) return { runs: [], totalRuns: 0, totalSignals: 0, page, pageSize, retractedConsensusIds, roundRetractions };
+  if (!(0, import_fs51.existsSync)(perfPath)) return { runs: [], totalRuns: 0, totalSignals: 0, page, pageSize, retractedConsensusIds, roundRetractions };
   const signals = [];
   try {
-    const lines = (0, import_fs50.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs51.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const parsed = JSON.parse(line);
@@ -27383,12 +27665,12 @@ async function consensusHandler(projectRoot, query) {
   const paginatedRuns = runs.slice(offset, offset + pageSize);
   return { runs: paginatedRuns, totalRuns, totalSignals: signals.length, page, pageSize, retractedConsensusIds, roundRetractions };
 }
-var import_fs50, import_path53, RESOLUTION_SIGNALS, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE;
+var import_fs51, import_path54, RESOLUTION_SIGNALS, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE;
 var init_api_consensus = __esm({
   "packages/relay/src/dashboard/api-consensus.ts"() {
     "use strict";
-    import_fs50 = require("fs");
-    import_path53 = require("path");
+    import_fs51 = require("fs");
+    import_path54 = require("path");
     RESOLUTION_SIGNALS = /* @__PURE__ */ new Set(["agreement", "unique_confirmed", "consensus_verified"]);
     DEFAULT_PAGE_SIZE = 10;
     MAX_PAGE_SIZE = 500;
@@ -27420,13 +27702,13 @@ 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_path54.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs51.existsSync)(perfPath)) return { items: [], total: 0, offset, limit };
+  const perfPath = (0, import_path55.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs52.existsSync)(perfPath)) return { items: [], total: 0, offset, limit };
   const all = [];
   const roundRetractions = [];
   const signalFilterSet = signalFilters.length ? new Set(signalFilters) : null;
   try {
-    const lines = (0, import_fs51.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs52.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -27481,12 +27763,12 @@ async function signalsHandler(projectRoot, query) {
   if (nextCursor) response.nextCursor = nextCursor;
   return response;
 }
-var import_fs51, import_path54, MAX_LIMIT, DEFAULT_LIMIT, META_SIGNALS;
+var import_fs52, import_path55, MAX_LIMIT, DEFAULT_LIMIT, META_SIGNALS;
 var init_api_signals = __esm({
   "packages/relay/src/dashboard/api-signals.ts"() {
     "use strict";
-    import_fs51 = require("fs");
-    import_path54 = require("path");
+    import_fs52 = require("fs");
+    import_path55 = require("path");
     MAX_LIMIT = 500;
     DEFAULT_LIMIT = 50;
     META_SIGNALS = /* @__PURE__ */ new Set(["task_completed", "tool_turns", "format_compliance"]);
@@ -27498,7 +27780,7 @@ function extractCitations(findingText, projectRoot) {
   const out = [];
   let realRoot;
   try {
-    realRoot = (0, import_fs52.realpathSync)((0, import_path55.resolve)(projectRoot));
+    realRoot = (0, import_fs53.realpathSync)((0, import_path56.resolve)(projectRoot));
   } catch {
     return out;
   }
@@ -27509,23 +27791,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_path55.resolve)(realRoot, filePath);
-    const preRel = (0, import_path55.relative)(realRoot, abs);
+    const abs = (0, import_path56.resolve)(realRoot, filePath);
+    const preRel = (0, import_path56.relative)(realRoot, abs);
     if (preRel === "" || preRel.startsWith("..")) continue;
-    if (!(0, import_fs52.existsSync)(abs)) {
+    if (!(0, import_fs53.existsSync)(abs)) {
       out.push({ file: filePath, line, snippet: "// file not found" });
       continue;
     }
     let realAbs;
     try {
-      realAbs = (0, import_fs52.realpathSync)(abs);
+      realAbs = (0, import_fs53.realpathSync)(abs);
     } catch {
       continue;
     }
-    const rel = (0, import_path55.relative)(realRoot, realAbs);
+    const rel = (0, import_path56.relative)(realRoot, realAbs);
     if (rel === "" || rel.startsWith("..")) continue;
     try {
-      const lines = (0, import_fs52.readFileSync)(realAbs, "utf-8").split("\n");
+      const lines = (0, import_fs53.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") });
@@ -27538,9 +27820,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_path55.join)(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
-  if (!(0, import_fs52.existsSync)(reportPath)) throw new Error(`consensus ${consensusId} not found`);
-  const report = JSON.parse((0, import_fs52.readFileSync)(reportPath, "utf-8"));
+  const reportPath = (0, import_path56.join)(projectRoot, ".gossip", "consensus-reports", `${consensusId}.json`);
+  if (!(0, import_fs53.existsSync)(reportPath)) throw new Error(`consensus ${consensusId} not found`);
+  const report = JSON.parse((0, import_fs53.readFileSync)(reportPath, "utf-8"));
   const buckets = [
     ["confirmed", "confirmed"],
     ["disputed", "disputed"],
@@ -27561,9 +27843,9 @@ async function findingHandler(projectRoot, consensusId, findingId) {
   }
   if (!found) throw new Error(`finding ${findingId} not found in ${consensusId}`);
   const signals = [];
-  const perfPath = (0, import_path55.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if ((0, import_fs52.existsSync)(perfPath)) {
-    const lines = (0, import_fs52.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+  const perfPath = (0, import_path56.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if ((0, import_fs53.existsSync)(perfPath)) {
+    const lines = (0, import_fs53.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -27599,12 +27881,12 @@ async function findingHandler(projectRoot, consensusId, findingId) {
     citations
   };
 }
-var import_fs52, import_path55, SAFE_ID, SNIPPET_CONTEXT, CITE_PATTERN;
+var import_fs53, import_path56, SAFE_ID, SNIPPET_CONTEXT, CITE_PATTERN;
 var init_api_finding = __esm({
   "packages/relay/src/dashboard/api-finding.ts"() {
     "use strict";
-    import_fs52 = require("fs");
-    import_path55 = require("path");
+    import_fs53 = require("fs");
+    import_path56 = require("path");
     SAFE_ID = /^[\w:.\-]+$/;
     SNIPPET_CONTEXT = 2;
     CITE_PATTERN = /<cite tag="file">([^<:]+):(\d+)<\/cite>/g;
@@ -27617,13 +27899,13 @@ async function openFindingsHandler(projectRoot) {
   let open = 0;
   let resolved = 0;
   let staleAnchor = 0;
-  const findingsPath = (0, import_path56.join)(projectRoot, ".gossip", "implementation-findings.jsonl");
-  if (!(0, import_fs53.existsSync)(findingsPath)) {
+  const findingsPath = (0, import_path57.join)(projectRoot, ".gossip", "implementation-findings.jsonl");
+  if (!(0, import_fs54.existsSync)(findingsPath)) {
     return { rows, totals: { open: 0, resolved: 0, staleAnchor: 0 } };
   }
   let raw;
   try {
-    raw = (0, import_fs53.readFileSync)(findingsPath, "utf-8");
+    raw = (0, import_fs54.readFileSync)(findingsPath, "utf-8");
   } catch {
     return { rows, totals: { open: 0, resolved: 0, staleAnchor: 0 } };
   }
@@ -27637,6 +27919,7 @@ async function openFindingsHandler(projectRoot) {
     }
     const findingId = String(entry.taskId ?? entry.findingId ?? entry.id ?? "");
     if (!findingId) continue;
+    if (entry.type === "insight") continue;
     let state;
     if (entry.status === "resolved") {
       state = entry.resolvedBy === "stale_anchor" ? "stale-anchor" : "resolved";
@@ -27660,40 +27943,40 @@ async function openFindingsHandler(projectRoot) {
   }
   return { rows, totals: { open, resolved, staleAnchor } };
 }
-var import_fs53, import_path56;
+var import_fs54, import_path57;
 var init_api_open_findings = __esm({
   "packages/relay/src/dashboard/api-open-findings.ts"() {
     "use strict";
-    import_fs53 = require("fs");
-    import_path56 = require("path");
+    import_fs54 = require("fs");
+    import_path57 = require("path");
   }
 });
 
 // packages/relay/src/dashboard/api-learnings.ts
 async function learningsHandler(projectRoot) {
-  const agentsDir = (0, import_path57.join)(projectRoot, ".gossip", "agents");
-  if (!(0, import_fs54.existsSync)(agentsDir)) return { learnings: [] };
+  const agentsDir = (0, import_path58.join)(projectRoot, ".gossip", "agents");
+  if (!(0, import_fs55.existsSync)(agentsDir)) return { learnings: [] };
   const all = [];
   let agentIds;
   try {
-    agentIds = (0, import_fs54.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
+    agentIds = (0, import_fs55.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
   } catch {
     return { learnings: [] };
   }
   for (const agentId of agentIds) {
-    const knowledgeDir = (0, import_path57.join)(agentsDir, agentId, "memory", "knowledge");
-    if (!(0, import_fs54.existsSync)(knowledgeDir)) continue;
+    const knowledgeDir = (0, import_path58.join)(agentsDir, agentId, "memory", "knowledge");
+    if (!(0, import_fs55.existsSync)(knowledgeDir)) continue;
     let files;
     try {
-      files = (0, import_fs54.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+      files = (0, import_fs55.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
     } catch {
       continue;
     }
     for (const filename of files) {
-      const filepath = (0, import_path57.join)(knowledgeDir, filename);
+      const filepath = (0, import_path58.join)(knowledgeDir, filename);
       try {
-        const stat4 = (0, import_fs54.statSync)(filepath);
-        const raw = (0, import_fs54.readFileSync)(filepath, "utf-8");
+        const stat4 = (0, import_fs55.statSync)(filepath);
+        const raw = (0, import_fs55.readFileSync)(filepath, "utf-8");
         const fm = parseFrontmatter3(raw);
         all.push({
           agentId,
@@ -27720,12 +28003,12 @@ function parseFrontmatter3(raw) {
   }
   return fm;
 }
-var import_fs54, import_path57, MAX_LEARNINGS;
+var import_fs55, import_path58, MAX_LEARNINGS;
 var init_api_learnings = __esm({
   "packages/relay/src/dashboard/api-learnings.ts"() {
     "use strict";
-    import_fs54 = require("fs");
-    import_path57 = require("path");
+    import_fs55 = require("fs");
+    import_path58 = require("path");
     MAX_LEARNINGS = 10;
   }
 });
@@ -27736,12 +28019,12 @@ async function tasksHandler(projectRoot, query) {
   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_path58.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs55.existsSync)(graphPath)) return { items: [], total: 0, offset, limit };
+  const graphPath = (0, import_path59.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs56.existsSync)(graphPath)) return { items: [], total: 0, offset, limit };
   const created = /* @__PURE__ */ new Map();
   const completed = /* @__PURE__ */ new Map();
   try {
-    const lines = (0, import_fs55.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs56.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -27797,24 +28080,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_fs55, import_path58;
+var import_fs56, import_path59;
 var init_api_tasks = __esm({
   "packages/relay/src/dashboard/api-tasks.ts"() {
     "use strict";
-    import_fs55 = require("fs");
-    import_path58 = require("path");
+    import_fs56 = require("fs");
+    import_path59 = require("path");
     init_utility_agents();
   }
 });
 
 // packages/relay/src/dashboard/api-active-tasks.ts
 async function activeTasksHandler(projectRoot) {
-  const taskGraphPath = (0, import_path59.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs56.existsSync)(taskGraphPath)) return { tasks: [] };
+  const taskGraphPath = (0, import_path60.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs57.existsSync)(taskGraphPath)) return { tasks: [] };
   const created = /* @__PURE__ */ new Map();
   const finished = /* @__PURE__ */ new Set();
   try {
-    const lines = (0, import_fs56.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs57.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const ev = JSON.parse(line);
@@ -27842,12 +28125,12 @@ async function activeTasksHandler(projectRoot) {
   active.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
   return { tasks: active.slice(0, 10) };
 }
-var import_fs56, import_path59;
+var import_fs57, import_path60;
 var init_api_active_tasks = __esm({
   "packages/relay/src/dashboard/api-active-tasks.ts"() {
     "use strict";
-    import_fs56 = require("fs");
-    import_path59 = require("path");
+    import_fs57 = require("fs");
+    import_path60 = require("path");
     init_utility_agents();
   }
 });
@@ -27861,25 +28144,25 @@ function categorize(text) {
   return "other";
 }
 function logsHandler(projectRoot, query) {
-  const logPath = (0, import_path60.join)(projectRoot, ".gossip", "mcp.log");
-  if (!(0, import_fs57.existsSync)(logPath)) {
+  const logPath = (0, import_path61.join)(projectRoot, ".gossip", "mcp.log");
+  if (!(0, import_fs58.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_fs57.statSync)(logPath).size;
+  const fileSize = (0, import_fs58.statSync)(logPath).size;
   const MAX_READ = 512 * 1024;
   const readFrom = Math.max(0, fileSize - MAX_READ);
   const readLen = fileSize - readFrom;
-  const fd = (0, import_fs57.openSync)(logPath, "r");
+  const fd = (0, import_fs58.openSync)(logPath, "r");
   let buf = Buffer.alloc(0);
   try {
     buf = Buffer.allocUnsafe(readLen);
-    const bytesRead = (0, import_fs57.readSync)(fd, buf, 0, readLen, readFrom);
+    const bytesRead = (0, import_fs58.readSync)(fd, buf, 0, readLen, readFrom);
     buf = buf.subarray(0, bytesRead);
   } finally {
-    (0, import_fs57.closeSync)(fd);
+    (0, import_fs58.closeSync)(fd);
   }
   let raw = buf.toString("utf-8");
   let lineOffset = 0;
@@ -27887,13 +28170,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_fs57.openSync)(logPath, "r");
+    const scanFd = (0, import_fs58.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_fs57.readSync)(scanFd, chunk, 0, len, pos);
+        const n = (0, import_fs58.readSync)(scanFd, chunk, 0, len, pos);
         if (n === 0) break;
         for (let j = 0; j < n; j++) {
           if (chunk[j] === 10) lineOffset++;
@@ -27901,7 +28184,7 @@ function logsHandler(projectRoot, query) {
         pos += n;
       }
     } finally {
-      (0, import_fs57.closeSync)(scanFd);
+      (0, import_fs58.closeSync)(scanFd);
     }
   }
   const allLines = raw.split("\n").filter(Boolean);
@@ -27919,12 +28202,12 @@ function logsHandler(projectRoot, query) {
   entries = entries.slice(-clampedTail);
   return { entries, totalLines, fileSize, filter };
 }
-var import_fs57, import_path60, CATEGORY_PATTERNS2;
+var import_fs58, import_path61, CATEGORY_PATTERNS2;
 var init_api_logs = __esm({
   "packages/relay/src/dashboard/api-logs.ts"() {
     "use strict";
-    import_fs57 = require("fs");
-    import_path60 = require("path");
+    import_fs58 = require("fs");
+    import_path61 = require("path");
     CATEGORY_PATTERNS2 = [
       [/^\[worker:/, "worker"],
       [/^\[Gemini\]/, "gemini"],
@@ -27951,18 +28234,57 @@ var init_api_logs = __esm({
   }
 });
 
+// packages/relay/src/dashboard/api-violations.ts
+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_path62.join)(projectRoot, FILE);
+  if (!(0, import_fs59.existsSync)(filePath)) {
+    return { items: [], total: 0, page, pageSize };
+  }
+  const raw = (0, import_fs59.readFileSync)(filePath, "utf-8");
+  const lines = raw.trim().split("\n").filter(Boolean);
+  const entries = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (!agentFilter || entry.agentId === agentFilter) {
+        entries.push(entry);
+      }
+    } catch {
+      continue;
+    }
+  }
+  entries.sort(
+    (a, b) => new Date(b.detectedAt).getTime() - new Date(a.detectedAt).getTime()
+  );
+  const total = entries.length;
+  const start = (page - 1) * pageSize;
+  return { items: entries.slice(start, start + pageSize), total, page, pageSize };
+}
+var import_fs59, import_path62, FILE;
+var init_api_violations = __esm({
+  "packages/relay/src/dashboard/api-violations.ts"() {
+    "use strict";
+    import_fs59 = require("fs");
+    import_path62 = require("path");
+    FILE = ".gossip/process-violations.jsonl";
+  }
+});
+
 // packages/relay/src/dashboard/routes.ts
 function resolveDashboardRoot(projectRoot) {
   const candidates = [
-    (0, import_path61.resolve)(__dirname, "..", "dist-dashboard"),
+    (0, import_path63.resolve)(__dirname, "..", "dist-dashboard"),
     // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
-    (0, import_path61.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    (0, import_path63.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
     // tsc dev: packages/relay/dist/dashboard → repo-root
-    (0, import_path61.join)(projectRoot, "dist-dashboard")
+    (0, import_path63.join)(projectRoot, "dist-dashboard")
     // legacy dev fallback (git-clone running from repo root)
   ];
   for (const p of candidates) {
-    if ((0, import_fs58.existsSync)(p)) return p;
+    if ((0, import_fs60.existsSync)(p)) return p;
   }
   return null;
 }
@@ -27989,7 +28311,7 @@ function readBody(req) {
     });
   });
 }
-var import_fs58, import_path61, import_crypto21, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
+var import_fs60, import_path63, import_crypto21, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
 var init_routes = __esm({
   "packages/relay/src/dashboard/routes.ts"() {
     "use strict";
@@ -28008,8 +28330,9 @@ var init_routes = __esm({
     init_api_tasks();
     init_api_active_tasks();
     init_api_logs();
-    import_fs58 = require("fs");
-    import_path61 = require("path");
+    init_api_violations();
+    import_fs60 = require("fs");
+    import_path63 = require("path");
     import_crypto21 = require("crypto");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
@@ -28249,6 +28572,11 @@ var init_routes = __esm({
             this.json(res, 200, data);
             return true;
           }
+          if (url2 === "/dashboard/api/violations" && req.method === "GET") {
+            const data = violationsHandler(this.projectRoot, query ?? void 0);
+            this.json(res, 200, data);
+            return true;
+          }
           if ((url2 === "/dashboard/api/native-memory" || url2 === "/dashboard/api/auto-memory") && req.method === "GET") {
             const data = await autoMemoryHandler(this.projectRoot);
             this.json(res, 200, data);
@@ -28281,13 +28609,13 @@ var init_routes = __esm({
           res.end("Dashboard assets not found. Reinstall gossipcat or rebuild from source.");
           return true;
         }
-        const htmlPath = (0, import_path61.join)(this.dashboardRoot, "index.html");
-        if (!(0, import_fs58.existsSync)(htmlPath)) {
+        const htmlPath = (0, import_path63.join)(this.dashboardRoot, "index.html");
+        if (!(0, import_fs60.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_fs58.readFileSync)(htmlPath, "utf-8");
+        const html = (0, import_fs60.readFileSync)(htmlPath, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return true;
@@ -28313,16 +28641,16 @@ var init_routes = __esm({
         const ext = "." + (relativePath.split(".").pop() || "");
         const mime = MIME[ext];
         if (!mime) return false;
-        const filePath = (0, import_path61.join)(this.dashboardRoot, relativePath);
+        const filePath = (0, import_path63.join)(this.dashboardRoot, relativePath);
         try {
-          const realFile = (0, import_fs58.realpathSync)(filePath);
-          const realBase = (0, import_fs58.realpathSync)(this.dashboardRoot);
+          const realFile = (0, import_fs60.realpathSync)(filePath);
+          const realBase = (0, import_fs60.realpathSync)(this.dashboardRoot);
           if (!realFile.startsWith(realBase + "/")) {
             res.writeHead(404);
             res.end();
             return true;
           }
-          const data = (0, import_fs58.readFileSync)(realFile);
+          const data = (0, import_fs60.readFileSync)(realFile);
           res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=86400" });
           res.end(data);
           return true;
@@ -28337,8 +28665,8 @@ var init_routes = __esm({
         return match ? match[1] : null;
       }
       getConsensusReports(page = 1, pageSize = 5) {
-        const { readdirSync: readdirSync18, readFileSync: readFileSync59, existsSync: existsSync61 } = require("fs");
-        const reportsDir = (0, import_path61.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const { readdirSync: readdirSync18, readFileSync: readFileSync61, existsSync: existsSync64 } = require("fs");
+        const reportsDir = (0, import_path63.join)(this.projectRoot, ".gossip", "consensus-reports");
         let retractedConsensusIds = [];
         let roundRetractions = [];
         try {
@@ -28348,13 +28676,13 @@ var init_routes = __esm({
           roundRetractions = reader.getRoundRetractions();
         } catch {
         }
-        if (!existsSync61(reportsDir)) return { reports: [], totalReports: 0, page, pageSize, retractedConsensusIds, roundRetractions };
+        if (!existsSync64(reportsDir)) return { reports: [], totalReports: 0, page, pageSize, retractedConsensusIds, roundRetractions };
         try {
-          const { statSync: statSync23 } = require("fs");
+          const { statSync: statSync24 } = require("fs");
           const allFiles = readdirSync18(reportsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
             try {
-              const aTime = statSync23((0, import_path61.join)(reportsDir, a)).mtimeMs;
-              const bTime = statSync23((0, import_path61.join)(reportsDir, b)).mtimeMs;
+              const aTime = statSync24((0, import_path63.join)(reportsDir, a)).mtimeMs;
+              const bTime = statSync24((0, import_path63.join)(reportsDir, b)).mtimeMs;
               return bTime - aTime;
             } catch {
               return 0;
@@ -28365,13 +28693,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_fs58.realpathSync)(reportsDir);
+          const realReportsDir = (0, import_fs60.realpathSync)(reportsDir);
           const reports = files.map((f) => {
             try {
-              const filePath = (0, import_path61.join)(reportsDir, f);
-              const realFile = (0, import_fs58.realpathSync)(filePath);
+              const filePath = (0, import_path63.join)(reportsDir, f);
+              const realFile = (0, import_fs60.realpathSync)(filePath);
               if (!realFile.startsWith(realReportsDir + "/")) return null;
-              return JSON.parse(readFileSync59(realFile, "utf-8"));
+              return JSON.parse(readFileSync61(realFile, "utf-8"));
             } catch {
               return null;
             }
@@ -28382,29 +28710,29 @@ var init_routes = __esm({
         }
       }
       archiveFindings() {
-        const { readdirSync: readdirSync18, readFileSync: readFileSync59, renameSync: renameSync8, writeFileSync: writeFileSync25, mkdirSync: mkdirSync30, existsSync: existsSync61 } = require("fs");
-        const reportsDir = (0, import_path61.join)(this.projectRoot, ".gossip", "consensus-reports");
-        const archiveDir = (0, import_path61.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
+        const { readdirSync: readdirSync18, readFileSync: readFileSync61, renameSync: renameSync9, writeFileSync: writeFileSync26, mkdirSync: mkdirSync33, existsSync: existsSync64 } = require("fs");
+        const reportsDir = (0, import_path63.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const archiveDir = (0, import_path63.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
         let archived = 0;
-        if (existsSync61(reportsDir)) {
+        if (existsSync64(reportsDir)) {
           const files = readdirSync18(reportsDir).filter((f) => f.endsWith(".json")).sort().reverse();
           if (files.length > 5) {
-            mkdirSync30(archiveDir, { recursive: true });
+            mkdirSync33(archiveDir, { recursive: true });
             const toArchive = files.slice(5);
             for (const f of toArchive) {
               try {
-                renameSync8((0, import_path61.join)(reportsDir, f), (0, import_path61.join)(archiveDir, f));
+                renameSync9((0, import_path63.join)(reportsDir, f), (0, import_path63.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path61.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path63.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
-        if (existsSync61(findingsPath)) {
+        if (existsSync64(findingsPath)) {
           try {
-            const lines = readFileSync59(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
+            const lines = readFileSync61(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
             const kept = lines.filter((line) => {
               try {
                 const entry = JSON.parse(line);
@@ -28417,11 +28745,11 @@ var init_routes = __esm({
                 return true;
               }
             });
-            writeFileSync25(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
+            writeFileSync26(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
           } catch {
           }
         }
-        const remaining = existsSync61(reportsDir) ? readdirSync18(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
+        const remaining = existsSync64(reportsDir) ? readdirSync18(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
         return { archived, remaining, findingsCleared };
       }
       json(res, status, data) {
@@ -28434,14 +28762,14 @@ var init_routes = __esm({
 });
 
 // packages/relay/src/dashboard/ws.ts
-var import_ws3, import_fs59, import_fs60, import_path62, DashboardWs;
+var import_ws3, import_fs61, import_fs62, import_path64, DashboardWs;
 var init_ws = __esm({
   "packages/relay/src/dashboard/ws.ts"() {
     "use strict";
     import_ws3 = require("ws");
-    import_fs59 = require("fs");
-    import_fs60 = require("fs");
-    import_path62 = require("path");
+    import_fs61 = require("fs");
+    import_fs62 = require("fs");
+    import_path64 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -28466,15 +28794,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_path62.join)(projectRoot, ".gossip", "mcp.log");
-        if (!(0, import_fs59.existsSync)(this.logPath)) return;
+        this.logPath = (0, import_path64.join)(projectRoot, ".gossip", "mcp.log");
+        if (!(0, import_fs61.existsSync)(this.logPath)) return;
         try {
-          this.logOffset = (0, import_fs59.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs61.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs60.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs62.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -28491,7 +28819,7 @@ var init_ws = __esm({
         if (this.logReading) return;
         this.logReading = true;
         try {
-          const currentSize = (0, import_fs59.statSync)(this.logPath).size;
+          const currentSize = (0, import_fs61.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -28504,7 +28832,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_fs59.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
+            stream = (0, import_fs61.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
           } catch {
             this.logReading = false;
             return;
@@ -29013,14 +29341,14 @@ __export(sandbox_exports, {
 });
 function rotateIfNeeded2(filePath, maxBytes) {
   try {
-    const st = (0, import_fs61.statSync)(filePath);
+    const st = (0, import_fs63.statSync)(filePath);
     if (st.size < maxBytes) return;
     const rotated = filePath + ".1";
     try {
-      if ((0, import_fs61.existsSync)(rotated)) (0, import_fs61.unlinkSync)(rotated);
+      if ((0, import_fs63.existsSync)(rotated)) (0, import_fs63.unlinkSync)(rotated);
     } catch {
     }
-    (0, import_fs61.renameSync)(filePath, rotated);
+    (0, import_fs63.renameSync)(filePath, rotated);
   } catch {
   }
 }
@@ -29093,9 +29421,9 @@ Tests passing is NOT sufficient verification \u2014 the 2026-04-22 incident had
 }
 function readSandboxMode(projectRoot) {
   try {
-    const p = (0, import_path63.join)(projectRoot, ".gossip", "config.json");
-    if (!(0, import_fs61.existsSync)(p)) return "warn";
-    const raw = JSON.parse((0, import_fs61.readFileSync)(p, "utf-8"));
+    const p = (0, import_path65.join)(projectRoot, ".gossip", "config.json");
+    if (!(0, import_fs63.existsSync)(p)) return "warn";
+    const raw = JSON.parse((0, import_fs63.readFileSync)(p, "utf-8"));
     const mode = raw?.sandboxEnforcement;
     if (mode === "off" || mode === "warn" || mode === "block") return mode;
     return "warn";
@@ -29105,8 +29433,8 @@ function readSandboxMode(projectRoot) {
 }
 function recordDispatchMetadata(projectRoot, meta3) {
   try {
-    const dir = (0, import_path63.join)(projectRoot, ".gossip");
-    (0, import_fs61.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path65.join)(projectRoot, ".gossip");
+    (0, import_fs63.mkdirSync)(dir, { recursive: true });
     const snapshotted = { ...meta3 };
     if (meta3.writeMode === "scoped" || meta3.writeMode === "worktree") {
       try {
@@ -29124,15 +29452,15 @@ function recordDispatchMetadata(projectRoot, meta3) {
       } catch {
       }
     }
-    (0, import_fs61.appendFileSync)((0, import_path63.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
+    (0, import_fs63.appendFileSync)((0, import_path65.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
   } catch {
   }
 }
 function updateDispatchMetadata(projectRoot, taskId, patch) {
   try {
-    const p = (0, import_path63.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs61.existsSync)(p)) return false;
-    const raw = (0, import_fs61.readFileSync)(p, "utf-8");
+    const p = (0, import_path65.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs63.existsSync)(p)) return false;
+    const raw = (0, import_fs63.readFileSync)(p, "utf-8");
     const lines = raw.split("\n");
     let patched = false;
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -29150,7 +29478,7 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
       }
     }
     if (!patched) return false;
-    (0, import_fs61.writeFileSync)(p, lines.join("\n"));
+    (0, import_fs63.writeFileSync)(p, lines.join("\n"));
     return true;
   } catch {
     return false;
@@ -29159,14 +29487,14 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
 function stampTaskSentinel(projectRoot, taskId) {
   if (!taskId) return null;
   try {
-    const dir = (0, import_path63.join)(projectRoot, ".gossip", SENTINEL_DIR);
-    (0, import_fs61.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path65.join)(projectRoot, ".gossip", SENTINEL_DIR);
+    (0, import_fs63.mkdirSync)(dir, { recursive: true });
     const slug = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const path6 = (0, import_path63.join)(dir, `${slug}.sentinel`);
-    const fd = (0, import_fs61.openSync)(path6, "w");
-    (0, import_fs61.closeSync)(fd);
+    const path6 = (0, import_path65.join)(dir, `${slug}.sentinel`);
+    const fd = (0, import_fs63.openSync)(path6, "w");
+    (0, import_fs63.closeSync)(fd);
     const stampTime = new Date(Date.now() - 2e3);
-    (0, import_fs61.utimesSync)(path6, stampTime, stampTime);
+    (0, import_fs63.utimesSync)(path6, stampTime, stampTime);
     return path6;
   } catch {
     return null;
@@ -29175,15 +29503,15 @@ function stampTaskSentinel(projectRoot, taskId) {
 function cleanupTaskSentinel(sentinelPath) {
   if (!sentinelPath) return;
   try {
-    (0, import_fs61.unlinkSync)(sentinelPath);
+    (0, import_fs63.unlinkSync)(sentinelPath);
   } catch {
   }
 }
 function lookupDispatchMetadata(projectRoot, taskId) {
   try {
-    const p = (0, import_path63.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs61.existsSync)(p)) return null;
-    const raw = (0, import_fs61.readFileSync)(p, "utf-8");
+    const p = (0, import_path65.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs63.existsSync)(p)) return null;
+    const raw = (0, import_fs63.readFileSync)(p, "utf-8");
     const lines = raw.split("\n").filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
@@ -29215,21 +29543,21 @@ function parseGitStatus(porcelain) {
 function normalizeScope(scope, projectRoot) {
   let s = scope.trim();
   if (!s) return "";
-  if ((0, import_path63.isAbsolute)(s)) {
-    s = (0, import_path63.relative)(projectRoot, s);
+  if ((0, import_path65.isAbsolute)(s)) {
+    s = (0, import_path65.relative)(projectRoot, s);
   } else if (s.startsWith("./")) {
     s = s.slice(2);
   }
-  s = (0, import_path63.normalize)(s).replace(/\/+$/, "");
+  s = (0, import_path65.normalize)(s).replace(/\/+$/, "");
   if (s === "." || s === "") return "";
   return s;
 }
 function isInsideScope(filePath, scope) {
   if (!scope) return true;
-  const f = (0, import_path63.normalize)(filePath).replace(/^\.\//, "");
+  const f = (0, import_path65.normalize)(filePath).replace(/^\.\//, "");
   const s = scope.replace(/^\.\//, "").replace(/\/+$/, "");
   if (f === s) return true;
-  return f.startsWith(s + "/") || f.startsWith(s + import_path63.sep);
+  return f.startsWith(s + "/") || f.startsWith(s + import_path65.sep);
 }
 function detectBoundaryEscapes(meta3, modifiedFiles, projectRoot) {
   const mode = meta3.writeMode;
@@ -29290,8 +29618,8 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
   } catch {
   }
   try {
-    const dir = (0, import_path63.join)(projectRoot, ".gossip");
-    (0, import_fs61.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path65.join)(projectRoot, ".gossip");
+    (0, import_fs63.mkdirSync)(dir, { recursive: true });
     const line = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       taskId: meta3.taskId,
@@ -29302,15 +29630,15 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
       action: mode
       // "warn" or "block"
     };
-    const escapeFile = (0, import_path63.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path65.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs61.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
+    (0, import_fs63.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
   } catch {
   }
 }
 function canonicalize(p) {
   try {
-    return (0, import_path63.resolve)(p).replace(/\/+$/, "") || "/";
+    return (0, import_path65.resolve)(p).replace(/\/+$/, "") || "/";
   } catch {
     return p.replace(/\/+$/, "") || "/";
   }
@@ -29521,7 +29849,7 @@ function buildAuditExclusions(projectRoot, ownWorktree, scope) {
     for (const v of expandTmpVariants(wt)) excl.add(v);
   }
   if (scope) {
-    const s = canonicalize((0, import_path63.join)(projectRoot, scope));
+    const s = canonicalize((0, import_path65.join)(projectRoot, scope));
     for (const v of expandTmpVariants(s)) excl.add(v);
   }
   return Array.from(excl);
@@ -29575,12 +29903,12 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
     return { violations: [], skipped: "win32" };
   }
   const sentinel = meta3.sentinelPath;
-  if (!sentinel || !(0, import_fs61.existsSync)(sentinel)) {
+  if (!sentinel || !(0, import_fs63.existsSync)(sentinel)) {
     return { violations: [], skipped: "sentinel missing" };
   }
   let sentinelMtimeMs = 0;
   try {
-    sentinelMtimeMs = (0, import_fs61.statSync)(sentinel).mtimeMs;
+    sentinelMtimeMs = (0, import_fs63.statSync)(sentinel).mtimeMs;
   } catch {
   }
   if (sentinelMtimeMs === 0) {
@@ -29592,11 +29920,11 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   );
   const exclusions = buildAuditExclusions(projectRoot, meta3.worktreePath, options.scope);
   const findBin = options.findBinary ?? "find";
-  const sentinelDir = canonicalize((0, import_path63.join)(projectRoot, ".gossip", SENTINEL_DIR));
+  const sentinelDir = canonicalize((0, import_path65.join)(projectRoot, ".gossip", SENTINEL_DIR));
   const mainSet = /* @__PURE__ */ new Set();
   const sensitiveSet = /* @__PURE__ */ new Set();
   for (const root of scanRoots) {
-    if (!(0, import_fs61.existsSync)(root)) continue;
+    if (!(0, import_fs63.existsSync)(root)) continue;
     const canonRoot = canonicalize(root);
     const allExcl = [...exclusions, ...expandTmpVariants(sentinelDir)];
     const args = buildFindPruneArgs(canonRoot, allExcl, sentinel);
@@ -29632,7 +29960,7 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   }
   const sensitiveTargets = buildSensitiveTargets(platform2);
   for (const target of sensitiveTargets) {
-    if (!(0, import_fs61.existsSync)(target.path)) continue;
+    if (!(0, import_fs63.existsSync)(target.path)) continue;
     const canonTarget = canonicalize(target.path);
     const args = buildSensitiveFindArgs(
       canonTarget,
@@ -29688,8 +30016,8 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
 }
 function recordLayer3Violations(projectRoot, meta3, violations, source) {
   try {
-    const dir = (0, import_path63.join)(projectRoot, ".gossip");
-    (0, import_fs61.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path65.join)(projectRoot, ".gossip");
+    (0, import_fs63.mkdirSync)(dir, { recursive: true });
     const ts2 = (/* @__PURE__ */ new Date()).toISOString();
     const lines = violations.map(
       (path6) => JSON.stringify({
@@ -29700,9 +30028,9 @@ function recordLayer3Violations(projectRoot, meta3, violations, source) {
         source
       })
     );
-    const escapeFile = (0, import_path63.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path65.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs61.appendFileSync)(escapeFile, lines.join("\n") + "\n");
+    (0, import_fs63.appendFileSync)(escapeFile, lines.join("\n") + "\n");
   } catch {
   }
   if (source === "layer3-sensitive" && violations.length > 0) {
@@ -29759,14 +30087,14 @@ function runLayer3Audit(projectRoot, taskId) {
   }
   return { blockError, warnPrefix };
 }
-var import_child_process8, import_fs61, import_os3, import_path63, 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_process8, import_fs63, import_os3, import_path65, 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_process8 = require("child_process");
-    import_fs61 = require("fs");
+    import_fs63 = require("fs");
     import_os3 = require("os");
-    import_path63 = require("path");
+    import_path65 = require("path");
     METADATA_FILE = "dispatch-metadata.jsonl";
     BOUNDARY_ESCAPE_FILE = "boundary-escapes.jsonl";
     SENTINEL_DIR = "sentinels";
@@ -29825,6 +30153,114 @@ var init_sandbox2 = __esm({
   }
 });
 
+// apps/cli/src/handlers/ref-allowlist-detection.ts
+var ref_allowlist_detection_exports = {};
+__export(ref_allowlist_detection_exports, {
+  capturePreDispatchSha: () => capturePreDispatchSha,
+  checkRefAllowlistViolation: () => checkRefAllowlistViolation
+});
+function capturePreDispatchSha() {
+  try {
+    const sha = (0, import_child_process9.execFileSync)("git", ["rev-parse", "origin/master"], {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return sha || null;
+  } catch {
+    process.stderr.write("[gossipcat] ref-allowlist: could not read origin/master SHA (offline or no remote) \u2014 skipping pre-dispatch snapshot\n");
+    return null;
+  }
+}
+function getPrMergeCommits(preSha, postSha) {
+  try {
+    const out = (0, import_child_process9.execFileSync)(
+      "git",
+      ["log", `${preSha}..${postSha}`, `--grep=(#[0-9]`, "--format=%H %s"],
+      { cwd: process.cwd(), stdio: ["ignore", "pipe", "ignore"] }
+    ).toString().trim();
+    return out ? out.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function getCommitRange(preSha, postSha) {
+  try {
+    const out = (0, import_child_process9.execFileSync)(
+      "git",
+      ["log", `${preSha}..${postSha}`, "--format=%H %s"],
+      { cwd: process.cwd(), stdio: ["ignore", "pipe", "ignore"] }
+    ).toString().trim();
+    return out ? out.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function appendViolationRecord(record2) {
+  try {
+    const projectRoot = process.cwd();
+    (0, import_fs64.mkdirSync)((0, import_path66.join)(projectRoot, ".gossip"), { recursive: true });
+    const logPath = (0, import_path66.join)(projectRoot, PROCESS_VIOLATIONS_FILE);
+    (0, import_fs64.appendFileSync)(logPath, JSON.stringify(record2) + "\n", "utf8");
+  } catch (err) {
+    process.stderr.write(`[gossipcat] ref-allowlist: failed to append violation record: ${err.message}
+`);
+  }
+}
+function checkRefAllowlistViolation(taskId, agentId, preSha) {
+  let postSha;
+  try {
+    postSha = (0, import_child_process9.execFileSync)("git", ["rev-parse", "origin/master"], {
+      cwd: process.cwd(),
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+  } catch {
+    return;
+  }
+  if (!postSha || postSha === preSha) return;
+  const mergeCommits = getPrMergeCommits(preSha, postSha);
+  if (mergeCommits.length > 0) return;
+  const allCommits = getCommitRange(preSha, postSha);
+  const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
+  appendViolationRecord({ taskId, agentId, preSha, postSha, detectedAt, commits: allCommits });
+  try {
+    const { emitConsensusSignals: emitConsensusSignals2 } = (init_src4(), __toCommonJS(src_exports3));
+    emitConsensusSignals2(process.cwd(), [
+      {
+        type: "consensus",
+        signal: "boundary_escape",
+        agentId,
+        taskId,
+        findingId: `proc:${taskId}:master_push`,
+        category: "process_discipline",
+        severity: "high",
+        evidence: `origin/master moved from ${preSha} to ${postSha} during task ${taskId} without a PR-merge entry \u2014 direct push detected. Commits: ${allCommits.slice(0, 5).join("; ")}`,
+        timestamp: detectedAt
+      }
+    ]);
+  } catch (err) {
+    process.stderr.write(`[gossipcat] ref-allowlist: failed to emit boundary_escape signal: ${err.message}
+`);
+  }
+  process.stderr.write(
+    `
+REF-ALLOWLIST VIOLATION: ${taskId} agent=${agentId} origin/master moved ${preSha.slice(0, 8)}\u2192${postSha.slice(0, 8)} with no PR merge.
+Operator confirmation required for revert or retroactive PR.
+Full audit trail at .gossip/process-violations.jsonl
+
+`
+  );
+}
+var import_fs64, import_path66, import_child_process9, PROCESS_VIOLATIONS_FILE;
+var init_ref_allowlist_detection = __esm({
+  "apps/cli/src/handlers/ref-allowlist-detection.ts"() {
+    "use strict";
+    import_fs64 = require("fs");
+    import_path66 = require("path");
+    import_child_process9 = require("child_process");
+    PROCESS_VIOLATIONS_FILE = ".gossip/process-violations.jsonl";
+  }
+});
+
 // apps/cli/src/handlers/native-tasks.ts
 function pruneExpiredRecentConsensusTaskIds(now = Date.now()) {
   try {
@@ -29904,11 +30340,11 @@ function taskWasInConsensusRound(taskId, agentId, rounds, recentTaskIds, recentA
 }
 function appendRelayWarning(projectRoot, entry) {
   try {
-    const { appendFileSync: appendFileSync16, mkdirSync: mkdirSync30 } = require("fs");
-    const { join: join70 } = require("path");
-    const dir = join70(projectRoot, ".gossip");
-    mkdirSync30(dir, { recursive: true });
-    appendFileSync16(join70(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
+    const { appendFileSync: appendFileSync18, mkdirSync: mkdirSync33 } = require("fs");
+    const { join: join73 } = require("path");
+    const dir = join73(projectRoot, ".gossip");
+    mkdirSync33(dir, { recursive: true });
+    appendFileSync18(join73(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
   } catch (err) {
     process.stderr.write(`[gossipcat] append relay-warning failed: ${err.message}
 `);
@@ -30224,6 +30660,13 @@ async function handleNativeRelay(task_id, result, error48, agentStartedAt, relay
     ctx.mainAgent.scopeTracker.release(task_id);
   } catch {
   }
+  if (taskInfo.writeMode && taskInfo.preDispatchSha) {
+    try {
+      const { checkRefAllowlistViolation: checkRefAllowlistViolation2 } = (init_ref_allowlist_detection(), __toCommonJS(ref_allowlist_detection_exports));
+      checkRefAllowlistViolation2(task_id, taskInfo.agentId, taskInfo.preDispatchSha);
+    } catch {
+    }
+  }
   if (error48 && taskInfo.writeMode === "worktree") {
     try {
       ctx.mainAgent.getWorktreeManager()?.pruneOrphans().catch(() => {
@@ -30575,12 +31018,12 @@ function startConsensusTimeout(consensusId) {
       const allEntries = [...snapshot.relayCrossReviewEntries, ...snapshot.nativeCrossReviewEntries];
       const report = await engine.synthesizeWithCrossReview(snapshot.allResults, allEntries, consensusId, snapshot.relayCrossReviewSkipped);
       try {
-        const { writeFileSync: writeFileSync25, mkdirSync: mkdirSync30 } = require("fs");
-        const { join: join70 } = require("path");
-        const reportsDir = join70(process.cwd(), ".gossip", "consensus-reports");
-        mkdirSync30(reportsDir, { recursive: true });
+        const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync33 } = require("fs");
+        const { join: join73 } = require("path");
+        const reportsDir = join73(process.cwd(), ".gossip", "consensus-reports");
+        mkdirSync33(reportsDir, { recursive: true });
         const topic = snapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
-        writeFileSync25(join70(reportsDir, `${consensusId}.json`), JSON.stringify({
+        writeFileSync26(join73(reportsDir, `${consensusId}.json`), JSON.stringify({
           id: consensusId,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           topic,
@@ -30747,13 +31190,13 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
       synthSnapshot.relayCrossReviewSkipped
     );
     try {
-      const { writeFileSync: writeFileSync25, mkdirSync: mkdirSync30 } = require("fs");
-      const { join: join70 } = require("path");
-      const reportsDir = join70(process.cwd(), ".gossip", "consensus-reports");
-      mkdirSync30(reportsDir, { recursive: true });
-      const reportPath = join70(reportsDir, `${consensus_id}.json`);
+      const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync33 } = require("fs");
+      const { join: join73 } = require("path");
+      const reportsDir = join73(process.cwd(), ".gossip", "consensus-reports");
+      mkdirSync33(reportsDir, { recursive: true });
+      const reportPath = join73(reportsDir, `${consensus_id}.json`);
       const topic = synthSnapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
-      writeFileSync25(reportPath, JSON.stringify({
+      writeFileSync26(reportPath, JSON.stringify({
         id: consensus_id,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         topic,
@@ -30796,10 +31239,10 @@ function persistPendingConsensus() {
   try {
     const projectRoot = ctx.mainAgent?.projectRoot;
     if (!projectRoot) return;
-    const { writeFileSync: writeFileSync25, mkdirSync: mkdirSync30 } = require("fs");
-    const { join: join70 } = require("path");
-    const dir = join70(projectRoot, ".gossip");
-    mkdirSync30(dir, { recursive: true });
+    const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync33 } = require("fs");
+    const { join: join73 } = require("path");
+    const dir = join73(projectRoot, ".gossip");
+    mkdirSync33(dir, { recursive: true });
     const rounds = {};
     for (const [id, round] of ctx.pendingConsensusRounds) {
       rounds[id] = {
@@ -30824,7 +31267,7 @@ function persistPendingConsensus() {
         resolutionRoots: round.resolutionRoots ? [...round.resolutionRoots] : void 0
       };
     }
-    writeFileSync25(join70(dir, CONSENSUS_FILE), JSON.stringify(rounds));
+    writeFileSync26(join73(dir, CONSENSUS_FILE), JSON.stringify(rounds));
   } catch (err) {
     process.stderr.write(`[gossipcat] persistPendingConsensus failed: ${err.message}
 `);
@@ -30832,11 +31275,11 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync61, readFileSync: readFileSync59, unlinkSync: unlinkSync7 } = require("fs");
-    const { join: join70 } = require("path");
-    const filePath = join70(projectRoot, ".gossip", CONSENSUS_FILE);
-    if (!existsSync61(filePath)) return;
-    const raw = JSON.parse(readFileSync59(filePath, "utf-8"));
+    const { existsSync: existsSync64, readFileSync: readFileSync61, unlinkSync: unlinkSync8 } = require("fs");
+    const { join: join73 } = require("path");
+    const filePath = join73(projectRoot, ".gossip", CONSENSUS_FILE);
+    if (!existsSync64(filePath)) return;
+    const raw = JSON.parse(readFileSync61(filePath, "utf-8"));
     const now = Date.now();
     for (const [id, data] of Object.entries(raw)) {
       if (now > data.deadline + 3e5) {
@@ -30867,7 +31310,7 @@ function restorePendingConsensus(projectRoot) {
       process.stderr.write(`[gossipcat] Restored consensus round ${id} \u2014 ${data.pendingNativeAgents?.length ?? 0} agents pending
 `);
     }
-    unlinkSync7(filePath);
+    unlinkSync8(filePath);
   } catch {
   }
 }
@@ -30881,6 +31324,178 @@ var init_relay_cross_review = __esm({
   }
 });
 
+// apps/cli/src/lifecycle-tasks.ts
+var lifecycle_tasks_exports = {};
+__export(lifecycle_tasks_exports, {
+  __resetLifecycleTasksForTests: () => __resetLifecycleTasksForTests,
+  drainLifecycleTasks: () => drainLifecycleTasks,
+  installLifecycleDrainHandlers: () => installLifecycleDrainHandlers,
+  trackLifecycleTask: () => trackLifecycleTask
+});
+function trackLifecycleTask(p) {
+  inFlight.add(p);
+  p.finally(() => {
+    inFlight.delete(p);
+  }).catch(() => {
+  });
+}
+function drainLifecycleTasks(maxMs = 8e3) {
+  if (inFlight.size === 0) return Promise.resolve();
+  const snapshot = [...inFlight];
+  return Promise.race([
+    Promise.allSettled(snapshot).then(() => void 0),
+    new Promise((resolve28) => setTimeout(resolve28, maxMs).unref?.())
+  ]).then(() => void 0);
+}
+function installLifecycleDrainHandlers() {
+  if (__installed) return;
+  __installed = true;
+  const drainAndContinue = async (signal) => {
+    try {
+      const pending = inFlight.size;
+      if (pending > 0) {
+        process.stderr.write(`[gossipcat] ${signal}: draining ${pending} lifecycle task(s)
+`);
+      }
+      await drainLifecycleTasks();
+    } catch {
+    }
+  };
+  process.on("beforeExit", () => {
+    void drainAndContinue("beforeExit");
+  });
+}
+function __resetLifecycleTasksForTests() {
+  if (process.env.NODE_ENV !== "test") {
+    throw new Error("__resetLifecycleTasksForTests is test-only \u2014 refusing to run outside NODE_ENV=test");
+  }
+  inFlight.clear();
+  __installed = false;
+}
+var inFlight, __installed;
+var init_lifecycle_tasks = __esm({
+  "apps/cli/src/lifecycle-tasks.ts"() {
+    "use strict";
+    inFlight = /* @__PURE__ */ new Set();
+    __installed = false;
+  }
+});
+
+// apps/cli/src/handlers/check-effectiveness-runner.ts
+var check_effectiveness_runner_exports = {};
+__export(check_effectiveness_runner_exports, {
+  runCheckEffectivenessForAllSkills: () => runCheckEffectivenessForAllSkills
+});
+function writeHealthAtomic(projectRoot, record2) {
+  const dir = (0, import_path68.join)(projectRoot, ".gossip");
+  const finalPath = (0, import_path68.join)(dir, "skill-runner-health.json");
+  const tmpPath = finalPath + ".tmp";
+  try {
+    (0, import_fs66.mkdirSync)(dir, { recursive: true });
+    (0, import_fs66.writeFileSync)(tmpPath, JSON.stringify(record2, null, 2));
+    (0, import_fs66.renameSync)(tmpPath, finalPath);
+  } catch (e) {
+    process.stderr.write(`[gossipcat] checkEffectiveness: health write failed: ${e.message}
+`);
+    try {
+      if ((0, import_fs66.existsSync)(tmpPath)) (0, import_fs66.unlinkSync)(tmpPath);
+    } catch {
+    }
+  }
+}
+async function runCheckEffectivenessForAllSkills(opts) {
+  const startedAt = Date.now();
+  const baseDir = (0, import_path68.join)(opts.projectRoot, ".gossip", "agents");
+  let agentDirs = [];
+  let canonicalBaseDir;
+  if ((0, import_fs66.existsSync)(baseDir)) {
+    try {
+      canonicalBaseDir = (0, import_fs66.realpathSync)(baseDir);
+      agentDirs = (0, import_fs66.readdirSync)(canonicalBaseDir);
+    } catch {
+    }
+  }
+  process.stderr.write(`[gossipcat] checkEffectiveness: scanning across ${agentDirs.length} agents
+`);
+  let skillsChecked = 0;
+  const transitions = {
+    passed: 0,
+    failed: 0,
+    flagged_for_manual_review: 0,
+    inconclusive: 0,
+    pending: 0
+  };
+  let lastError = null;
+  if (canonicalBaseDir && agentDirs.length > 0) {
+    for (const agentId of agentDirs) {
+      if (agentId.startsWith("_")) continue;
+      if (!SAFE_NAME2.test(agentId)) continue;
+      const skillsDir = (0, import_path68.join)(canonicalBaseDir, agentId, "skills");
+      if (!(0, import_fs66.existsSync)(skillsDir)) continue;
+      let canonicalSkillsDir;
+      try {
+        canonicalSkillsDir = (0, import_fs66.realpathSync)(skillsDir);
+      } catch {
+        continue;
+      }
+      if (!canonicalSkillsDir.startsWith(canonicalBaseDir + "/")) {
+        process.stderr.write(`[gossipcat] checkEffectiveness: skipping ${agentId} \u2014 skillsDir resolved outside agents tree (canonical=${canonicalSkillsDir})
+`);
+        continue;
+      }
+      const role = opts.registryGet(agentId)?.role;
+      if (role === "implementer") continue;
+      const files = (0, import_fs66.readdirSync)(canonicalSkillsDir).filter((f) => f.endsWith(".md"));
+      for (const file2 of files) {
+        const category = file2.replace(/\.md$/, "");
+        if (!SAFE_NAME2.test(category)) continue;
+        skillsChecked++;
+        try {
+          const verdict = await opts.skillEngine.checkEffectiveness(agentId, category, { role });
+          if (verdict.shouldUpdate) {
+            const loggedStates = /* @__PURE__ */ new Set(["passed", "failed", "flagged_for_manual_review"]);
+            if (loggedStates.has(verdict.status)) {
+              process.stderr.write(
+                `[gossipcat] checkEffectiveness ${agentId}/${category}: ${verdict.status}` + (verdict.effectiveness !== void 0 ? ` (\u0394=${verdict.effectiveness.toFixed(3)})` : "") + `
+`
+              );
+            }
+            if (transitions[verdict.status] != null) {
+              transitions[verdict.status]++;
+            }
+          }
+        } catch (e) {
+          lastError = e.message;
+          process.stderr.write(`[gossipcat] checkEffectiveness ${agentId}/${category} threw: ${lastError}
+`);
+        }
+      }
+    }
+  }
+  const totalTransitions = transitions.passed + transitions.failed + transitions.flagged_for_manual_review + transitions.inconclusive + transitions.pending;
+  const durationMs = Date.now() - startedAt;
+  process.stderr.write(
+    `[gossipcat] checkEffectiveness: done in ${durationMs}ms (skills: ${skillsChecked}, transitions: ${totalTransitions})
+`
+  );
+  writeHealthAtomic(opts.projectRoot, {
+    last_run_at: new Date(startedAt).toISOString(),
+    last_run_duration_ms: durationMs,
+    skills_evaluated: skillsChecked,
+    transitions,
+    last_error: lastError
+  });
+}
+var import_fs66, import_path68, SAFE_NAME2;
+var init_check_effectiveness_runner = __esm({
+  "apps/cli/src/handlers/check-effectiveness-runner.ts"() {
+    "use strict";
+    import_fs66 = require("fs");
+    import_path68 = require("path");
+    SAFE_NAME2 = /^(?!.*\.\.)[a-zA-Z0-9._-]+$/;
+  }
+});
+
 // apps/cli/src/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -30897,18 +31512,18 @@ __export(config_exports, {
 function findConfigPath(projectRoot) {
   const root = projectRoot || process.cwd();
   const candidates = [
-    (0, import_path65.resolve)(root, ".gossip", "config.json"),
-    (0, import_path65.resolve)(root, "gossip.agents.json"),
-    (0, import_path65.resolve)(root, "gossip.agents.yaml"),
-    (0, import_path65.resolve)(root, "gossip.agents.yml")
+    (0, import_path69.resolve)(root, ".gossip", "config.json"),
+    (0, import_path69.resolve)(root, "gossip.agents.json"),
+    (0, import_path69.resolve)(root, "gossip.agents.yaml"),
+    (0, import_path69.resolve)(root, "gossip.agents.yml")
   ];
   for (const p of candidates) {
-    if ((0, import_fs63.existsSync)(p)) return p;
+    if ((0, import_fs67.existsSync)(p)) return p;
   }
   return null;
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs63.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs67.readFileSync)(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -30998,19 +31613,19 @@ function configToAgentConfigs(config2) {
 }
 function loadClaudeSubagents(projectRoot, existingIds) {
   const root = projectRoot || process.cwd();
-  const agentsDir = (0, import_path65.join)(root, ".claude", "agents");
-  if (!(0, import_fs63.existsSync)(agentsDir)) return [];
+  const agentsDir = (0, import_path69.join)(root, ".claude", "agents");
+  if (!(0, import_fs67.existsSync)(agentsDir)) return [];
   let files;
   try {
-    files = (0, import_fs63.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
+    files = (0, import_fs67.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const agents = [];
   for (const file2 of files) {
-    const filePath = (0, import_path65.join)(agentsDir, file2);
+    const filePath = (0, import_path69.join)(agentsDir, file2);
     try {
-      const content = (0, import_fs63.readFileSync)(filePath, "utf-8");
+      const content = (0, import_fs67.readFileSync)(filePath, "utf-8");
       const frontmatter = content.match(/^---\n([\s\S]*?)\n---/);
       if (!frontmatter) continue;
       const fm = frontmatter[1];
@@ -31065,12 +31680,12 @@ function inferSkills(description, name) {
   if (skills.length === 0) skills.push("general");
   return skills;
 }
-var import_fs63, import_path65, VALID_PROVIDERS, VALID_MAIN_PROVIDERS, CLAUDE_MODEL_MAP;
+var import_fs67, import_path69, VALID_PROVIDERS, VALID_MAIN_PROVIDERS, CLAUDE_MODEL_MAP;
 var init_config = __esm({
   "apps/cli/src/config.ts"() {
     "use strict";
-    import_fs63 = require("fs");
-    import_path65 = require("path");
+    import_fs67 = require("fs");
+    import_path69 = require("path");
     VALID_PROVIDERS = ["anthropic", "openai", "openclaw", "google", "local", "native", "none"];
     VALID_MAIN_PROVIDERS = VALID_PROVIDERS.filter((p) => p !== "native");
     CLAUDE_MODEL_MAP = {
@@ -31088,86 +31703,38 @@ __export(skill_develop_audit_exports, {
 });
 function appendSkillDevelopAudit(entry) {
   try {
-    const gossipDir2 = (0, import_path66.join)(process.cwd(), ".gossip");
-    (0, import_fs64.mkdirSync)(gossipDir2, { recursive: true });
+    const gossipDir2 = (0, import_path70.join)(process.cwd(), ".gossip");
+    (0, import_fs68.mkdirSync)(gossipDir2, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs64.appendFileSync)((0, import_path66.join)(gossipDir2, AUDIT_FILE), line);
-    (0, import_fs64.appendFileSync)((0, import_path66.join)(gossipDir2, LEGACY_FILE), line);
+    (0, import_fs68.appendFileSync)((0, import_path70.join)(gossipDir2, AUDIT_FILE), line);
+    (0, import_fs68.appendFileSync)((0, import_path70.join)(gossipDir2, LEGACY_FILE), line);
   } catch {
   }
 }
-var import_fs64, import_path66, AUDIT_FILE, LEGACY_FILE;
+var import_fs68, import_path70, AUDIT_FILE, LEGACY_FILE;
 var init_skill_develop_audit = __esm({
   "apps/cli/src/handlers/skill-develop-audit.ts"() {
     "use strict";
-    import_fs64 = require("fs");
-    import_path66 = require("path");
+    import_fs68 = require("fs");
+    import_path70 = require("path");
     AUDIT_FILE = "skill-develop-audit.jsonl";
     LEGACY_FILE = "forced-skill-develops.jsonl";
   }
 });
 
-// apps/cli/src/handlers/check-effectiveness-runner.ts
-var check_effectiveness_runner_exports = {};
-__export(check_effectiveness_runner_exports, {
-  runCheckEffectivenessForAllSkills: () => runCheckEffectivenessForAllSkills
-});
-async function runCheckEffectivenessForAllSkills(opts) {
-  const baseDir = (0, import_path67.join)(opts.projectRoot, ".gossip", "agents");
-  if (!(0, import_fs65.existsSync)(baseDir)) return;
-  const agentDirs = (0, import_fs65.readdirSync)(baseDir);
-  for (const agentId of agentDirs) {
-    if (agentId.startsWith("_")) continue;
-    if (!SAFE_NAME2.test(agentId)) continue;
-    const skillsDir = (0, import_path67.join)(baseDir, agentId, "skills");
-    if (!(0, import_fs65.existsSync)(skillsDir)) continue;
-    const role = opts.registryGet(agentId)?.role;
-    if (role === "implementer") continue;
-    const files = (0, import_fs65.readdirSync)(skillsDir).filter((f) => f.endsWith(".md"));
-    for (const file2 of files) {
-      const category = file2.replace(/\.md$/, "");
-      if (!SAFE_NAME2.test(category)) continue;
-      try {
-        const verdict = await opts.skillEngine.checkEffectiveness(agentId, category, { role });
-        if (verdict.shouldUpdate) {
-          const loggedStates = /* @__PURE__ */ new Set(["passed", "failed", "flagged_for_manual_review"]);
-          if (loggedStates.has(verdict.status)) {
-            process.stderr.write(
-              `[gossipcat] checkEffectiveness ${agentId}/${category}: ${verdict.status}` + (verdict.effectiveness !== void 0 ? ` (\u0394=${verdict.effectiveness.toFixed(3)})` : "") + `
-`
-            );
-          }
-        }
-      } catch (e) {
-        process.stderr.write(`[gossipcat] checkEffectiveness ${agentId}/${category} threw: ${e.message}
-`);
-      }
-    }
-  }
-}
-var import_fs65, import_path67, SAFE_NAME2;
-var init_check_effectiveness_runner = __esm({
-  "apps/cli/src/handlers/check-effectiveness-runner.ts"() {
-    "use strict";
-    import_fs65 = require("fs");
-    import_path67 = require("path");
-    SAFE_NAME2 = /^(?!.*\.\.)[a-zA-Z0-9._-]+$/;
-  }
-});
-
 // apps/cli/src/keychain.ts
 var keychain_exports = {};
 __export(keychain_exports, {
   Keychain: () => Keychain
 });
-var import_child_process9, import_os4, import_fs69, import_path71, import_crypto25, DEFAULT_SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
+var import_child_process10, import_os4, import_fs72, import_path74, import_crypto25, DEFAULT_SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
 var init_keychain = __esm({
   "apps/cli/src/keychain.ts"() {
     "use strict";
-    import_child_process9 = require("child_process");
+    import_child_process10 = require("child_process");
     import_os4 = require("os");
-    import_fs69 = require("fs");
-    import_path71 = require("path");
+    import_fs72 = require("fs");
+    import_path74 = require("path");
     import_crypto25 = require("crypto");
     DEFAULT_SERVICE_NAME = "gossip-mesh";
     VALID_PROVIDERS2 = /^[a-zA-Z0-9_-]{1,32}$/;
@@ -31211,10 +31778,10 @@ var init_keychain = __esm({
         return (0, import_crypto25.pbkdf2Sync)(seed, salt, 6e5, 32, "sha256");
       }
       loadEncryptedFile() {
-        const filePath = (0, import_path71.join)(process.cwd(), ENCRYPTED_FILE);
-        if (!(0, import_fs69.existsSync)(filePath)) return;
+        const filePath = (0, import_path74.join)(process.cwd(), ENCRYPTED_FILE);
+        if (!(0, import_fs72.existsSync)(filePath)) return;
         try {
-          const raw = (0, import_fs69.readFileSync)(filePath);
+          const raw = (0, import_fs72.readFileSync)(filePath);
           if (raw.length < 61) return;
           const salt = raw.subarray(0, 32);
           const iv = raw.subarray(32, 44);
@@ -31232,9 +31799,9 @@ var init_keychain = __esm({
         }
       }
       saveEncryptedFile() {
-        const filePath = (0, import_path71.join)(process.cwd(), ENCRYPTED_FILE);
-        const dir = (0, import_path71.join)(process.cwd(), ".gossip");
-        if (!(0, import_fs69.existsSync)(dir)) (0, import_fs69.mkdirSync)(dir, { recursive: true });
+        const filePath = (0, import_path74.join)(process.cwd(), ENCRYPTED_FILE);
+        const dir = (0, import_path74.join)(process.cwd(), ".gossip");
+        if (!(0, import_fs72.existsSync)(dir)) (0, import_fs72.mkdirSync)(dir, { recursive: true });
         const data = JSON.stringify(Object.fromEntries(this.inMemoryStore));
         const salt = (0, import_crypto25.randomBytes)(32);
         const iv = (0, import_crypto25.randomBytes)(12);
@@ -31242,12 +31809,12 @@ var init_keychain = __esm({
         const cipher = (0, import_crypto25.createCipheriv)(ALGO, key, iv);
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
-        (0, import_fs69.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
+        (0, import_fs72.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
       }
       isKeychainAvailable() {
         if ((0, import_os4.platform)() === "darwin") {
           try {
-            (0, import_child_process9.execFileSync)("security", ["help"], { stdio: "pipe" });
+            (0, import_child_process10.execFileSync)("security", ["help"], { stdio: "pipe" });
             return true;
           } catch {
             return false;
@@ -31255,7 +31822,7 @@ var init_keychain = __esm({
         }
         if ((0, import_os4.platform)() === "linux") {
           try {
-            (0, import_child_process9.execFileSync)("which", ["secret-tool"], { stdio: "pipe" });
+            (0, import_child_process10.execFileSync)("which", ["secret-tool"], { stdio: "pipe" });
             return true;
           } catch {
             return false;
@@ -31271,7 +31838,7 @@ var init_keychain = __esm({
       readFromKeychain(provider) {
         this.validateProvider(provider);
         if ((0, import_os4.platform)() === "darwin") {
-          return (0, import_child_process9.execFileSync)("security", [
+          return (0, import_child_process10.execFileSync)("security", [
             "find-generic-password",
             "-s",
             this.serviceName,
@@ -31281,7 +31848,7 @@ var init_keychain = __esm({
           ], { stdio: "pipe" }).toString().trim();
         }
         if ((0, import_os4.platform)() === "linux") {
-          return (0, import_child_process9.execFileSync)("secret-tool", [
+          return (0, import_child_process10.execFileSync)("secret-tool", [
             "lookup",
             "service",
             this.serviceName,
@@ -31295,7 +31862,7 @@ var init_keychain = __esm({
         this.validateProvider(provider);
         if ((0, import_os4.platform)() === "darwin") {
           try {
-            (0, import_child_process9.execFileSync)("security", [
+            (0, import_child_process10.execFileSync)("security", [
               "delete-generic-password",
               "-s",
               this.serviceName,
@@ -31304,7 +31871,7 @@ var init_keychain = __esm({
             ], { stdio: "pipe" });
           } catch {
           }
-          (0, import_child_process9.execFileSync)("security", [
+          (0, import_child_process10.execFileSync)("security", [
             "add-generic-password",
             "-s",
             this.serviceName,
@@ -31316,7 +31883,7 @@ var init_keychain = __esm({
           return;
         }
         if ((0, import_os4.platform)() === "linux") {
-          (0, import_child_process9.execFileSync)("secret-tool", [
+          (0, import_child_process10.execFileSync)("secret-tool", [
             "store",
             "--label",
             `Gossip Mesh ${provider}`,
@@ -31342,23 +31909,23 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path72.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path75.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs70.readFileSync)(saltPath, "utf-8").trim();
+    return (0, import_fs73.readFileSync)(saltPath, "utf-8").trim();
   } catch {
     const salt = (0, import_crypto26.randomBytes)(16).toString("hex");
-    (0, import_fs70.mkdirSync)((0, import_path72.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs73.mkdirSync)((0, import_path75.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs70.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs73.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs70.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs73.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
 function getUserId(projectRoot) {
   try {
-    const email3 = (0, import_child_process10.execFileSync)("git", ["config", "user.email"], { stdio: "pipe" }).toString().trim();
+    const email3 = (0, import_child_process11.execFileSync)("git", ["config", "user.email"], { stdio: "pipe" }).toString().trim();
     const salt = getOrCreateSalt(projectRoot);
     return (0, import_crypto26.createHash)("sha256").update(email3 + projectRoot + salt).digest("hex").slice(0, 16);
   } catch {
@@ -31381,7 +31948,7 @@ function getTeamUserId(email3, teamSalt) {
 }
 function getGitEmail() {
   try {
-    const email3 = (0, import_child_process10.execFileSync)("git", ["config", "user.email"], { stdio: "pipe" }).toString().trim();
+    const email3 = (0, import_child_process11.execFileSync)("git", ["config", "user.email"], { stdio: "pipe" }).toString().trim();
     return email3 || null;
   } catch {
     return null;
@@ -31389,7 +31956,7 @@ function getGitEmail() {
 }
 function getProjectId(projectRoot) {
   try {
-    const remoteUrl = (0, import_child_process10.execFileSync)(
+    const remoteUrl = (0, import_child_process11.execFileSync)(
       "git",
       ["config", "--get", "remote.origin.url"],
       { cwd: projectRoot, stdio: "pipe" }
@@ -31402,14 +31969,14 @@ function getProjectId(projectRoot) {
   }
   return (0, import_crypto26.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 16);
 }
-var import_fs70, import_path72, import_crypto26, import_child_process10;
+var import_fs73, import_path75, import_crypto26, import_child_process11;
 var init_identity = __esm({
   "apps/cli/src/identity.ts"() {
     "use strict";
-    import_fs70 = require("fs");
-    import_path72 = require("path");
+    import_fs73 = require("fs");
+    import_path75 = require("path");
     import_crypto26 = require("crypto");
-    import_child_process10 = require("child_process");
+    import_child_process11 = require("child_process");
   }
 });
 
@@ -31429,9 +31996,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path73.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path76.resolve)(__dirname, "..", "..", "..", "..");
   if (process.env.npm_config_global === "true") return "global";
-  if ((0, import_fs71.existsSync)((0, import_path73.join)(packageRoot, ".git"))) return "git-clone";
+  if ((0, import_fs74.existsSync)((0, import_path76.join)(packageRoot, ".git"))) return "git-clone";
   return "local";
 }
 function updateCommand(method, version2) {
@@ -31479,10 +32046,15 @@ Check your internet connection or visit https://www.npmjs.com/package/gossipcat
       }]
     };
   }
+  const scrubbedEnv = { ...process.env };
+  for (const key of Object.keys(scrubbedEnv)) {
+    if (/^GOSSIPCAT_/i.test(key)) delete scrubbedEnv[key];
+  }
   try {
-    (0, import_child_process11.execSync)(command, {
+    (0, import_child_process12.execSync)(command, {
       stdio: "inherit",
-      cwd: method === "git-clone" ? (0, import_path73.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
+      cwd: method === "git-clone" ? (0, import_path76.resolve)(__dirname, "..", "..", "..", "..") : process.cwd(),
+      env: scrubbedEnv
     });
   } catch (err) {
     return {
@@ -31504,13 +32076,13 @@ Run /mcp reconnect in Claude Code to load the new version.`
     }]
   };
 }
-var import_child_process11, import_fs71, import_path73;
+var import_child_process12, import_fs74, import_path76;
 var init_gossip_update = __esm({
   "apps/cli/src/handlers/gossip-update.ts"() {
     "use strict";
-    import_child_process11 = require("child_process");
-    import_fs71 = require("fs");
-    import_path73 = require("path");
+    import_child_process12 = require("child_process");
+    import_fs74 = require("fs");
+    import_path76 = require("path");
     init_version();
   }
 });
@@ -31716,8 +32288,8 @@ var init_verify_memory = __esm({
 });
 
 // apps/cli/src/mcp-server-sdk.ts
-var import_fs72 = require("fs");
-var import_path74 = require("path");
+var import_fs75 = require("fs");
+var import_path77 = require("path");
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
@@ -45544,8 +46116,8 @@ init_native_tasks();
 
 // apps/cli/src/handlers/dispatch.ts
 var import_crypto24 = require("crypto");
-var import_fs62 = require("fs");
-var import_path64 = require("path");
+var import_fs65 = require("fs");
+var import_path67 = require("path");
 init_src4();
 init_src3();
 init_mcp_context();
@@ -45572,7 +46144,11 @@ function persistRelayTasks() {
         agentId: task.agentId,
         task: task.task.slice(0, 5e3),
         startedAt: task.startedAt,
-        timeoutMs: task.timeoutMs
+        timeoutMs: task.timeoutMs,
+        // Persist the dispatched resolutionRoots so post-reconnect audit /
+        // dashboard rendering can show the worktree binding even after the
+        // websocket-bound runtime task is marked timed_out.
+        ...task.resolutionRoots && task.resolutionRoots.length > 0 ? { resolutionRoots: [...task.resolutionRoots] } : {}
       });
     }
     wf(j(dir, RELAY_TASK_FILE), JSON.stringify({ tasks: records }));
@@ -45683,9 +46259,9 @@ function formatFalsifiedNote(block, verdicts) {
 }
 function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
   try {
-    const logPath = (0, import_path64.join)(projectRoot, PREMISE_VERIFICATION_LOG);
+    const logPath = (0, import_path67.join)(projectRoot, PREMISE_VERIFICATION_LOG);
     rotateIfNeeded2(logPath, MAX_PREMISE_VERIFICATION_BYTES);
-    (0, import_fs62.mkdirSync)((0, import_path64.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs65.mkdirSync)((0, import_path67.join)(projectRoot, ".gossip"), { recursive: true });
     const row = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       consensus_id: null,
@@ -45699,7 +46275,7 @@ function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
       skill_bound: opts.skill_bound
     };
     if (opts.schema_lint) row.schema_lint = opts.schema_lint;
-    (0, import_fs62.appendFileSync)(logPath, JSON.stringify(row) + "\n");
+    (0, import_fs65.appendFileSync)(logPath, JSON.stringify(row) + "\n");
   } catch {
   }
 }
@@ -45811,7 +46387,7 @@ var AGENT_PROVIDER_MAP = {
 };
 function readQuotaState() {
   try {
-    const raw = (0, import_fs62.readFileSync)((0, import_path64.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
+    const raw = (0, import_fs65.readFileSync)((0, import_path67.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -45835,7 +46411,7 @@ function reroutableAgent(agentId) {
   }
   return agentId;
 }
-async function handleDispatchSingle(agent_id, task, write_mode, scope, timeout_ms, plan_id, step) {
+async function handleDispatchSingle(agent_id, task, write_mode, scope, timeout_ms, plan_id, step, resolutionRoots) {
   await ctx.boot();
   await ctx.syncWorkersViaKeychain();
   if (!/^[a-zA-Z0-9_-]+$/.test(agent_id)) {
@@ -45857,6 +46433,9 @@ async function handleDispatchSingle(agent_id, task, write_mode, scope, timeout_m
     options.planId = plan_id;
     options.step = step;
   }
+  if (resolutionRoots && resolutionRoots.length > 0) {
+    options.resolutionRoots = resolutionRoots;
+  }
   const dispatchOptions = Object.keys(options).length > 0 ? options : void 0;
   const nativeConfig = ctx.nativeAgentConfigs.get(agent_id);
   if (nativeConfig) {
@@ -45878,7 +46457,12 @@ async function handleDispatchSingle(agent_id, task, write_mode, scope, timeout_m
     if (premiseResult.signals.length > 0) {
       emitConsensusSignals(process.cwd(), premiseResult.signals);
     }
-    ctx.nativeTaskMap.set(taskId, { agentId: agent_id, task, startedAt: Date.now(), timeoutMs, planId: plan_id, step, writeMode: write_mode, relayToken });
+    let preDispatchSha = null;
+    if (write_mode) {
+      const { capturePreDispatchSha: capturePreDispatchSha2 } = (init_ref_allowlist_detection(), __toCommonJS(ref_allowlist_detection_exports));
+      preDispatchSha = capturePreDispatchSha2();
+    }
+    ctx.nativeTaskMap.set(taskId, { agentId: agent_id, task, startedAt: Date.now(), timeoutMs, planId: plan_id, step, writeMode: write_mode, relayToken, preDispatchSha });
     spawnTimeoutWatcher(taskId, ctx.nativeTaskMap.get(taskId));
     persistNativeTaskMap();
     process.stderr.write(`[gossipcat] \u2192 dispatch \u2192 ${agent_id} (${nativeConfig.model}) [${taskId}]
@@ -45975,7 +46559,7 @@ ${agentPrompt}` }
     return { content: [{ type: "text", text: err.message }] };
   }
 }
-async function handleDispatchParallel(taskDefs, consensus) {
+async function handleDispatchParallel(taskDefs, consensus, resolutionRoots) {
   await ctx.boot();
   await ctx.syncWorkersViaKeychain();
   for (const def of taskDefs) {
@@ -46000,11 +46584,21 @@ async function handleDispatchParallel(taskDefs, consensus) {
   const lines = [];
   if (relayTasks.length > 0) {
     const { taskIds, errors } = await ctx.mainAgent.dispatchParallel(
-      relayTasks.map((d) => ({
-        agentId: d.agent_id,
-        task: d.task,
-        options: d.write_mode ? { writeMode: d.write_mode, scope: d.scope } : void 0
-      })),
+      relayTasks.map((d) => {
+        const opts = {};
+        if (d.write_mode) {
+          opts.writeMode = d.write_mode;
+          if (d.scope) opts.scope = d.scope;
+        }
+        if (resolutionRoots && resolutionRoots.length > 0) {
+          opts.resolutionRoots = resolutionRoots;
+        }
+        return {
+          agentId: d.agent_id,
+          task: d.task,
+          options: Object.keys(opts).length > 0 ? opts : void 0
+        };
+      }),
       consensus ? { consensus: true } : void 0
     );
     persistRelayTasks();
@@ -46197,12 +46791,13 @@ async function handleDispatchConsensus(taskDefs, _utility_task_id, dispatchResol
   const lines = [];
   const allTaskIds = [];
   if (relayTasks.length > 0) {
+    const relayOptions = dispatchResolutionRoots && dispatchResolutionRoots.length > 0 ? { resolutionRoots: dispatchResolutionRoots } : void 0;
     const { taskIds, errors } = precomputedLenses ? await ctx.mainAgent.dispatchParallelWithLenses(
-      relayTasks.map((d) => ({ agentId: d.agent_id, task: d.task })),
+      relayTasks.map((d) => ({ agentId: d.agent_id, task: d.task, options: relayOptions })),
       { consensus: true },
       precomputedLenses
     ) : await ctx.mainAgent.dispatchParallel(
-      relayTasks.map((d) => ({ agentId: d.agent_id, task: d.task })),
+      relayTasks.map((d) => ({ agentId: d.agent_id, task: d.task, options: relayOptions })),
       { consensus: true }
     );
     persistRelayTasks();
@@ -46319,8 +46914,29 @@ ${p.prompt}` });
 init_mcp_context();
 init_relay_cross_review();
 init_native_tasks();
+init_lifecycle_tasks();
 init_src3();
 init_src4();
+function scheduleSkillRunner(c, mainAgent) {
+  if (!c.skillEngine) return;
+  const skillEngine = c.skillEngine;
+  const registryGet = (id) => mainAgent.getAgentConfig(id);
+  const projectRoot = process.cwd();
+  const runRunner = async () => {
+    try {
+      const { runCheckEffectivenessForAllSkills: runCheckEffectivenessForAllSkills2 } = await Promise.resolve().then(() => (init_check_effectiveness_runner(), check_effectiveness_runner_exports));
+      await runCheckEffectivenessForAllSkills2({
+        skillEngine,
+        registryGet,
+        projectRoot
+      });
+    } catch (e) {
+      process.stderr.write(`[gossipcat] checkEffectiveness post-collect run failed: ${e.message}
+`);
+    }
+  };
+  trackLifecycleTask(Promise.resolve().then(runRunner));
+}
 var _autoResolverErrors = /* @__PURE__ */ new Set();
 var _autoResolverLockWarned = false;
 var CONSENSUS_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{8}$/;
@@ -46509,6 +47125,7 @@ ${t.skillWarnings.map((w) => `  - ${w}`).join("\n")}`;
   });
   let consensusReport = void 0;
   let provisionalSignalCount = 0;
+  let outerEffectiveRoots = resolutionRoots ?? [];
   const CONSENSUS_TIMEOUT_MS = 18e5;
   if (consensus && allResults.filter((r) => r.status === "completed").length >= 2) {
     const nativeAgentIds = /* @__PURE__ */ new Set();
@@ -46559,6 +47176,7 @@ ${t.skillWarnings.map((w) => `  - ${w}`).join("\n")}`;
         process.stderr.write(`[consensus] auto-discovery failed: ${err.message}
 `);
       }
+      outerEffectiveRoots = effectiveRoots;
       const verifierFs = new FileTools(new Sandbox(process.cwd()));
       const verifierGit = new GitTools(process.cwd());
       const verifierMemory = new MemorySearcher(process.cwd());
@@ -46831,6 +47449,7 @@ ${np.user}
               ctx.nativeTaskMap.delete(id);
             }
           }
+          scheduleSkillRunner(ctx, ctx.mainAgent);
           return { content: [{ type: "text", text: partialOutput }] };
         }
       }
@@ -46846,9 +47465,10 @@ ${np.user}
     try {
       const { writeFileSync: wfr, mkdirSync: mdr } = require("fs");
       const { join: jr } = require("path");
+      const { randomBytes: rb } = require("crypto");
       const reportsDir = jr(process.cwd(), ".gossip", "consensus-reports");
       mdr(reportsDir, { recursive: true });
-      const reportId = consensusReport.signals?.[0]?.consensusId || Date.now().toString();
+      const reportId = consensusReport.signals?.[0]?.consensusId || `${rb(4).toString("hex")}-${rb(4).toString("hex")}`;
       const reportPath = jr(reportsDir, `${reportId}.json`);
       const topic = allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
       wfr(reportPath, JSON.stringify({
@@ -46857,6 +47477,13 @@ ${np.user}
         topic,
         agentCount: consensusReport.agentCount,
         rounds: consensusReport.rounds,
+        // Persist resolutionRoots so the transport-failure detector
+        // (Path 2, spec docs/specs/2026-04-29-relay-worker-resolution-roots.md)
+        // can look up "did this round dispatch with resolutionRoots?" from a
+        // bare `consensus_id` derived from a `finding_id`. Empty array when
+        // none was passed — preserving the explicit "no roots" signal in the
+        // record.
+        resolutionRoots: outerEffectiveRoots.length > 0 ? [...outerEffectiveRoots] : [],
         confirmed: consensusReport.confirmed || [],
         disputed: consensusReport.disputed || [],
         unverified: consensusReport.unverified || [],
@@ -46870,7 +47497,12 @@ ${np.user}
         // round-trip through the JSON payload or the feature is invisible.
         ...consensusReport.authorDiagnostics ? { authorDiagnostics: consensusReport.authorDiagnostics } : {}
       }, null, 2));
-    } catch {
+    } catch (e) {
+      const reportIdForLog = consensusReport.signals?.[0]?.consensusId || "<unknown>";
+      process.stderr.write(
+        `[gossipcat] consensus-report write failed for ${reportIdForLog}: ${e.message ?? e}
+`
+      );
     }
   }
   if (consensusReport) {
@@ -47132,25 +47764,7 @@ ${gaps.map((g) => `  - ${g.agentId} needs "${g.category}" (score: ${g.score.toFi
     }
   } catch {
   }
-  if (ctx.skillEngine) {
-    const skillEngine = ctx.skillEngine;
-    const mainAgent = ctx.mainAgent;
-    const registryGet = (id) => mainAgent.getAgentConfig(id);
-    const projectRoot = process.cwd();
-    setImmediate(async () => {
-      try {
-        const { runCheckEffectivenessForAllSkills: runCheckEffectivenessForAllSkills2 } = await Promise.resolve().then(() => (init_check_effectiveness_runner(), check_effectiveness_runner_exports));
-        await runCheckEffectivenessForAllSkills2({
-          skillEngine,
-          registryGet,
-          projectRoot
-        });
-      } catch (e) {
-        process.stderr.write(`[gossipcat] checkEffectiveness post-collect run failed: ${e.message}
-`);
-      }
-    });
-  }
+  scheduleSkillRunner(ctx, ctx.mainAgent);
   try {
     const taskCount = ctx.mainAgent.getSessionGossip().length;
     const consensusCount = ctx.mainAgent.getSessionConsensusHistory().length;
@@ -47168,19 +47782,19 @@ REQUIRED_BEFORE_END: gossip_session_save() \u2014 ${taskCount} tasks, ${consensu
 init_relay_cross_review();
 
 // apps/cli/src/stickyPort.ts
-var import_fs66 = require("fs");
-var import_path68 = require("path");
+var import_fs69 = require("fs");
+var import_path71 = require("path");
 var import_net = require("net");
-var RELAY_STICKY_FILE = (0, import_path68.join)(".gossip", "relay.port");
-var HTTP_MCP_STICKY_FILE = (0, import_path68.join)(".gossip", "http-mcp.port");
+var RELAY_STICKY_FILE = (0, import_path71.join)(".gossip", "relay.port");
+var HTTP_MCP_STICKY_FILE = (0, import_path71.join)(".gossip", "http-mcp.port");
 function stickyPath(filename) {
-  return (0, import_path68.join)(process.cwd(), filename);
+  return (0, import_path71.join)(process.cwd(), filename);
 }
 function readStickyPort(filename) {
   const p = stickyPath(filename);
-  if (!(0, import_fs66.existsSync)(p)) return null;
+  if (!(0, import_fs69.existsSync)(p)) return null;
   try {
-    const raw = (0, import_fs66.readFileSync)(p, "utf-8").trim();
+    const raw = (0, import_fs69.readFileSync)(p, "utf-8").trim();
     const n = parseInt(raw, 10);
     if (!Number.isFinite(n) || n < 1 || n > 65535) return null;
     return n;
@@ -47192,8 +47806,8 @@ function writeStickyPort(filename, port) {
   if (!Number.isFinite(port) || port < 1 || port > 65535) return;
   const p = stickyPath(filename);
   try {
-    (0, import_fs66.mkdirSync)((0, import_path68.dirname)(p), { recursive: true });
-    (0, import_fs66.writeFileSync)(p, String(port), "utf-8");
+    (0, import_fs69.mkdirSync)((0, import_path71.dirname)(p), { recursive: true });
+    (0, import_fs69.writeFileSync)(p, String(port), "utf-8");
   } catch {
   }
 }
@@ -47257,12 +47871,12 @@ function buildDashboardAdvisory(input) {
 }
 
 // apps/cli/src/native-agent-cache.ts
-var import_fs67 = require("fs");
-var import_path69 = require("path");
+var import_fs70 = require("fs");
+var import_path72 = require("path");
 var realFs = {
-  existsSync: import_fs67.existsSync,
-  readFileSync: import_fs67.readFileSync,
-  statSync: (p) => ({ mtimeMs: (0, import_fs67.statSync)(p).mtimeMs })
+  existsSync: import_fs70.existsSync,
+  readFileSync: import_fs70.readFileSync,
+  statSync: (p) => ({ mtimeMs: (0, import_fs70.statSync)(p).mtimeMs })
 };
 function modelTierFromId(modelId) {
   if (modelId.includes("opus")) return "opus";
@@ -47270,8 +47884,8 @@ function modelTierFromId(modelId) {
   return "sonnet";
 }
 function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs5 = realFs) {
-  const claudeAgentPath = (0, import_path69.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
-  const instrPath = (0, import_path69.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+  const claudeAgentPath = (0, import_path72.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
+  const instrPath = (0, import_path72.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
   const prev = cache2.get(ac.id);
   let sourcePath = null;
   let stripFrontmatter = false;
@@ -47330,16 +47944,16 @@ function refreshNativeAgentFromDisk(ac, cache2, projectRoot, fs5 = realFs) {
 }
 
 // apps/cli/src/rules-content.ts
-var import_fs68 = require("fs");
-var import_path70 = require("path");
+var import_fs71 = require("fs");
+var import_path73 = require("path");
 var AGENT_LIST_PLACEHOLDER = "{{AGENT_LIST}}";
 function resolveRulesPath() {
   const candidates = [
-    (0, import_path70.join)(process.cwd(), "docs", "RULES.md"),
-    (0, import_path70.join)(__dirname, "..", "docs", "RULES.md"),
-    (0, import_path70.join)(__dirname, "docs", "RULES.md")
+    (0, import_path73.join)(process.cwd(), "docs", "RULES.md"),
+    (0, import_path73.join)(__dirname, "..", "docs", "RULES.md"),
+    (0, import_path73.join)(__dirname, "docs", "RULES.md")
   ];
-  return candidates.find((p) => (0, import_fs68.existsSync)(p)) ?? null;
+  return candidates.find((p) => (0, import_fs71.existsSync)(p)) ?? null;
 }
 function generateRulesContent(agentList) {
   const rulesPath = resolveRulesPath();
@@ -47348,7 +47962,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_fs68.readFileSync)(rulesPath, "utf-8");
+  const template = (0, import_fs71.readFileSync)(rulesPath, "utf-8");
   return template.split(AGENT_LIST_PLACEHOLDER).join(agentList);
 }
 
@@ -47364,6 +47978,23 @@ function formatDropReceipt(drops) {
 ${lines.join("\n")}`;
 }
 
+// apps/cli/src/shutdown.ts
+async function shutdownOnSignal(signal, deps) {
+  try {
+    await deps.drainLifecycleTasks();
+  } catch {
+  }
+  deps.eviction.stop();
+  process.stderr.write(`[relay] shutdown reason=${signal} pid=${deps.pid}
+`);
+  try {
+    await deps.relayStop();
+  } catch {
+  }
+  deps.cleanupPid();
+  deps.exit(0);
+}
+
 // apps/cli/src/mcp-server-sdk.ts
 var import_os5 = require("os");
 
@@ -47419,17 +48050,17 @@ function filterWatchEvents(rawJsonl, opts) {
 }
 
 // apps/cli/src/mcp-server-sdk.ts
-var gossipDir = (0, import_path74.join)(process.cwd(), ".gossip");
+var gossipDir = (0, import_path77.join)(process.cwd(), ".gossip");
 try {
-  (0, import_fs72.mkdirSync)(gossipDir, { recursive: true });
+  (0, import_fs75.mkdirSync)(gossipDir, { recursive: true });
 } catch {
 }
-var logStream = (0, import_fs72.createWriteStream)((0, import_path74.join)(gossipDir, "mcp.log"), { flags: "a" });
+var logStream = (0, import_fs75.createWriteStream)((0, import_path77.join)(gossipDir, "mcp.log"), { flags: "a" });
 process.stderr.write = ((chunk, ...args) => {
   return logStream.write(chunk, ...args);
 });
 function memoryDirForProject(cwd) {
-  return (0, import_path74.join)((0, import_os5.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
+  return (0, import_path77.join)((0, import_os5.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
 }
 function detectEnvironment() {
   if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE_ENTRYPOINT) {
@@ -47453,9 +48084,9 @@ var planExecutionDepth = 0;
 var _pendingSessionData = /* @__PURE__ */ new Map();
 async function writeArtifactsInOrder(a) {
   const { writeFileSync: wf, mkdirSync: md } = await import("fs");
-  const { dirname: dirname16 } = await import("path");
+  const { dirname: dirname17 } = await import("path");
   try {
-    md(dirname16(a.nextSessionPath), { recursive: true });
+    md(dirname17(a.nextSessionPath), { recursive: true });
     wf(a.nextSessionPath, a.nextSessionContent);
   } catch (err) {
     process.stderr.write(`[gossipcat] next-session.md write FAILED: ${err.message}
@@ -47463,7 +48094,7 @@ async function writeArtifactsInOrder(a) {
     throw err;
   }
   try {
-    md(dirname16(a.knowledgePath), { recursive: true });
+    md(dirname17(a.knowledgePath), { recursive: true });
     wf(a.knowledgePath, a.knowledgeContent);
   } catch (err) {
     process.stderr.write(`[gossipcat] cognitive knowledge write failed: ${err.message}
@@ -47484,14 +48115,14 @@ var _pendingPlanData = /* @__PURE__ */ new Map();
 var _utilityGuardSnapshots = /* @__PURE__ */ new Map();
 var _modules = null;
 function lookupFindingSeverity(findingId, projectRoot) {
-  const { existsSync: existsSync61, readdirSync: readdirSync18, readFileSync: readFileSync59 } = require("fs");
-  const { join: join70 } = require("path");
-  const reportsDir = join70(projectRoot, ".gossip", "consensus-reports");
-  if (!existsSync61(reportsDir)) return null;
+  const { existsSync: existsSync64, readdirSync: readdirSync18, readFileSync: readFileSync61 } = require("fs");
+  const { join: join73 } = require("path");
+  const reportsDir = join73(projectRoot, ".gossip", "consensus-reports");
+  if (!existsSync64(reportsDir)) return null;
   try {
     const files = readdirSync18(reportsDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const report = JSON.parse(readFileSync59(join70(reportsDir, file2), "utf-8"));
+      const report = JSON.parse(readFileSync61(join73(reportsDir, file2), "utf-8"));
       for (const bucket of ["confirmed", "disputed", "unverified", "unique"]) {
         for (const finding of report[bucket] || []) {
           if (finding.id === findingId && finding.severity) {
@@ -47569,7 +48200,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_path74.join)(process.cwd(), ".gossip", "relay.pid");
+  const pidFile = (0, import_path77.join)(process.cwd(), ".gossip", "relay.pid");
   if (pidExists(pidFile)) {
     const oldPid = parseInt(readPid(pidFile, "utf-8").trim(), 10);
     if (!isNaN(oldPid) && oldPid !== process.pid) {
@@ -47613,31 +48244,25 @@ async function doBoot() {
   process.once("exit", cleanupPid);
   let shuttingDown = false;
   const eviction = scheduleNativeTaskEviction();
+  const { installLifecycleDrainHandlers: installLifecycleDrainHandlers2, drainLifecycleTasks: drainLifecycleTasks2 } = await Promise.resolve().then(() => (init_lifecycle_tasks(), lifecycle_tasks_exports));
+  installLifecycleDrainHandlers2();
+  const shutdownDeps = {
+    eviction,
+    relayStop: () => ctx.relay.stop(),
+    cleanupPid,
+    drainLifecycleTasks: () => drainLifecycleTasks2(),
+    exit: (code) => process.exit(code),
+    pid: process.pid
+  };
   process.once("SIGTERM", async () => {
     if (shuttingDown) return;
     shuttingDown = true;
-    eviction.stop();
-    process.stderr.write(`[relay] shutdown reason=SIGTERM pid=${process.pid}
-`);
-    try {
-      await ctx.relay.stop();
-    } catch {
-    }
-    cleanupPid();
-    process.exit(0);
+    await shutdownOnSignal("SIGTERM", shutdownDeps);
   });
   process.once("SIGINT", async () => {
     if (shuttingDown) return;
     shuttingDown = true;
-    eviction.stop();
-    process.stderr.write(`[relay] shutdown reason=SIGINT pid=${process.pid}
-`);
-    try {
-      await ctx.relay.stop();
-    } catch {
-    }
-    cleanupPid();
-    process.exit(0);
+    await shutdownOnSignal("SIGINT", shutdownDeps);
   });
   if (ctx.relay.dashboardUrl) {
     process.stderr.write(`[gossipcat] \u{1F310} Dashboard: ${ctx.relay.dashboardUrl} (key: ${ctx.relay.dashboardKey})
@@ -47685,10 +48310,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: existsSync61, readFileSync: readFileSync59 } = require("fs");
-    const { join: join70 } = require("path");
-    const instructionsPath = join70(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
-    const baseInstructions = existsSync61(instructionsPath) ? readFileSync59(instructionsPath, "utf-8") : "";
+    const { existsSync: existsSync64, readFileSync: readFileSync61 } = require("fs");
+    const { join: join73 } = require("path");
+    const instructionsPath = join73(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
+    const baseInstructions = existsSync64(instructionsPath) ? readFileSync61(instructionsPath, "utf-8") : "";
     const identity = ctx.identityRegistry.get(ac.id);
     const identityBlock = identity ? m.formatIdentityBlock(identity) + "\n" : "";
     const instructions = (identityBlock + baseInstructions).trim() || void 0;
@@ -48360,13 +48985,26 @@ server.tool(
         if (!agent_id || !task) {
           return { content: [{ type: "text", text: 'Error: mode:"single" requires agent_id and task.' }] };
         }
-        return handleDispatchSingle(agent_id, task, write_mode, scope, timeout_ms, plan_id, step);
+        return handleDispatchSingle(
+          agent_id,
+          task,
+          write_mode,
+          scope,
+          timeout_ms,
+          plan_id,
+          step,
+          validatedDispatchRoots.length > 0 ? validatedDispatchRoots : void 0
+        );
       }
       if (mode === "parallel") {
         if (!tasks || tasks.length === 0) {
           return { content: [{ type: "text", text: 'Error: mode:"parallel" requires a non-empty tasks array.' }] };
         }
-        return handleDispatchParallel(tasks, false);
+        return handleDispatchParallel(
+          tasks,
+          false,
+          validatedDispatchRoots.length > 0 ? validatedDispatchRoots : void 0
+        );
       }
       if (mode === "consensus") {
         if (!tasks || tasks.length === 0) {
@@ -48484,9 +49122,26 @@ server.tool(
       lines.push(`  HTTP MCP: :${ctx.httpMcpPort}/mcp${ctx.httpMcpPortSource === "sticky" ? " (sticky)" : ""}`);
     }
     try {
-      const { readFileSync: readFileSync59 } = await import("fs");
-      const quotaPath = (0, import_path74.join)(process.cwd(), ".gossip", "quota-state.json");
-      const quotaRaw = readFileSync59(quotaPath, "utf8");
+      const { readFileSync: rfHealth } = await import("fs");
+      const healthPath = (0, import_path77.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;
+      if (Number.isFinite(lastMs)) {
+        const ago = Date.now() - lastMs;
+        const sec = Math.round(ago / 1e3);
+        const rel = sec < 60 ? `${sec}s` : sec < 3600 ? `${Math.round(sec / 60)}m` : `${Math.round(sec / 3600)}h`;
+        const t = h.transitions || {};
+        const totalT = (t.passed ?? 0) + (t.failed ?? 0) + (t.flagged_for_manual_review ?? 0) + (t.inconclusive ?? 0) + (t.pending ?? 0);
+        lines.push(`  Skill graduation: last run ${rel} ago (${h.skills_evaluated ?? 0} skills, ${totalT} transitions)`);
+      }
+    } catch {
+      lines.push("  Skill graduation: never run since session start (expected after first gossip_collect)");
+    }
+    try {
+      const { readFileSync: readFileSync61 } = await import("fs");
+      const quotaPath = (0, import_path77.join)(process.cwd(), ".gossip", "quota-state.json");
+      const quotaRaw = readFileSync61(quotaPath, "utf8");
       const quotaState = JSON.parse(quotaRaw);
       for (const [provider, state] of Object.entries(quotaState)) {
         const now = Date.now();
@@ -48500,17 +49155,17 @@ server.tool(
     } catch {
     }
     try {
-      const { readFileSync: readFileSync59, readdirSync: readdirSync18, statSync: statSync23 } = await import("fs");
-      const reportsDir = (0, import_path74.join)(process.cwd(), ".gossip", "consensus-reports");
-      const perfPath = (0, import_path74.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
+      const { readFileSync: readFileSync61, readdirSync: readdirSync18, statSync: statSync24 } = await import("fs");
+      const reportsDir = (0, import_path77.join)(process.cwd(), ".gossip", "consensus-reports");
+      const perfPath = (0, import_path77.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
       const WINDOW_MS2 = 24 * 60 * 60 * 1e3;
       const now = Date.now();
       const recentReports = [];
       try {
         for (const fname of readdirSync18(reportsDir)) {
           if (!fname.endsWith(".json")) continue;
-          const fpath = (0, import_path74.join)(reportsDir, fname);
-          const st = statSync23(fpath);
+          const fpath = (0, import_path77.join)(reportsDir, fname);
+          const st = statSync24(fpath);
           if (now - st.mtimeMs > WINDOW_MS2) continue;
           recentReports.push({ id: fname.replace(/\.json$/, ""), mtimeMs: st.mtimeMs });
         }
@@ -48519,7 +49174,7 @@ server.tool(
       if (recentReports.length > 0) {
         const covered = /* @__PURE__ */ new Set();
         try {
-          const perfRaw = readFileSync59(perfPath, "utf8");
+          const perfRaw = readFileSync61(perfPath, "utf8");
           for (const line of perfRaw.split("\n")) {
             if (!line) continue;
             try {
@@ -48869,8 +49524,8 @@ server.tool(
       }
       return { content: [{ type: "text", text: results.join("\n") }] };
     }
-    const { writeFileSync: writeFileSync25, mkdirSync: mkdirSync30, existsSync: existsSync61 } = require("fs");
-    const { join: join70 } = require("path");
+    const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync33, existsSync: existsSync64 } = require("fs");
+    const { join: join73 } = require("path");
     const root = process.cwd();
     const CLAUDE_MODEL_MAP2 = {
       opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -48884,8 +49539,8 @@ server.tool(
     let existingAgents = {};
     if (mode === "merge") {
       try {
-        const { readFileSync: readFileSync59 } = require("fs");
-        const existing = JSON.parse(readFileSync59(join70(root, ".gossip", "config.json"), "utf-8"));
+        const { readFileSync: readFileSync61 } = require("fs");
+        const existing = JSON.parse(readFileSync61(join73(root, ".gossip", "config.json"), "utf-8"));
         existingAgents = existing.agents || {};
       } catch {
       }
@@ -48916,9 +49571,9 @@ server.tool(
           "",
           body
         ].join("\n");
-        const agentsDir = join70(root, ".claude", "agents");
-        mkdirSync30(agentsDir, { recursive: true });
-        writeFileSync25(join70(agentsDir, `${agent.id}.md`), md, "utf-8");
+        const agentsDir = join73(root, ".claude", "agents");
+        mkdirSync33(agentsDir, { recursive: true });
+        writeFileSync26(join73(agentsDir, `${agent.id}.md`), md, "utf-8");
         nativeCreated.push(agent.id);
         configAgents[agent.id] = {
           provider: mapped.provider,
@@ -48936,8 +49591,8 @@ server.tool(
           errors.push(`${agent.id}: custom agent requires "custom_model" field`);
           continue;
         }
-        const nativeFile = join70(root, ".claude", "agents", `${agent.id}.md`);
-        const wasNative = existingAgents[agent.id]?.native || existsSync61(nativeFile);
+        const nativeFile = join73(root, ".claude", "agents", `${agent.id}.md`);
+        const wasNative = existingAgents[agent.id]?.native || existsSync64(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;
@@ -48951,9 +49606,9 @@ server.tool(
         };
         customCreated.push(agent.id);
         if (agent.instructions) {
-          const instrDir = join70(root, ".gossip", "agents", agent.id);
-          mkdirSync30(instrDir, { recursive: true });
-          writeFileSync25(join70(instrDir, "instructions.md"), agent.instructions, "utf-8");
+          const instrDir = join73(root, ".gossip", "agents", agent.id);
+          mkdirSync33(instrDir, { recursive: true });
+          writeFileSync26(join73(instrDir, "instructions.md"), agent.instructions, "utf-8");
         }
       }
     }
@@ -48967,8 +49622,8 @@ server.tool(
     } catch (err) {
       return { content: [{ type: "text", text: `Invalid config: ${err.message}` }] };
     }
-    mkdirSync30(join70(root, ".gossip"), { recursive: true });
-    writeFileSync25(join70(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
+    mkdirSync33(join73(root, ".gossip"), { recursive: true });
+    writeFileSync26(join73(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
     let hookSummary = "";
     try {
       const { installWorktreeSandboxHook: installWorktreeSandboxHook2, writeOrchestratorRoleMarker: writeOrchestratorRoleMarker2 } = (init_src4(), __toCommonJS(src_exports3));
@@ -49007,10 +49662,10 @@ server.tool(
       }
     }
     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 = join70(root, env.rulesDir);
-    const rulesFile = join70(root, env.rulesFile);
-    mkdirSync30(rulesDir, { recursive: true });
-    writeFileSync25(rulesFile, generateRulesContent(agentList));
+    const rulesDir = join73(root, env.rulesDir);
+    const rulesFile = join73(root, env.rulesFile);
+    mkdirSync33(rulesDir, { recursive: true });
+    writeFileSync26(rulesFile, generateRulesContent(agentList));
     const lines = [`Host: ${env.host}`, ""];
     if (nativeCreated.length > 0) {
       lines.push(`Native agents created (${nativeCreated.length}):`);
@@ -49297,11 +49952,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: readFileSync59, existsSync: existsSync61, writeFileSync: writeFileSync25, renameSync: renameSync8 } = require("fs");
-      if (!existsSync61(findingsPath)) {
+      const { readFileSync: readFileSync61, existsSync: existsSync64, writeFileSync: writeFileSync26, renameSync: renameSync9 } = require("fs");
+      if (!existsSync64(findingsPath)) {
         return { content: [{ type: "text", text: `No implementation-findings.jsonl found at ${findingsPath}` }] };
       }
-      const lines = readFileSync59(findingsPath, "utf-8").split("\n");
+      const lines = readFileSync61(findingsPath, "utf-8").split("\n");
       let matched = false;
       let alreadyTarget = false;
       let matchedEntry = null;
@@ -49357,8 +50012,8 @@ The original signal remains in the audit log but will be excluded from scoring.`
       }
       try {
         const tmp = findingsPath + ".tmp." + Date.now();
-        writeFileSync25(tmp, newLines.join("\n"));
-        renameSync8(tmp, findingsPath);
+        writeFileSync26(tmp, newLines.join("\n"));
+        renameSync9(tmp, findingsPath);
       } catch (err) {
         return { content: [{ type: "text", text: `Failed to write findings: ${err.message}` }] };
       }
@@ -49389,19 +50044,19 @@ 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: readFileSync59 } = await import("fs");
-        const { join: join70 } = await import("path");
-        const reportPath = join70(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
+        const { readFileSync: readFileSync61 } = await import("fs");
+        const { join: join73 } = await import("path");
+        const reportPath = join73(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
         let report;
         try {
-          report = JSON.parse(readFileSync59(reportPath, "utf-8"));
+          report = JSON.parse(readFileSync61(reportPath, "utf-8"));
         } catch {
           return { content: [{ type: "text", text: `Error: consensus report not found: ${consensus_id}` }] };
         }
         const existingFindingIds = /* @__PURE__ */ new Set();
         try {
-          const perfPath = join70(process.cwd(), ".gossip", "agent-performance.jsonl");
-          const lines = readFileSync59(perfPath, "utf-8").split("\n").filter(Boolean);
+          const perfPath = join73(process.cwd(), ".gossip", "agent-performance.jsonl");
+          const lines = readFileSync61(perfPath, "utf-8").split("\n").filter(Boolean);
           for (const line of lines) {
             try {
               const rec = JSON.parse(line);
@@ -49569,6 +50224,41 @@ Uncategorized finding_ids: ${uncategorized.join(", ")}`;
           timestamp: ts2
         };
       });
+      try {
+        const { maybeRewriteHallucinationToTransportFailure: maybeRewriteHallucinationToTransportFailure2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
+        const { existsSync: nativeExists } = require("fs");
+        const { join: nativeJoin } = require("path");
+        const nativeFileCache = /* @__PURE__ */ new Map();
+        const isNativeAgent = (agentId) => {
+          if (ctx.nativeAgentConfigs.has(agentId)) return true;
+          const cached3 = nativeFileCache.get(agentId);
+          if (cached3 !== void 0) return cached3;
+          let onDisk = false;
+          try {
+            onDisk = nativeExists(nativeJoin(process.cwd(), ".claude", "agents", `${agentId}.md`));
+          } catch {
+            onDisk = false;
+          }
+          nativeFileCache.set(agentId, onDisk);
+          return onDisk;
+        };
+        for (let i = 0; i < formatted.length; i++) {
+          const s = formatted[i];
+          if (s.type !== "consensus") continue;
+          if (s.signal !== "hallucination_caught") continue;
+          const rewritten = maybeRewriteHallucinationToTransportFailure2(
+            process.cwd(),
+            s,
+            isNativeAgent
+          );
+          if (rewritten !== s) {
+            formatted[i] = rewritten;
+          }
+        }
+      } catch (err) {
+        process.stderr.write(`[gossip_signals] transport-failure detector failed: ${err.message}
+`);
+      }
       const { extractCategories: extractCategories2, logUncategorizedFinding: logUncategorizedFinding2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
       const droppedNoCategory = [];
       const categoryEnforced = formatted.filter((s, i) => {
@@ -49602,9 +50292,9 @@ Uncategorized finding_ids: ${uncategorized.join(", ")}`;
       const existingFindingIds = /* @__PURE__ */ new Set();
       const existingKeyToFindingId = /* @__PURE__ */ new Map();
       try {
-        const { readFileSync: readFileSync59 } = await import("fs");
+        const { readFileSync: readFileSync61 } = await import("fs");
         const perfPath = require("path").join(process.cwd(), ".gossip", "agent-performance.jsonl");
-        const lines = readFileSync59(perfPath, "utf-8").split("\n").filter(Boolean);
+        const lines = readFileSync61(perfPath, "utf-8").split("\n").filter(Boolean);
         for (const line of lines) {
           try {
             const rec = JSON.parse(line);
@@ -50361,16 +51051,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: writeFileSync25, mkdirSync: mkdirSync30, existsSync: existsSync61, readFileSync: readFileSync59 } = require("fs");
-      const { join: join70 } = require("path");
-      const dir = join70(process.cwd(), ".gossip", "skills");
-      mkdirSync30(dir, { recursive: true });
+      const { writeFileSync: writeFileSync26, mkdirSync: mkdirSync33, existsSync: existsSync64, readFileSync: readFileSync61 } = require("fs");
+      const { join: join73 } = require("path");
+      const dir = join73(process.cwd(), ".gossip", "skills");
+      mkdirSync33(dir, { recursive: true });
       const results = [];
       for (const sk of skills) {
         const name = normalizeSkillName2(sk.name);
-        const filePath = join70(dir, `${name}.md`);
-        if (existsSync61(filePath)) {
-          const existing = readFileSync59(filePath, "utf-8");
+        const filePath = join73(dir, `${name}.md`);
+        if (existsSync64(filePath)) {
+          const existing = readFileSync61(filePath, "utf-8");
           const fm = parseSkillFrontmatter2(existing);
           if (fm) {
             if (fm.generated_by === "manual") {
@@ -50387,7 +51077,7 @@ ${preview}` }]
             }
           }
         }
-        writeFileSync25(filePath, sk.content);
+        writeFileSync26(filePath, sk.content);
         tracker.recordResolution(name);
         results.push(`Created .gossip/skills/${name}.md`);
       }
@@ -51100,10 +51790,10 @@ server.tool(
     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 { readFileSync: readFileSync59, existsSync: existsSync61 } = await import("node:fs");
-    const { join: join70 } = await import("node:path");
-    const perfPath = join70(process.cwd(), ".gossip", "agent-performance.jsonl");
-    const raw = existsSync61(perfPath) ? readFileSync59(perfPath, "utf-8") : "";
+    const { readFileSync: readFileSync61, existsSync: existsSync64 } = await import("node:fs");
+    const { join: join73 } = await import("node:path");
+    const perfPath = join73(process.cwd(), ".gossip", "agent-performance.jsonl");
+    const raw = existsSync64(perfPath) ? readFileSync61(perfPath, "utf-8") : "";
     const result = filterWatchEvents(raw, { cursor, maxEvents: max_events });
     return { content: [{ type: "text", text: JSON.stringify(result) }] };
   }