gossipcat 0.1.2 → 0.2.0

package/dist-mcp/mcp-server.js

@@ -55,6 +55,9 @@ var init_mcp_context = __esm({
       pendingConsensusRounds: /* @__PURE__ */ new Map(),
       nativeUtilityConfig: null,
       mainProvider: "google",
+      httpMcpPort: null,
+      relayPortSource: null,
+      httpMcpPortSource: null,
       booted: false,
       boot: async () => {
         throw new Error("boot not initialized");
@@ -9219,6 +9222,17 @@ function loadSkills(agentId, skills, projectRoot, index, task) {
   for (const skill of effectiveSkills) {
     const content = resolveSkill(agentId, skill, projectRoot);
     if (!content) continue;
+    const frontmatterStatus = parseSkillFrontmatter(content)?.status;
+    if (frontmatterStatus === "failed" || frontmatterStatus === "silent_skill") {
+      process.stderr.write(`[gossipcat] Skipping ${frontmatterStatus} skill ${agentId}/${skill} from injection
+`);
+      dropped.push(skill);
+      continue;
+    }
+    if (frontmatterStatus === "flagged_for_manual_review") {
+      process.stderr.write(`[gossipcat] Injecting flagged_for_manual_review skill ${agentId}/${skill} \u2014 manual review recommended
+`);
+    }
     const mode = index?.getSkillMode(agentId, skill) ?? "permanent";
     if (mode === "permanent") {
       permanent.push({ name: skill, content });
@@ -11310,6 +11324,7 @@ var init_performance_reader = __esm({
     "use strict";
     import_fs15 = require("fs");
     import_path17 = require("path");
+    init_skill_name();
     CIRCUIT_BREAKER_THRESHOLD = 3;
     NEGATIVE_SIGNALS = /* @__PURE__ */ new Set(["hallucination_caught", "disagreement", "unique_unconfirmed"]);
     SIGNAL_EXPIRY_DAYS = 30;
@@ -11393,9 +11408,10 @@ var init_performance_reader = __esm({
       getCountersSince(agentId, category, sinceMs) {
         const allSignals = this.readSignalsRaw();
         const counters = { correct: 0, hallucinated: 0 };
+        const normalizedTarget = normalizeSkillName(category);
         for (const s of allSignals) {
           if (s.agentId !== agentId) continue;
-          if (s.category !== category) continue;
+          if (normalizeSkillName(s.category ?? "") !== normalizedTarget) continue;
           const ts = s.timestamp ? new Date(s.timestamp).getTime() : 0;
           if (!isFinite(ts) || ts === 0 || ts < sinceMs) continue;
           switch (s.signal) {
@@ -11670,6 +11686,7 @@ var init_performance_reader = __esm({
             const timeFreshness = Math.pow(0.5, daysSinceLastSignal / halfLife);
             reliability = 0.5 + (reliability - 0.5) * timeFreshness;
           }
+          const MIN_CATEGORY_N = 5;
           const categoryAccuracy = {};
           const allCategories = /* @__PURE__ */ new Set([
             ...Object.keys(a.categoryCorrect),
@@ -11678,7 +11695,7 @@ var init_performance_reader = __esm({
           for (const cat of allCategories) {
             const c = a.categoryCorrect[cat] ?? 0;
             const h = a.categoryHallucinated[cat] ?? 0;
-            if (c + h > 0) categoryAccuracy[cat] = c / (c + h);
+            if (c + h >= MIN_CATEGORY_N) categoryAccuracy[cat] = c / (c + h);
           }
           const consec = consecutiveFailures.get(id) || 0;
           scores.set(id, {
@@ -15588,8 +15605,8 @@ Keep it SHORT \u2014 under 30 lines. This is a working document, not a design do
         ]);
         const specContent = response.text || "";
         try {
-          const { mkdirSync: mkdirSync21, writeFileSync: writeFS } = require("fs");
-          mkdirSync21((0, import_path23.join)(this.projectRoot, ".gossip"), { recursive: true });
+          const { mkdirSync: mkdirSync22, writeFileSync: writeFS } = require("fs");
+          mkdirSync22((0, import_path23.join)(this.projectRoot, ".gossip"), { recursive: true });
           writeFS(specPath, specContent, "utf-8");
         } catch (err) {
           return { text: `Spec generated but failed to save: ${err.message}
@@ -16424,8 +16441,8 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync43, readFileSync: readFileSync40 } = await import("fs");
-        const { join: join48 } = await import("path");
+        const { existsSync: existsSync44, readFileSync: readFileSync41 } = await import("fs");
+        const { join: join49 } = await import("path");
         for (const config2 of this.registry.getAll()) {
           if (config2.native) continue;
           if (this.workers.has(config2.id)) continue;
@@ -16434,8 +16451,8 @@ message: Your question?
             apiKey = await this.keyProviderFn(config2.provider) ?? void 0;
           }
           const llm = createProvider(config2.provider, config2.model, apiKey);
-          const instructionsPath = join48(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
-          const instructions = existsSync43(instructionsPath) ? readFileSync40(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join49(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
+          const instructions = existsSync44(instructionsPath) ? readFileSync41(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();
@@ -16617,16 +16634,16 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync43, readFileSync: readFileSync40 } = await import("fs");
-        const { join: join48 } = await import("path");
+        const { existsSync: existsSync44, readFileSync: readFileSync41 } = await import("fs");
+        const { join: join49 } = await import("path");
         let added = 0;
         for (const ac of this.registry.getAll()) {
           if (ac.native) continue;
           if (this.workers.has(ac.id)) continue;
           const key = await keyProvider(ac.provider);
           const llm = createProvider(ac.provider, ac.model, key ?? void 0, void 0, ac.base_url);
-          const instructionsPath = join48(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
-          const instructions = existsSync43(instructionsPath) ? readFileSync40(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join49(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+          const instructions = existsSync44(instructionsPath) ? readFileSync41(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();
@@ -18398,7 +18415,13 @@ NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
         this.projectRoot = projectRoot;
       }
       techStackCache = void 0;
-      async generate(agentId, category) {
+      /**
+       * Build the LLM prompt strings and metadata needed to generate a skill file.
+       * Separated from generate() so callers (e.g. the native-utility re-entry path)
+       * can obtain the prompt, dispatch it externally, and later call saveFromRaw()
+       * with the result — without re-running the expensive data-gathering step.
+       */
+      async buildPrompt(agentId, category) {
         if (!SAFE_NAME.test(agentId)) {
           throw new Error(`Invalid agent_id: "${agentId}". Must be lowercase alphanumeric with hyphens/underscores.`);
         }
@@ -18437,10 +18460,13 @@ ${techStack}
         const totalDispatches = agentScoreData?.totalSignals ?? 0;
         const categoryConfirmations = findings.filter((f) => f.agentId === agentId).length;
         const baselineRate = totalDispatches > 0 ? categoryConfirmations / totalDispatches : 0;
-        const messages = [
-          {
-            role: "system",
-            content: `You are a senior prompt engineer who builds skill files for AI code review agents. Your skills are injected into agent system prompts at dispatch time \u2014 every word costs tokens and shapes behavior. You write concise, opinionated methodology that changes how an agent thinks about a specific class of problems.
+        const lifetime = this.perfReader.getCountersSince(agentId, category, 0);
+        const baseline_accuracy_correct = lifetime.correct;
+        const baseline_accuracy_hallucinated = lifetime.hallucinated;
+        const bound_at = (/* @__PURE__ */ new Date()).toISOString();
+        const skillName = normalizeSkillName(category);
+        const skillPath = (0, import_path31.join)(this.projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
+        const system = `You are a senior prompt engineer who builds skill files for AI code review agents. Your skills are injected into agent system prompts at dispatch time \u2014 every word costs tokens and shapes behavior. You write concise, opinionated methodology that changes how an agent thinks about a specific class of problems.
 
 Your output quality is measured by:
 1. **Relevance** \u2014 every check must apply to THIS project's tech stack. Generic checklists are waste.
@@ -18452,11 +18478,8 @@ Study this reference skill \u2014 it represents the quality bar:
 
 <reference_skill>
 ${template}
-</reference_skill>`
-          },
-          {
-            role: "user",
-            content: `Generate a skill file for agent "${agentId}" to improve its "${category}" review performance.
+</reference_skill>`;
+        const user = `Generate a skill file for agent "${agentId}" to improve its "${category}" review performance.
 
 <project_context>
 ${projectContext || "No project context available."}
@@ -18487,27 +18510,42 @@ Requirements:
 - Keep under 150 lines
 - CRITICAL: Tailor ALL content to the project's actual tech stack (see <tech_stack>). Only include checks relevant to technologies the project uses. If the project has no SQL database, do NOT mention SQL injection. If no HTML rendering, do NOT mention XSS. Generic security checklists waste agent prompt tokens.
 - Reference actual project file paths and patterns from findings and context
-- Use bullet lists instead of markdown tables for Anti-Patterns (tables render poorly in agent prompts)`
-          }
-        ];
-        const response = await this.llm.generate(messages, { temperature: 0.3 });
-        const content = response.text || "";
-        let cleaned = content.trim();
+- Use bullet lists instead of markdown tables for Anti-Patterns (tables render poorly in agent prompts)`;
+        return { system, user, skillName, skillPath, baseline_accuracy_correct, baseline_accuracy_hallucinated, bound_at };
+      }
+      /**
+       * Persist a raw LLM-generated skill markdown string to disk.
+       * Mirrors the post-LLM steps from generate(): code-fence stripping,
+       * validation, snapshot-field injection, and atomic file write.
+       *
+       * Called by the native-utility re-entry path after gossip_relay delivers
+       * the agent output back to the orchestrator.
+       */
+      saveFromRaw(_agentId, _category, rawMarkdown, meta3) {
+        let cleaned = rawMarkdown.trim();
         if (cleaned.startsWith("```")) {
           cleaned = cleaned.replace(/^```\w*\n/, "").replace(/\n```\s*$/, "").trim();
         }
         this.validateSkillContent(cleaned);
-        const lifetime = this.perfReader.getCountersSince(agentId, category, 0);
-        const baseline_accuracy_correct = lifetime.correct;
-        const baseline_accuracy_hallucinated = lifetime.hallucinated;
-        const bound_at = (/* @__PURE__ */ new Date()).toISOString();
-        cleaned = this.injectSnapshotFields(cleaned, { baseline_accuracy_correct, baseline_accuracy_hallucinated, bound_at });
-        const skillName = normalizeSkillName(category);
-        const skillDir = (0, import_path31.join)(this.projectRoot, ".gossip", "agents", agentId, "skills");
+        cleaned = this.injectSnapshotFields(cleaned, {
+          baseline_accuracy_correct: meta3.baseline_accuracy_correct,
+          baseline_accuracy_hallucinated: meta3.baseline_accuracy_hallucinated,
+          bound_at: meta3.bound_at
+        });
+        const skillDir = (0, import_path31.join)(this.projectRoot, ".gossip", "agents", _agentId, "skills");
         (0, import_fs29.mkdirSync)(skillDir, { recursive: true });
-        const skillPath = (0, import_path31.join)(skillDir, `${skillName}.md`);
-        (0, import_fs29.writeFileSync)(skillPath, cleaned);
-        return { path: skillPath, content: cleaned };
+        (0, import_fs29.writeFileSync)(meta3.skillPath, cleaned);
+        return { path: meta3.skillPath, content: cleaned };
+      }
+      async generate(agentId, category) {
+        const promptData = await this.buildPrompt(agentId, category);
+        const messages = [
+          { role: "system", content: promptData.system },
+          { role: "user", content: promptData.user }
+        ];
+        const response = await this.llm.generate(messages, { temperature: 0.3 });
+        const content = response.text || "";
+        return this.saveFromRaw(agentId, category, content, promptData);
       }
       /**
        * Post-processes LLM-generated skill content to inject or overwrite snapshot fields
@@ -19425,11 +19463,11 @@ function startConsensusTimeout(consensusId) {
       const allEntries = [...snapshot.relayCrossReviewEntries, ...snapshot.nativeCrossReviewEntries];
       const report = await engine.synthesizeWithCrossReview(snapshot.allResults, allEntries, consensusId, snapshot.relayCrossReviewSkipped);
       try {
-        const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21 } = require("fs");
-        const { join: join48 } = require("path");
-        const reportsDir = join48(process.cwd(), ".gossip", "consensus-reports");
-        mkdirSync21(reportsDir, { recursive: true });
-        writeFileSync17(join48(reportsDir, `${consensusId}.json`), JSON.stringify({
+        const { writeFileSync: writeFileSync18, mkdirSync: mkdirSync22 } = require("fs");
+        const { join: join49 } = require("path");
+        const reportsDir = join49(process.cwd(), ".gossip", "consensus-reports");
+        mkdirSync22(reportsDir, { recursive: true });
+        writeFileSync18(join49(reportsDir, `${consensusId}.json`), JSON.stringify({
           id: consensusId,
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           agentCount: report.agentCount,
@@ -19577,12 +19615,12 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
       synthSnapshot.relayCrossReviewSkipped
     );
     try {
-      const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21 } = require("fs");
-      const { join: join48 } = require("path");
-      const reportsDir = join48(process.cwd(), ".gossip", "consensus-reports");
-      mkdirSync21(reportsDir, { recursive: true });
-      const reportPath = join48(reportsDir, `${consensus_id}.json`);
-      writeFileSync17(reportPath, JSON.stringify({
+      const { writeFileSync: writeFileSync18, mkdirSync: mkdirSync22 } = require("fs");
+      const { join: join49 } = require("path");
+      const reportsDir = join49(process.cwd(), ".gossip", "consensus-reports");
+      mkdirSync22(reportsDir, { recursive: true });
+      const reportPath = join49(reportsDir, `${consensus_id}.json`);
+      writeFileSync18(reportPath, JSON.stringify({
         id: consensus_id,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         agentCount: report.agentCount,
@@ -19622,10 +19660,10 @@ function persistPendingConsensus() {
   try {
     const projectRoot = ctx.mainAgent?.projectRoot;
     if (!projectRoot) return;
-    const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21 } = require("fs");
-    const { join: join48 } = require("path");
-    const dir = join48(projectRoot, ".gossip");
-    mkdirSync21(dir, { recursive: true });
+    const { writeFileSync: writeFileSync18, mkdirSync: mkdirSync22 } = require("fs");
+    const { join: join49 } = require("path");
+    const dir = join49(projectRoot, ".gossip");
+    mkdirSync22(dir, { recursive: true });
     const rounds = {};
     for (const [id, round] of ctx.pendingConsensusRounds) {
       rounds[id] = {
@@ -19647,7 +19685,7 @@ function persistPendingConsensus() {
         nativePrompts: (round.nativePrompts || []).filter((p) => round.pendingNativeAgents.has(p.agentId))
       };
     }
-    writeFileSync17(join48(dir, CONSENSUS_FILE), JSON.stringify(rounds));
+    writeFileSync18(join49(dir, CONSENSUS_FILE), JSON.stringify(rounds));
   } catch (err) {
     process.stderr.write(`[gossipcat] persistPendingConsensus failed: ${err.message}
 `);
@@ -19655,11 +19693,11 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync43, readFileSync: readFileSync40, unlinkSync: unlinkSync4 } = require("fs");
-    const { join: join48 } = require("path");
-    const filePath = join48(projectRoot, ".gossip", CONSENSUS_FILE);
-    if (!existsSync43(filePath)) return;
-    const raw = JSON.parse(readFileSync40(filePath, "utf-8"));
+    const { existsSync: existsSync44, readFileSync: readFileSync41, unlinkSync: unlinkSync4 } = require("fs");
+    const { join: join49 } = require("path");
+    const filePath = join49(projectRoot, ".gossip", CONSENSUS_FILE);
+    if (!existsSync44(filePath)) return;
+    const raw = JSON.parse(readFileSync41(filePath, "utf-8"));
     const now = Date.now();
     for (const [id, data] of Object.entries(raw)) {
       if (now > data.deadline + 3e5) {
@@ -20419,12 +20457,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_path36.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if ((0, import_fs34.existsSync)(graphPath)) {
+  const graphPath = (0, import_path37.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if ((0, import_fs35.existsSync)(graphPath)) {
     try {
       const created = /* @__PURE__ */ new Map();
       const finished = /* @__PURE__ */ new Set();
-      const lines = (0, import_fs34.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = (0, import_fs35.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const ev = JSON.parse(line);
@@ -20474,17 +20512,27 @@ async function overviewHandler(projectRoot, ctx2) {
   let confirmedFindings = 0;
   let lastConsensusTimestamp = "";
   let actionableFindings = 0;
-  const consensusTaskIds = /* @__PURE__ */ new Set();
-  const perfPath = (0, import_path36.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if ((0, import_fs34.existsSync)(perfPath)) {
+  const runBuckets = /* @__PURE__ */ new Map();
+  const perfPath = (0, import_path37.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if ((0, import_fs35.existsSync)(perfPath)) {
     try {
-      const lines = (0, import_fs34.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = (0, import_fs35.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const entry = JSON.parse(line);
-          totalSignals++;
+          if (entry.type === "consensus" && typeof entry.signal === "string") {
+            totalSignals++;
+          }
           if (entry.type === "consensus" && (entry.consensusId || entry.taskId)) {
-            consensusTaskIds.add(entry.consensusId ?? entry.taskId);
+            const runId = entry.consensusId ?? entry.taskId;
+            let bucket = runBuckets.get(runId);
+            if (!bucket) {
+              bucket = { agents: /* @__PURE__ */ new Set(), signalCount: 0 };
+              runBuckets.set(runId, bucket);
+            }
+            bucket.signalCount++;
+            if (entry.agentId) bucket.agents.add(entry.agentId);
+            if (entry.counterpartId) bucket.agents.add(entry.counterpartId);
           }
           if (entry.consensusId && entry.timestamp > lastConsensusTimestamp) {
             lastConsensusTimestamp = entry.timestamp;
@@ -20507,27 +20555,29 @@ async function overviewHandler(projectRoot, ctx2) {
     } catch {
     }
   }
-  consensusRuns = consensusTaskIds.size;
+  for (const bucket of runBuckets.values()) {
+    if (bucket.agents.size >= 2 && bucket.signalCount >= 3) consensusRuns++;
+  }
   const avgDurationMs = durationCount > 0 ? Math.round(totalDuration / durationCount) : 0;
   return { agentsOnline, relayCount, relayConnected, nativeCount, consensusRuns, totalFindings, confirmedFindings, totalSignals, tasksCompleted, tasksFailed, avgDurationMs, lastConsensusTimestamp, actionableFindings, hourlyActivity };
 }
-var import_fs34, import_path36;
+var import_fs35, import_path37;
 var init_api_overview = __esm({
   "packages/relay/src/dashboard/api-overview.ts"() {
     "use strict";
-    import_fs34 = require("fs");
-    import_path36 = require("path");
+    import_fs35 = require("fs");
+    import_path37 = require("path");
   }
 });
 
 // packages/relay/src/dashboard/api-agents.ts
 function readTaskGraphByAgent(projectRoot) {
-  const taskGraphPath = (0, import_path37.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  const taskGraphPath = (0, import_path38.join)(projectRoot, ".gossip", "task-graph.jsonl");
   const result = /* @__PURE__ */ new Map();
-  if (!(0, import_fs35.existsSync)(taskGraphPath)) return result;
+  if (!(0, import_fs36.existsSync)(taskGraphPath)) return result;
   let lines;
   try {
-    lines = (0, import_fs35.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    lines = (0, import_fs36.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
   } catch {
     return result;
   }
@@ -20619,19 +20669,32 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
         hallucinations: score.hallucinations,
         consecutiveFailures: score.consecutiveFailures ?? 0,
         circuitOpen: score.circuitOpen ?? false,
-        categoryStrengths: score.categoryStrengths ?? {}
+        // categoryStrengths is an UNBOUNDED severity-weighted accumulator used
+        // for dispatch routing (severity × decay × 0.15 per confirmed signal),
+        // not a [0,1] ratio. The dashboard must NOT render it as a percentage —
+        // it should render categoryAccuracy (c / (c + h)) which is a real ratio.
+        // See performance-reader.ts:357 (increment) vs :496-505 (accuracy).
+        categoryStrengths: score.categoryStrengths ?? {},
+        categoryAccuracy: score.categoryAccuracy ?? {},
+        // Forward raw counts so the dashboard can render "100% (3/3)" and
+        // distinguish a sparse-but-clean category from a high-volume clean
+        // one. categoryAccuracy already drops categories with fewer than
+        // MIN_CATEGORY_N signals, but the counts let the UI surface them
+        // as dimmed "sparse" rows instead of hiding them silently.
+        categoryCorrect: score.categoryCorrect ?? {},
+        categoryHallucinated: score.categoryHallucinated ?? {}
       }
     };
   });
 }
-var import_fs35, import_path37, DEFAULT_SCORE;
+var import_fs36, import_path38, DEFAULT_SCORE;
 var init_api_agents = __esm({
   "packages/relay/src/dashboard/api-agents.ts"() {
     "use strict";
     init_performance_reader();
     init_skill_index();
-    import_fs35 = require("fs");
-    import_path37 = require("path");
+    import_fs36 = require("fs");
+    import_path38 = require("path");
     DEFAULT_SCORE = {
       agentId: "",
       accuracy: 0.5,
@@ -20655,7 +20718,7 @@ var init_api_agents = __esm({
 
 // packages/relay/src/dashboard/api-skills.ts
 function isCorrupt(projectRoot, index) {
-  return (0, import_fs36.existsSync)((0, import_path38.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
+  return (0, import_fs37.existsSync)((0, import_path39.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
 }
 async function skillsGetHandler(projectRoot) {
   try {
@@ -20684,13 +20747,13 @@ async function skillsBindHandler(projectRoot, body) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
   }
 }
-var import_fs36, import_path38, AGENT_ID_RE2;
+var import_fs37, import_path39, AGENT_ID_RE2;
 var init_api_skills = __esm({
   "packages/relay/src/dashboard/api-skills.ts"() {
     "use strict";
     init_skill_index();
-    import_fs36 = require("fs");
-    import_path38 = require("path");
+    import_fs37 = require("fs");
+    import_path39 = require("path");
     AGENT_ID_RE2 = /^[a-zA-Z0-9_-]{1,64}$/;
   }
 });
@@ -20698,25 +20761,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_path39.join)(projectRoot, ".gossip", "agents", agentId, "memory");
+  const memDir = (0, import_path40.join)(projectRoot, ".gossip", "agents", agentId, "memory");
   let index = "";
-  const indexPath = (0, import_path39.join)(memDir, "MEMORY.md");
-  if ((0, import_fs37.existsSync)(indexPath)) {
+  const indexPath = (0, import_path40.join)(memDir, "MEMORY.md");
+  if ((0, import_fs38.existsSync)(indexPath)) {
     try {
-      index = (0, import_fs37.readFileSync)(indexPath, "utf-8");
+      index = (0, import_fs38.readFileSync)(indexPath, "utf-8");
     } catch {
     }
   }
   const knowledge = [];
-  const knowledgeDir = (0, import_path39.join)(memDir, "knowledge");
+  const knowledgeDir = (0, import_path40.join)(memDir, "knowledge");
   const knowledgeDirs = [knowledgeDir, memDir];
   for (const dir of knowledgeDirs) {
-    if (!(0, import_fs37.existsSync)(dir)) continue;
+    if (!(0, import_fs38.existsSync)(dir)) continue;
     try {
-      const files = (0, import_fs37.readdirSync)(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+      const files = (0, import_fs38.readdirSync)(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
       for (const filename of files) {
         try {
-          const raw = (0, import_fs37.readFileSync)((0, import_path39.join)(dir, filename), "utf-8");
+          const raw = (0, import_fs38.readFileSync)((0, import_path40.join)(dir, filename), "utf-8");
           const { frontmatter, content } = parseFrontmatter(raw);
           knowledge.push({ filename, frontmatter, content });
         } catch {
@@ -20726,10 +20789,10 @@ async function memoryHandler(projectRoot, agentId) {
     }
   }
   const tasks = [];
-  const tasksPath = (0, import_path39.join)(memDir, "tasks.jsonl");
-  if ((0, import_fs37.existsSync)(tasksPath)) {
+  const tasksPath = (0, import_path40.join)(memDir, "tasks.jsonl");
+  if ((0, import_fs38.existsSync)(tasksPath)) {
     try {
-      const lines = (0, import_fs37.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
+      const lines = (0, import_fs38.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
       for (const line of lines) {
         try {
           tasks.push(JSON.parse(line));
@@ -20757,12 +20820,12 @@ function parseFrontmatter(raw) {
   }
   return { frontmatter: fm, content: raw.slice(end + 3).trim() };
 }
-var import_fs37, import_path39, AGENT_ID_RE3, DANGEROUS_IDS;
+var import_fs38, import_path40, AGENT_ID_RE3, DANGEROUS_IDS;
 var init_api_memory = __esm({
   "packages/relay/src/dashboard/api-memory.ts"() {
     "use strict";
-    import_fs37 = require("fs");
-    import_path39 = require("path");
+    import_fs38 = require("fs");
+    import_path40 = require("path");
     AGENT_ID_RE3 = /^[a-zA-Z0-9_-]{1,64}$/;
     DANGEROUS_IDS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   }
@@ -20774,11 +20837,11 @@ 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_path40.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs38.existsSync)(perfPath)) return { runs: [], totalRuns: 0, totalSignals: 0, page, pageSize };
+  const perfPath = (0, import_path41.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs39.existsSync)(perfPath)) return { runs: [], totalRuns: 0, totalSignals: 0, page, pageSize };
   const signals = [];
   try {
-    const lines = (0, import_fs38.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs39.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const parsed = JSON.parse(line);
@@ -20849,12 +20912,12 @@ async function consensusHandler(projectRoot, query) {
   const paginatedRuns = runs.slice(offset, offset + pageSize);
   return { runs: paginatedRuns, totalRuns, totalSignals: signals.length, page, pageSize };
 }
-var import_fs38, import_path40, RESOLUTION_SIGNALS, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE;
+var import_fs39, import_path41, RESOLUTION_SIGNALS, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE;
 var init_api_consensus = __esm({
   "packages/relay/src/dashboard/api-consensus.ts"() {
     "use strict";
-    import_fs38 = require("fs");
-    import_path40 = require("path");
+    import_fs39 = require("fs");
+    import_path41 = require("path");
     RESOLUTION_SIGNALS = /* @__PURE__ */ new Set(["agreement", "unique_confirmed", "consensus_verified"]);
     DEFAULT_PAGE_SIZE = 10;
     MAX_PAGE_SIZE = 50;
@@ -20866,11 +20929,11 @@ async function signalsHandler(projectRoot, query) {
   const agentFilter = query?.get("agent") ?? 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_path41.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs39.existsSync)(perfPath)) return { items: [], total: 0, offset, limit };
+  const perfPath = (0, import_path42.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs40.existsSync)(perfPath)) return { items: [], total: 0, offset, limit };
   const all = [];
   try {
-    const lines = (0, import_fs39.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs40.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -20886,12 +20949,12 @@ async function signalsHandler(projectRoot, query) {
   all.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
   return { items: all.slice(offset, offset + limit), total: all.length, offset, limit };
 }
-var import_fs39, import_path41, MAX_LIMIT, DEFAULT_LIMIT;
+var import_fs40, import_path42, MAX_LIMIT, DEFAULT_LIMIT;
 var init_api_signals = __esm({
   "packages/relay/src/dashboard/api-signals.ts"() {
     "use strict";
-    import_fs39 = require("fs");
-    import_path41 = require("path");
+    import_fs40 = require("fs");
+    import_path42 = require("path");
     MAX_LIMIT = 200;
     DEFAULT_LIMIT = 50;
   }
@@ -20899,29 +20962,29 @@ var init_api_signals = __esm({
 
 // packages/relay/src/dashboard/api-learnings.ts
 async function learningsHandler(projectRoot) {
-  const agentsDir = (0, import_path42.join)(projectRoot, ".gossip", "agents");
-  if (!(0, import_fs40.existsSync)(agentsDir)) return { learnings: [] };
+  const agentsDir = (0, import_path43.join)(projectRoot, ".gossip", "agents");
+  if (!(0, import_fs41.existsSync)(agentsDir)) return { learnings: [] };
   const all = [];
   let agentIds;
   try {
-    agentIds = (0, import_fs40.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
+    agentIds = (0, import_fs41.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
   } catch {
     return { learnings: [] };
   }
   for (const agentId of agentIds) {
-    const knowledgeDir = (0, import_path42.join)(agentsDir, agentId, "memory", "knowledge");
-    if (!(0, import_fs40.existsSync)(knowledgeDir)) continue;
+    const knowledgeDir = (0, import_path43.join)(agentsDir, agentId, "memory", "knowledge");
+    if (!(0, import_fs41.existsSync)(knowledgeDir)) continue;
     let files;
     try {
-      files = (0, import_fs40.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+      files = (0, import_fs41.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
     } catch {
       continue;
     }
     for (const filename of files) {
-      const filepath = (0, import_path42.join)(knowledgeDir, filename);
+      const filepath = (0, import_path43.join)(knowledgeDir, filename);
       try {
-        const stat3 = (0, import_fs40.statSync)(filepath);
-        const raw = (0, import_fs40.readFileSync)(filepath, "utf-8");
+        const stat3 = (0, import_fs41.statSync)(filepath);
+        const raw = (0, import_fs41.readFileSync)(filepath, "utf-8");
         const fm = parseFrontmatter2(raw);
         all.push({
           agentId,
@@ -20948,12 +21011,12 @@ function parseFrontmatter2(raw) {
   }
   return fm;
 }
-var import_fs40, import_path42, MAX_LEARNINGS;
+var import_fs41, import_path43, MAX_LEARNINGS;
 var init_api_learnings = __esm({
   "packages/relay/src/dashboard/api-learnings.ts"() {
     "use strict";
-    import_fs40 = require("fs");
-    import_path42 = require("path");
+    import_fs41 = require("fs");
+    import_path43 = require("path");
     MAX_LEARNINGS = 10;
   }
 });
@@ -20964,12 +21027,12 @@ async function tasksHandler(projectRoot, query) {
   const rawOffset = parseInt(query?.get("offset") ?? "0", 10);
   const limit = isNaN(rawLimit) || rawLimit < 1 ? 50 : Math.min(rawLimit, 200);
   const offset = isNaN(rawOffset) || rawOffset < 0 ? 0 : rawOffset;
-  const graphPath = (0, import_path43.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs41.existsSync)(graphPath)) return { items: [], total: 0, offset, limit };
+  const graphPath = (0, import_path44.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs42.existsSync)(graphPath)) return { items: [], total: 0, offset, limit };
   const created = /* @__PURE__ */ new Map();
   const completed = /* @__PURE__ */ new Map();
   try {
-    const lines = (0, import_fs41.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs42.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -21024,23 +21087,23 @@ 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_fs41, import_path43;
+var import_fs42, import_path44;
 var init_api_tasks = __esm({
   "packages/relay/src/dashboard/api-tasks.ts"() {
     "use strict";
-    import_fs41 = require("fs");
-    import_path43 = require("path");
+    import_fs42 = require("fs");
+    import_path44 = require("path");
   }
 });
 
 // packages/relay/src/dashboard/api-active-tasks.ts
 async function activeTasksHandler(projectRoot) {
-  const taskGraphPath = (0, import_path44.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs42.existsSync)(taskGraphPath)) return { tasks: [] };
+  const taskGraphPath = (0, import_path45.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs43.existsSync)(taskGraphPath)) return { tasks: [] };
   const created = /* @__PURE__ */ new Map();
   const finished = /* @__PURE__ */ new Set();
   try {
-    const lines = (0, import_fs42.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    const lines = (0, import_fs43.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const ev = JSON.parse(line);
@@ -21067,12 +21130,12 @@ async function activeTasksHandler(projectRoot) {
   active.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
   return { tasks: active.slice(0, 10) };
 }
-var import_fs42, import_path44;
+var import_fs43, import_path45;
 var init_api_active_tasks = __esm({
   "packages/relay/src/dashboard/api-active-tasks.ts"() {
     "use strict";
-    import_fs42 = require("fs");
-    import_path44 = require("path");
+    import_fs43 = require("fs");
+    import_path45 = require("path");
   }
 });
 
@@ -21085,25 +21148,25 @@ function categorize(text) {
   return "other";
 }
 function logsHandler(projectRoot, query) {
-  const logPath = (0, import_path45.join)(projectRoot, ".gossip", "mcp.log");
-  if (!(0, import_fs43.existsSync)(logPath)) {
+  const logPath = (0, import_path46.join)(projectRoot, ".gossip", "mcp.log");
+  if (!(0, import_fs44.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_fs43.statSync)(logPath).size;
+  const fileSize = (0, import_fs44.statSync)(logPath).size;
   const MAX_READ = 512 * 1024;
   const readFrom = Math.max(0, fileSize - MAX_READ);
   const readLen = fileSize - readFrom;
-  const fd = (0, import_fs43.openSync)(logPath, "r");
+  const fd = (0, import_fs44.openSync)(logPath, "r");
   let buf = Buffer.alloc(0);
   try {
     buf = Buffer.allocUnsafe(readLen);
-    const bytesRead = (0, import_fs43.readSync)(fd, buf, 0, readLen, readFrom);
+    const bytesRead = (0, import_fs44.readSync)(fd, buf, 0, readLen, readFrom);
     buf = buf.subarray(0, bytesRead);
   } finally {
-    (0, import_fs43.closeSync)(fd);
+    (0, import_fs44.closeSync)(fd);
   }
   let raw = buf.toString("utf-8");
   let lineOffset = 0;
@@ -21111,13 +21174,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_fs43.openSync)(logPath, "r");
+    const scanFd = (0, import_fs44.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_fs43.readSync)(scanFd, chunk, 0, len, pos);
+        const n = (0, import_fs44.readSync)(scanFd, chunk, 0, len, pos);
         if (n === 0) break;
         for (let j = 0; j < n; j++) {
           if (chunk[j] === 10) lineOffset++;
@@ -21125,7 +21188,7 @@ function logsHandler(projectRoot, query) {
         pos += n;
       }
     } finally {
-      (0, import_fs43.closeSync)(scanFd);
+      (0, import_fs44.closeSync)(scanFd);
     }
   }
   const allLines = raw.split("\n").filter(Boolean);
@@ -21143,12 +21206,12 @@ function logsHandler(projectRoot, query) {
   entries = entries.slice(-clampedTail);
   return { entries, totalLines, fileSize, filter };
 }
-var import_fs43, import_path45, CATEGORY_PATTERNS2;
+var import_fs44, import_path46, CATEGORY_PATTERNS2;
 var init_api_logs = __esm({
   "packages/relay/src/dashboard/api-logs.ts"() {
     "use strict";
-    import_fs43 = require("fs");
-    import_path45 = require("path");
+    import_fs44 = require("fs");
+    import_path46 = require("path");
     CATEGORY_PATTERNS2 = [
       [/^\[worker:/, "worker"],
       [/^\[Gemini\]/, "gemini"],
@@ -21178,15 +21241,15 @@ var init_api_logs = __esm({
 // packages/relay/src/dashboard/routes.ts
 function resolveDashboardRoot(projectRoot) {
   const candidates = [
-    (0, import_path46.resolve)(__dirname, "..", "dist-dashboard"),
+    (0, import_path47.resolve)(__dirname, "..", "dist-dashboard"),
     // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
-    (0, import_path46.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    (0, import_path47.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
     // tsc dev: packages/relay/dist/dashboard → repo-root
-    (0, import_path46.join)(projectRoot, "dist-dashboard")
+    (0, import_path47.join)(projectRoot, "dist-dashboard")
     // legacy dev fallback (git-clone running from repo root)
   ];
   for (const p of candidates) {
-    if ((0, import_fs44.existsSync)(p)) return p;
+    if ((0, import_fs45.existsSync)(p)) return p;
   }
   return null;
 }
@@ -21213,7 +21276,7 @@ function readBody(req) {
     });
   });
 }
-var import_fs44, import_path46, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
+var import_fs45, import_path47, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
 var init_routes = __esm({
   "packages/relay/src/dashboard/routes.ts"() {
     "use strict";
@@ -21227,8 +21290,8 @@ var init_routes = __esm({
     init_api_tasks();
     init_api_active_tasks();
     init_api_logs();
-    import_fs44 = require("fs");
-    import_path46 = require("path");
+    import_fs45 = require("fs");
+    import_path47 = require("path");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
     DashboardRouter = class {
@@ -21410,13 +21473,13 @@ var init_routes = __esm({
           res.end("Dashboard assets not found. Reinstall gossipcat or rebuild from source.");
           return true;
         }
-        const htmlPath = (0, import_path46.join)(this.dashboardRoot, "index.html");
-        if (!(0, import_fs44.existsSync)(htmlPath)) {
+        const htmlPath = (0, import_path47.join)(this.dashboardRoot, "index.html");
+        if (!(0, import_fs45.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_fs44.readFileSync)(htmlPath, "utf-8");
+        const html = (0, import_fs45.readFileSync)(htmlPath, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return true;
@@ -21442,16 +21505,16 @@ var init_routes = __esm({
         const ext = "." + (relativePath.split(".").pop() || "");
         const mime = MIME[ext];
         if (!mime) return false;
-        const filePath = (0, import_path46.join)(this.dashboardRoot, relativePath);
+        const filePath = (0, import_path47.join)(this.dashboardRoot, relativePath);
         try {
-          const realFile = (0, import_fs44.realpathSync)(filePath);
-          const realBase = (0, import_fs44.realpathSync)(this.dashboardRoot);
+          const realFile = (0, import_fs45.realpathSync)(filePath);
+          const realBase = (0, import_fs45.realpathSync)(this.dashboardRoot);
           if (!realFile.startsWith(realBase + "/")) {
             res.writeHead(404);
             res.end();
             return true;
           }
-          const data = (0, import_fs44.readFileSync)(realFile);
+          const data = (0, import_fs45.readFileSync)(realFile);
           res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=86400" });
           res.end(data);
           return true;
@@ -21466,15 +21529,15 @@ var init_routes = __esm({
         return match ? match[1] : null;
       }
       getConsensusReports(page = 1, pageSize = 5) {
-        const { readdirSync: readdirSync13, readFileSync: readFileSync40, existsSync: existsSync43 } = require("fs");
-        const reportsDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports");
-        if (!existsSync43(reportsDir)) return { reports: [], totalReports: 0, page, pageSize };
+        const { readdirSync: readdirSync13, readFileSync: readFileSync41, existsSync: existsSync44 } = require("fs");
+        const reportsDir = (0, import_path47.join)(this.projectRoot, ".gossip", "consensus-reports");
+        if (!existsSync44(reportsDir)) return { reports: [], totalReports: 0, page, pageSize };
         try {
           const { statSync: statSync9 } = require("fs");
           const allFiles = readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
             try {
-              const aTime = statSync9((0, import_path46.join)(reportsDir, a)).mtimeMs;
-              const bTime = statSync9((0, import_path46.join)(reportsDir, b)).mtimeMs;
+              const aTime = statSync9((0, import_path47.join)(reportsDir, a)).mtimeMs;
+              const bTime = statSync9((0, import_path47.join)(reportsDir, b)).mtimeMs;
               return bTime - aTime;
             } catch {
               return 0;
@@ -21485,13 +21548,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_fs44.realpathSync)(reportsDir);
+          const realReportsDir = (0, import_fs45.realpathSync)(reportsDir);
           const reports = files.map((f) => {
             try {
-              const filePath = (0, import_path46.join)(reportsDir, f);
-              const realFile = (0, import_fs44.realpathSync)(filePath);
+              const filePath = (0, import_path47.join)(reportsDir, f);
+              const realFile = (0, import_fs45.realpathSync)(filePath);
               if (!realFile.startsWith(realReportsDir + "/")) return null;
-              return JSON.parse(readFileSync40(realFile, "utf-8"));
+              return JSON.parse(readFileSync41(realFile, "utf-8"));
             } catch {
               return null;
             }
@@ -21502,29 +21565,29 @@ var init_routes = __esm({
         }
       }
       archiveFindings() {
-        const { readdirSync: readdirSync13, readFileSync: readFileSync40, renameSync: renameSync2, writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43 } = require("fs");
-        const reportsDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports");
-        const archiveDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
+        const { readdirSync: readdirSync13, readFileSync: readFileSync41, renameSync: renameSync2, writeFileSync: writeFileSync18, mkdirSync: mkdirSync22, existsSync: existsSync44 } = require("fs");
+        const reportsDir = (0, import_path47.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const archiveDir = (0, import_path47.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
         let archived = 0;
-        if (existsSync43(reportsDir)) {
+        if (existsSync44(reportsDir)) {
           const files = readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).sort().reverse();
           if (files.length > 5) {
-            mkdirSync21(archiveDir, { recursive: true });
+            mkdirSync22(archiveDir, { recursive: true });
             const toArchive = files.slice(5);
             for (const f of toArchive) {
               try {
-                renameSync2((0, import_path46.join)(reportsDir, f), (0, import_path46.join)(archiveDir, f));
+                renameSync2((0, import_path47.join)(reportsDir, f), (0, import_path47.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path46.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path47.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
-        if (existsSync43(findingsPath)) {
+        if (existsSync44(findingsPath)) {
           try {
-            const lines = readFileSync40(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
+            const lines = readFileSync41(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
             const kept = lines.filter((line) => {
               try {
                 const entry = JSON.parse(line);
@@ -21537,11 +21600,11 @@ var init_routes = __esm({
                 return true;
               }
             });
-            writeFileSync17(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
+            writeFileSync18(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
           } catch {
           }
         }
-        const remaining = existsSync43(reportsDir) ? readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
+        const remaining = existsSync44(reportsDir) ? readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
         return { archived, remaining, findingsCleared };
       }
       json(res, status, data) {
@@ -21554,14 +21617,14 @@ var init_routes = __esm({
 });
 
 // packages/relay/src/dashboard/ws.ts
-var import_ws3, import_fs45, import_fs46, import_path47, DashboardWs;
+var import_ws3, import_fs46, import_fs47, import_path48, DashboardWs;
 var init_ws = __esm({
   "packages/relay/src/dashboard/ws.ts"() {
     "use strict";
     import_ws3 = require("ws");
-    import_fs45 = require("fs");
     import_fs46 = require("fs");
-    import_path47 = require("path");
+    import_fs47 = require("fs");
+    import_path48 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -21586,15 +21649,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_path47.join)(projectRoot, ".gossip", "mcp.log");
-        if (!(0, import_fs45.existsSync)(this.logPath)) return;
+        this.logPath = (0, import_path48.join)(projectRoot, ".gossip", "mcp.log");
+        if (!(0, import_fs46.existsSync)(this.logPath)) return;
         try {
-          this.logOffset = (0, import_fs45.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs46.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs46.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs47.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -21611,7 +21674,7 @@ var init_ws = __esm({
         if (this.logReading) return;
         this.logReading = true;
         try {
-          const currentSize = (0, import_fs45.statSync)(this.logPath).size;
+          const currentSize = (0, import_fs46.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -21624,7 +21687,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_fs45.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
+            stream = (0, import_fs46.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
           } catch {
             this.logReading = false;
             return;
@@ -21980,18 +22043,18 @@ __export(config_exports, {
 function findConfigPath(projectRoot) {
   const root = projectRoot || process.cwd();
   const candidates = [
-    (0, import_path48.resolve)(root, ".gossip", "config.json"),
-    (0, import_path48.resolve)(root, "gossip.agents.json"),
-    (0, import_path48.resolve)(root, "gossip.agents.yaml"),
-    (0, import_path48.resolve)(root, "gossip.agents.yml")
+    (0, import_path49.resolve)(root, ".gossip", "config.json"),
+    (0, import_path49.resolve)(root, "gossip.agents.json"),
+    (0, import_path49.resolve)(root, "gossip.agents.yaml"),
+    (0, import_path49.resolve)(root, "gossip.agents.yml")
   ];
   for (const p of candidates) {
-    if ((0, import_fs47.existsSync)(p)) return p;
+    if ((0, import_fs48.existsSync)(p)) return p;
   }
   return null;
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs47.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs48.readFileSync)(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -22070,19 +22133,19 @@ function configToAgentConfigs(config2) {
 }
 function loadClaudeSubagents(projectRoot, existingIds) {
   const root = projectRoot || process.cwd();
-  const agentsDir = (0, import_path48.join)(root, ".claude", "agents");
-  if (!(0, import_fs47.existsSync)(agentsDir)) return [];
+  const agentsDir = (0, import_path49.join)(root, ".claude", "agents");
+  if (!(0, import_fs48.existsSync)(agentsDir)) return [];
   let files;
   try {
-    files = (0, import_fs47.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
+    files = (0, import_fs48.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
   } catch {
     return [];
   }
   const agents = [];
   for (const file2 of files) {
-    const filePath = (0, import_path48.join)(agentsDir, file2);
+    const filePath = (0, import_path49.join)(agentsDir, file2);
     try {
-      const content = (0, import_fs47.readFileSync)(filePath, "utf-8");
+      const content = (0, import_fs48.readFileSync)(filePath, "utf-8");
       const frontmatter = content.match(/^---\n([\s\S]*?)\n---/);
       if (!frontmatter) continue;
       const fm = frontmatter[1];
@@ -22137,12 +22200,12 @@ function inferSkills(description, name) {
   if (skills.length === 0) skills.push("general");
   return skills;
 }
-var import_fs47, import_path48, VALID_PROVIDERS, CLAUDE_MODEL_MAP;
+var import_fs48, import_path49, VALID_PROVIDERS, CLAUDE_MODEL_MAP;
 var init_config = __esm({
   "apps/cli/src/config.ts"() {
     "use strict";
-    import_fs47 = require("fs");
-    import_path48 = require("path");
+    import_fs48 = require("fs");
+    import_path49 = require("path");
     VALID_PROVIDERS = ["anthropic", "openai", "openclaw", "google", "local", "native"];
     CLAUDE_MODEL_MAP = {
       opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -22157,14 +22220,14 @@ var keychain_exports = {};
 __export(keychain_exports, {
   Keychain: () => Keychain
 });
-var import_child_process5, import_os2, import_fs48, import_path49, import_crypto15, SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
+var import_child_process5, import_os2, import_fs49, import_path50, import_crypto15, SERVICE_NAME, VALID_PROVIDERS2, ENCRYPTED_FILE, ALGO, Keychain;
 var init_keychain = __esm({
   "apps/cli/src/keychain.ts"() {
     "use strict";
     import_child_process5 = require("child_process");
     import_os2 = require("os");
-    import_fs48 = require("fs");
-    import_path49 = require("path");
+    import_fs49 = require("fs");
+    import_path50 = require("path");
     import_crypto15 = require("crypto");
     SERVICE_NAME = "gossip-mesh";
     VALID_PROVIDERS2 = /^[a-zA-Z0-9_-]{1,32}$/;
@@ -22206,10 +22269,10 @@ var init_keychain = __esm({
         return (0, import_crypto15.pbkdf2Sync)(seed, salt, 6e5, 32, "sha256");
       }
       loadEncryptedFile() {
-        const filePath = (0, import_path49.join)(process.cwd(), ENCRYPTED_FILE);
-        if (!(0, import_fs48.existsSync)(filePath)) return;
+        const filePath = (0, import_path50.join)(process.cwd(), ENCRYPTED_FILE);
+        if (!(0, import_fs49.existsSync)(filePath)) return;
         try {
-          const raw = (0, import_fs48.readFileSync)(filePath);
+          const raw = (0, import_fs49.readFileSync)(filePath);
           if (raw.length < 61) return;
           const salt = raw.subarray(0, 32);
           const iv = raw.subarray(32, 44);
@@ -22227,9 +22290,9 @@ var init_keychain = __esm({
         }
       }
       saveEncryptedFile() {
-        const filePath = (0, import_path49.join)(process.cwd(), ENCRYPTED_FILE);
-        const dir = (0, import_path49.join)(process.cwd(), ".gossip");
-        if (!(0, import_fs48.existsSync)(dir)) (0, import_fs48.mkdirSync)(dir, { recursive: true });
+        const filePath = (0, import_path50.join)(process.cwd(), ENCRYPTED_FILE);
+        const dir = (0, import_path50.join)(process.cwd(), ".gossip");
+        if (!(0, import_fs49.existsSync)(dir)) (0, import_fs49.mkdirSync)(dir, { recursive: true });
         const data = JSON.stringify(Object.fromEntries(this.inMemoryStore));
         const salt = (0, import_crypto15.randomBytes)(32);
         const iv = (0, import_crypto15.randomBytes)(12);
@@ -22237,7 +22300,7 @@ var init_keychain = __esm({
         const cipher = (0, import_crypto15.createCipheriv)(ALGO, key, iv);
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
-        (0, import_fs48.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
+        (0, import_fs49.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
       }
       isKeychainAvailable() {
         if ((0, import_os2.platform)() === "darwin") {
@@ -22337,17 +22400,17 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path50.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path51.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs49.readFileSync)(saltPath, "utf-8").trim();
+    return (0, import_fs50.readFileSync)(saltPath, "utf-8").trim();
   } catch {
     const salt = (0, import_crypto16.randomBytes)(16).toString("hex");
-    (0, import_fs49.mkdirSync)((0, import_path50.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs50.mkdirSync)((0, import_path51.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs49.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs50.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs49.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs50.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
@@ -22397,12 +22460,12 @@ function getProjectId(projectRoot) {
   }
   return (0, import_crypto16.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 16);
 }
-var import_fs49, import_path50, import_crypto16, import_child_process6;
+var import_fs50, import_path51, import_crypto16, import_child_process6;
 var init_identity = __esm({
   "apps/cli/src/identity.ts"() {
     "use strict";
-    import_fs49 = require("fs");
-    import_path50 = require("path");
+    import_fs50 = require("fs");
+    import_path51 = require("path");
     import_crypto16 = require("crypto");
     import_child_process6 = require("child_process");
   }
@@ -22424,9 +22487,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path51.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path52.resolve)(__dirname, "..", "..", "..", "..");
   if (process.env.npm_config_global === "true") return "global";
-  if ((0, import_fs50.existsSync)((0, import_path51.join)(packageRoot, ".git"))) return "git-clone";
+  if ((0, import_fs51.existsSync)((0, import_path52.join)(packageRoot, ".git"))) return "git-clone";
   return "local";
 }
 function updateCommand(method, version2) {
@@ -22477,7 +22540,7 @@ Check your internet connection or visit https://www.npmjs.com/package/gossipcat
   try {
     (0, import_child_process7.execSync)(command, {
       stdio: "inherit",
-      cwd: method === "git-clone" ? (0, import_path51.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
+      cwd: method === "git-clone" ? (0, import_path52.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
     });
   } catch (err) {
     return {
@@ -22499,13 +22562,13 @@ Run /mcp reconnect in Claude Code to load the new version.`
     }]
   };
 }
-var import_child_process7, import_fs50, import_path51;
+var import_child_process7, import_fs51, import_path52;
 var init_gossip_update = __esm({
   "apps/cli/src/handlers/gossip-update.ts"() {
     "use strict";
     import_child_process7 = require("child_process");
-    import_fs50 = require("fs");
-    import_path51 = require("path");
+    import_fs51 = require("fs");
+    import_path52 = require("path");
     init_version();
   }
 });
@@ -22669,8 +22732,8 @@ var init_verify_memory = __esm({
 });
 
 // apps/cli/src/mcp-server-sdk.ts
-var import_fs51 = require("fs");
-var import_path52 = require("path");
+var import_fs52 = require("fs");
+var import_path53 = 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");
@@ -38030,12 +38093,83 @@ ${gaps.map((g) => `  - ${g.agentId} needs "${g.category}" (score: ${g.score.toFi
 
 // apps/cli/src/mcp-server-sdk.ts
 init_relay_cross_review();
-var gossipDir = (0, import_path52.join)(process.cwd(), ".gossip");
+
+// apps/cli/src/stickyPort.ts
+var import_fs34 = require("fs");
+var import_path36 = require("path");
+var import_net = require("net");
+var RELAY_STICKY_FILE = (0, import_path36.join)(".gossip", "relay.port");
+var HTTP_MCP_STICKY_FILE = (0, import_path36.join)(".gossip", "http-mcp.port");
+function stickyPath(filename) {
+  return (0, import_path36.join)(process.cwd(), filename);
+}
+function readStickyPort(filename) {
+  const p = stickyPath(filename);
+  if (!(0, import_fs34.existsSync)(p)) return null;
+  try {
+    const raw = (0, import_fs34.readFileSync)(p, "utf-8").trim();
+    const n = parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 1 || n > 65535) return null;
+    return n;
+  } catch {
+    return null;
+  }
+}
+function writeStickyPort(filename, port) {
+  if (!Number.isFinite(port) || port < 1 || port > 65535) return;
+  const p = stickyPath(filename);
+  try {
+    (0, import_fs34.mkdirSync)((0, import_path36.dirname)(p), { recursive: true });
+    (0, import_fs34.writeFileSync)(p, String(port), "utf-8");
+  } catch {
+  }
+}
+function probePort(port, host = "127.0.0.1") {
+  return new Promise((resolve18) => {
+    const srv = (0, import_net.createServer)();
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      try {
+        srv.close();
+      } catch {
+      }
+      resolve18(ok);
+    };
+    srv.once("error", () => done(false));
+    try {
+      srv.listen(port, host, () => {
+        srv.close(() => done(true));
+      });
+    } catch {
+      done(false);
+    }
+  });
+}
+async function pickStickyPort(envVar, stickyFile, probeHost = "127.0.0.1") {
+  const envRaw = process.env[envVar];
+  if (envRaw !== void 0 && envRaw !== "") {
+    const envPort = parseInt(envRaw, 10);
+    if (Number.isFinite(envPort) && envPort >= 0 && envPort <= 65535) {
+      return { port: envPort, source: "env" };
+    }
+  }
+  const sticky = readStickyPort(stickyFile);
+  if (sticky !== null) {
+    const free = await probePort(sticky, probeHost);
+    if (free) return { port: sticky, source: "sticky" };
+  }
+  return { port: 0, source: "auto" };
+}
+
+// apps/cli/src/mcp-server-sdk.ts
+var gossipDir = (0, import_path53.join)(process.cwd(), ".gossip");
 try {
-  (0, import_fs51.mkdirSync)(gossipDir, { recursive: true });
+  (0, import_fs52.mkdirSync)(gossipDir, { recursive: true });
 } catch {
 }
-var logStream = (0, import_fs51.createWriteStream)((0, import_path52.join)(gossipDir, "mcp.log"), { flags: "a" });
+var logStream = (0, import_fs52.createWriteStream)((0, import_path53.join)(gossipDir, "mcp.log"), { flags: "a" });
 process.stderr.write = ((chunk, ...args) => {
   return logStream.write(chunk, ...args);
 });
@@ -38199,17 +38333,18 @@ var booted = false;
 var bootPromise = null;
 var planExecutionDepth = 0;
 var _pendingSessionData = /* @__PURE__ */ new Map();
+var _pendingSkillData = /* @__PURE__ */ new Map();
 var _pendingVerifyData = /* @__PURE__ */ new Map();
 var _modules = null;
 function lookupFindingSeverity(findingId, projectRoot) {
-  const { existsSync: existsSync43, readdirSync: readdirSync13, readFileSync: readFileSync40 } = require("fs");
-  const { join: join48 } = require("path");
-  const reportsDir = join48(projectRoot, ".gossip", "consensus-reports");
-  if (!existsSync43(reportsDir)) return null;
+  const { existsSync: existsSync44, readdirSync: readdirSync13, readFileSync: readFileSync41 } = require("fs");
+  const { join: join49 } = require("path");
+  const reportsDir = join49(projectRoot, ".gossip", "consensus-reports");
+  if (!existsSync44(reportsDir)) return null;
   try {
     const files = readdirSync13(reportsDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const report = JSON.parse(readFileSync40(join48(reportsDir, file2), "utf-8"));
+      const report = JSON.parse(readFileSync41(join49(reportsDir, file2), "utf-8"));
       for (const bucket of ["confirmed", "disputed", "unverified", "unique"]) {
         for (const finding of report[bucket] || []) {
           if (finding.id === findingId && finding.severity) {
@@ -38286,7 +38421,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_path52.join)(process.cwd(), ".gossip", "relay.pid");
+  const pidFile = (0, import_path53.join)(process.cwd(), ".gossip", "relay.pid");
   if (pidExists(pidFile)) {
     const oldPid = parseInt(readPid(pidFile, "utf-8").trim(), 10);
     if (!isNaN(oldPid) && oldPid !== process.pid) {
@@ -38299,8 +38434,9 @@ async function doBoot() {
     }
   }
   const relayApiKey = (0, import_crypto17.randomBytes)(32).toString("hex");
-  const envPort = process.env.GOSSIPCAT_PORT ? parseInt(process.env.GOSSIPCAT_PORT, 10) : NaN;
-  const relayPort = Number.isFinite(envPort) && envPort >= 0 && envPort <= 65535 ? envPort : 0;
+  const relayPick = await pickStickyPort("GOSSIPCAT_PORT", RELAY_STICKY_FILE);
+  const relayPort = relayPick.port;
+  ctx.relayPortSource = relayPick.source;
   ctx.relay = new m.RelayServer({
     port: relayPort,
     apiKey: relayApiKey,
@@ -38310,7 +38446,10 @@ async function doBoot() {
     }
   });
   await ctx.relay.start();
-  startHttpMcpTransport();
+  if (typeof ctx.relay.port === "number" && ctx.relay.port > 0) {
+    writeStickyPort(RELAY_STICKY_FILE, ctx.relay.port);
+  }
+  await startHttpMcpTransport();
   try {
     writePid(pidFile, String(process.pid));
   } catch {
@@ -38376,10 +38515,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: existsSync43, readFileSync: readFileSync40 } = require("fs");
-    const { join: join48 } = require("path");
-    const instructionsPath = join48(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
-    const baseInstructions = existsSync43(instructionsPath) ? readFileSync40(instructionsPath, "utf-8") : "";
+    const { existsSync: existsSync44, readFileSync: readFileSync41 } = require("fs");
+    const { join: join49 } = require("path");
+    const instructionsPath = join49(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
+    const baseInstructions = existsSync44(instructionsPath) ? readFileSync41(instructionsPath, "utf-8") : "";
     const identity = identityRegistry.get(ac.id);
     const identityBlock = identity ? m.formatIdentityBlock(identity) + "\n" : "";
     const instructions = (identityBlock + baseInstructions).trim() || void 0;
@@ -38940,18 +39079,21 @@ server.tool(
       "Status:",
       `  Host: ${env.host}${env.supportsNativeAgents ? " (native agents supported)" : ""}`,
       `  Native agent dir: ${env.nativeAgentDir || "n/a"}`,
-      `  Relay: ${ctx.relay ? `running :${ctx.relay.port}` : "not started"}`,
+      `  Relay: ${ctx.relay ? `running :${ctx.relay.port}${ctx.relayPortSource === "sticky" ? " (sticky)" : ""}` : "not started"}`,
       `  Tool Server: ${ctx.toolServer ? "running" : "not started"}`,
       `  Workers: ${ctx.workers.size} (${Array.from(ctx.workers.keys()).join(", ") || "none"})`,
       `  Claude subagents found: ${claudeSubagentsList.length}`
     ];
     if (ctx.relay?.dashboardUrl) {
-      lines.push(`  Dashboard: ${ctx.relay.dashboardUrl} (key: ${ctx.relay.dashboardKey})`);
+      lines.push(`  Dashboard: ${ctx.relay.dashboardUrl}${ctx.relayPortSource === "sticky" ? " (sticky)" : ""} (key: ${ctx.relay.dashboardKey})`);
+    }
+    if (ctx.httpMcpPort) {
+      lines.push(`  HTTP MCP: :${ctx.httpMcpPort}/mcp${ctx.httpMcpPortSource === "sticky" ? " (sticky)" : ""}`);
     }
     try {
-      const { readFileSync: readFileSync40 } = await import("fs");
-      const quotaPath = (0, import_path52.join)(process.cwd(), ".gossip", "quota-state.json");
-      const quotaRaw = readFileSync40(quotaPath, "utf8");
+      const { readFileSync: readFileSync41 } = await import("fs");
+      const quotaPath = (0, import_path53.join)(process.cwd(), ".gossip", "quota-state.json");
+      const quotaRaw = readFileSync41(quotaPath, "utf8");
       const quotaState = JSON.parse(quotaRaw);
       for (const [provider, state] of Object.entries(quotaState)) {
         const now = Date.now();
@@ -38965,16 +39107,16 @@ server.tool(
     } catch {
     }
     try {
-      const { readFileSync: readFileSync40, readdirSync: readdirSync13, statSync: statSync9 } = await import("fs");
-      const reportsDir = (0, import_path52.join)(process.cwd(), ".gossip", "consensus-reports");
-      const perfPath = (0, import_path52.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
+      const { readFileSync: readFileSync41, readdirSync: readdirSync13, statSync: statSync9 } = await import("fs");
+      const reportsDir = (0, import_path53.join)(process.cwd(), ".gossip", "consensus-reports");
+      const perfPath = (0, import_path53.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
       const WINDOW_MS = 24 * 60 * 60 * 1e3;
       const now = Date.now();
       const recentReports = [];
       try {
         for (const fname of readdirSync13(reportsDir)) {
           if (!fname.endsWith(".json")) continue;
-          const fpath = (0, import_path52.join)(reportsDir, fname);
+          const fpath = (0, import_path53.join)(reportsDir, fname);
           const st = statSync9(fpath);
           if (now - st.mtimeMs > WINDOW_MS) continue;
           recentReports.push({ id: fname.replace(/\.json$/, ""), mtimeMs: st.mtimeMs });
@@ -38984,7 +39126,7 @@ server.tool(
       if (recentReports.length > 0) {
         const covered = /* @__PURE__ */ new Set();
         try {
-          const perfRaw = readFileSync40(perfPath, "utf8");
+          const perfRaw = readFileSync41(perfPath, "utf8");
           for (const line of perfRaw.split("\n")) {
             if (!line) continue;
             try {
@@ -39116,7 +39258,73 @@ ${toolsMatch[1].trim()}`;
       }
     } catch {
     }
-    return { content: [{ type: "text", text: lines.join("\n") + "\n\n" + agentSections.join("\n") + sessionContextSection }] };
+    let handbookSection = "";
+    try {
+      const { readFileSync: rfHB, statSync: stHB } = require("fs");
+      const { join: jHB } = require("path");
+      const handbookPath = jHB(process.cwd(), "docs", "HANDBOOK.md");
+      const stat3 = stHB(handbookPath);
+      const HANDBOOK_CAP_BYTES = 24 * 1024;
+      let body = rfHB(handbookPath, "utf-8");
+      const truncated = body.length > HANDBOOK_CAP_BYTES;
+      if (truncated) {
+        body = body.slice(0, HANDBOOK_CAP_BYTES);
+      }
+      handbookSection = "\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n## Project Handbook (auto-loaded from docs/HANDBOOK.md)\n\n" + body.trim() + (truncated ? `
+
+[handbook truncated at ${HANDBOOK_CAP_BYTES / 1024}KB \u2014 full file at docs/HANDBOOK.md, ${stat3.size} bytes total]` : "");
+    } catch {
+    }
+    return { content: [{ type: "text", text: lines.join("\n") + "\n\n" + agentSections.join("\n") + sessionContextSection + handbookSection }] };
+  }
+);
+server.tool(
+  "gossip_guide",
+  "Show the gossipcat handbook for humans \u2014 architectural invariants, operator playbook, caveats, hallucination patterns, glossary. Call this when you want to READ the docs, not when you need LLM context. The LLM-facing auto-load lives in gossip_status().",
+  {},
+  async () => {
+    try {
+      const { readFileSync: rfG, existsSync: exG } = require("fs");
+      const { join: jG, dirname: dG } = require("path");
+      const projectHandbook = jG(process.cwd(), "docs", "HANDBOOK.md");
+      if (exG(projectHandbook)) {
+        const body = rfG(projectHandbook, "utf-8");
+        return {
+          content: [{
+            type: "text",
+            text: `# Gossipcat Handbook (from ${projectHandbook})
+
+${body}`
+          }]
+        };
+      }
+      const bundleRoot = dG(require.resolve("../../dist-mcp/mcp-server.js").replace(/\/dist-mcp\/mcp-server\.js$/, "/dist-mcp/mcp-server.js"));
+      const defaultHandbook = jG(bundleRoot, "..", "docs", "HANDBOOK.md");
+      if (exG(defaultHandbook)) {
+        const body = rfG(defaultHandbook, "utf-8");
+        return {
+          content: [{
+            type: "text",
+            text: `# Gossipcat Handbook (bundled default \u2014 your project has no docs/HANDBOOK.md yet)
+
+${body}`
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: "No handbook found. Expected at docs/HANDBOOK.md in the current project or bundled with gossipcat. If you are inside a gossipcat project, run `gossip_setup` first."
+        }]
+      };
+    } catch (err) {
+      return {
+        content: [{
+          type: "text",
+          text: `Error reading handbook: ${err.message}`
+        }]
+      };
+    }
   }
 );
 server.tool(
@@ -39223,8 +39431,8 @@ server.tool(
       }
       return { content: [{ type: "text", text: results.join("\n") }] };
     }
-    const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43 } = require("fs");
-    const { join: join48 } = require("path");
+    const { writeFileSync: writeFileSync18, mkdirSync: mkdirSync22, existsSync: existsSync44 } = require("fs");
+    const { join: join49 } = require("path");
     const root = process.cwd();
     const CLAUDE_MODEL_MAP2 = {
       opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -39238,8 +39446,8 @@ server.tool(
     let existingAgents = {};
     if (mode === "merge") {
       try {
-        const { readFileSync: readFileSync40 } = require("fs");
-        const existing = JSON.parse(readFileSync40(join48(root, ".gossip", "config.json"), "utf-8"));
+        const { readFileSync: readFileSync41 } = require("fs");
+        const existing = JSON.parse(readFileSync41(join49(root, ".gossip", "config.json"), "utf-8"));
         existingAgents = existing.agents || {};
       } catch {
       }
@@ -39271,9 +39479,9 @@ server.tool(
           "",
           body
         ].join("\n");
-        const agentsDir = join48(root, ".claude", "agents");
-        mkdirSync21(agentsDir, { recursive: true });
-        writeFileSync17(join48(agentsDir, `${agent.id}.md`), md, "utf-8");
+        const agentsDir = join49(root, ".claude", "agents");
+        mkdirSync22(agentsDir, { recursive: true });
+        writeFileSync18(join49(agentsDir, `${agent.id}.md`), md, "utf-8");
         nativeCreated.push(agent.id);
         configAgents[agent.id] = {
           provider: mapped.provider,
@@ -39291,8 +39499,8 @@ server.tool(
           errors.push(`${agent.id}: custom agent requires "custom_model" field`);
           continue;
         }
-        const nativeFile = join48(root, ".claude", "agents", `${agent.id}.md`);
-        const wasNative = existingAgents[agent.id]?.native || existsSync43(nativeFile);
+        const nativeFile = join49(root, ".claude", "agents", `${agent.id}.md`);
+        const wasNative = existingAgents[agent.id]?.native || existsSync44(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;
@@ -39306,9 +39514,9 @@ server.tool(
         };
         customCreated.push(agent.id);
         if (agent.instructions) {
-          const instrDir = join48(root, ".gossip", "agents", agent.id);
-          mkdirSync21(instrDir, { recursive: true });
-          writeFileSync17(join48(instrDir, "instructions.md"), agent.instructions, "utf-8");
+          const instrDir = join49(root, ".gossip", "agents", agent.id);
+          mkdirSync22(instrDir, { recursive: true });
+          writeFileSync18(join49(instrDir, "instructions.md"), agent.instructions, "utf-8");
         }
       }
     }
@@ -39322,13 +39530,13 @@ server.tool(
     } catch (err) {
       return { content: [{ type: "text", text: `Invalid config: ${err.message}` }] };
     }
-    mkdirSync21(join48(root, ".gossip"), { recursive: true });
-    writeFileSync17(join48(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
+    mkdirSync22(join49(root, ".gossip"), { recursive: true });
+    writeFileSync18(join49(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
     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 = join48(root, env.rulesDir);
-    const rulesFile = join48(root, env.rulesFile);
-    mkdirSync21(rulesDir, { recursive: true });
-    writeFileSync17(rulesFile, generateRulesContent(agentList));
+    const rulesDir = join49(root, env.rulesDir);
+    const rulesFile = join49(root, env.rulesFile);
+    mkdirSync22(rulesDir, { recursive: true });
+    writeFileSync18(rulesFile, generateRulesContent(agentList));
     const lines = [`Host: ${env.host}`, ""];
     if (nativeCreated.length > 0) {
       lines.push(`Native agents created (${nativeCreated.length}):`);
@@ -40034,9 +40242,11 @@ server.tool(
     skills: external_exports.array(external_exports.object({
       name: external_exports.string().describe("Skill name (kebab-case)"),
       content: external_exports.string().describe("Full .md content with frontmatter")
-    })).optional().describe("For build: generated skill files to save. Omit for discovery mode.")
+    })).optional().describe("For build: generated skill files to save. Omit for discovery mode."),
+    // Internal: re-entry param for native-utility dispatch path (develop action only)
+    _utility_task_id: external_exports.string().optional().describe("Internal: utility task ID for re-entry after native skill generation")
   },
-  async ({ action, agent_id, skill, enabled, category, skill_names, skills }) => {
+  async ({ action, agent_id, skill, enabled, category, skill_names, skills, _utility_task_id }) => {
     await boot();
     if (action === "list") {
       const index = ctx.mainAgent.getSkillIndex();
@@ -40092,6 +40302,98 @@ ${sections.join("\n\n")}` }] };
       if (!ctx.skillEngine) {
         return { content: [{ type: "text", text: "Skill engine not available. Check boot logs." }] };
       }
+      if (_utility_task_id) {
+        const stashedMeta = _pendingSkillData.get(_utility_task_id);
+        _pendingSkillData.delete(_utility_task_id);
+        const utilityResult = ctx.nativeResultMap.get(_utility_task_id);
+        ctx.nativeResultMap.delete(_utility_task_id);
+        ctx.nativeTaskMap.delete(_utility_task_id);
+        if (utilityResult?.status === "completed" && utilityResult.result && stashedMeta) {
+          try {
+            const result = ctx.skillEngine.saveFromRaw(agent_id, category, utilityResult.result, stashedMeta);
+            const { normalizeSkillName: nsn } = await Promise.resolve().then(() => (init_src4(), src_exports3));
+            const skillName = nsn(category);
+            if (ctx.mainAgent) {
+              const skillIndex = ctx.mainAgent.getSkillIndex();
+              if (skillIndex) {
+                skillIndex.bind(agent_id, skillName, { source: "auto", mode: "permanent" });
+              }
+              const registry2 = ctx.mainAgent.registry;
+              const agentConfig = registry2?.get(agent_id);
+              const normalizedCategory = nsn(category);
+              if (agentConfig && !agentConfig.skills.includes(normalizedCategory)) {
+                agentConfig.skills.push(normalizedCategory);
+              }
+              const pipeline = ctx.mainAgent.pipeline;
+              if (pipeline?.suppressSkillGapAlert) {
+                pipeline.suppressSkillGapAlert(agent_id, category);
+              }
+            }
+            const preview = result.content.length > 1e3 ? result.content.slice(0, 1e3) + "\n\n... (truncated)" : result.content;
+            process.stderr.write(`[gossipcat] Skill developed (native): "${skillName}" for ${agent_id} (category: ${category})
+`);
+            return {
+              content: [{ type: "text", text: `Skill generated and saved:
+
+Path: ${result.path}
+
+Auto-bound "${skillName}" to ${agent_id} in skill index.
+
+${preview}` }]
+            };
+          } catch (err) {
+            process.stderr.write(`[gossipcat] Skill develop native post-processing failed: ${err.message}
+`);
+            return {
+              content: [{ type: "text", text: `Skill generation failed: ${err.message}` }]
+            };
+          }
+        } else {
+          process.stderr.write(`[gossipcat] Skill develop utility ${_utility_task_id} failed/missing, falling back to direct LLM
+`);
+        }
+      }
+      if (ctx.nativeUtilityConfig && !_utility_task_id) {
+        try {
+          const { system, user, skillName, skillPath, baseline_accuracy_correct, baseline_accuracy_hallucinated, bound_at } = await ctx.skillEngine.buildPrompt(agent_id, category);
+          const taskId = (0, import_crypto17.randomUUID)().slice(0, 8);
+          _pendingSkillData.set(taskId, { agentId: agent_id, category, skillName, skillPath, baseline_accuracy_correct, baseline_accuracy_hallucinated, bound_at });
+          ctx.nativeTaskMap.set(taskId, {
+            agentId: "_utility",
+            task: `skill_develop:${category}`,
+            startedAt: Date.now(),
+            timeoutMs: 12e4,
+            utilityType: "skill_develop"
+          });
+          spawnTimeoutWatcher(taskId, ctx.nativeTaskMap.get(taskId));
+          const modelShort = ctx.nativeUtilityConfig.model;
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Skill prompt built. Dispatching native utility for generation.
+
+\u26A0\uFE0F EXECUTE NOW \u2014 launch this Agent and re-call gossip_skills:
+
+1. Agent(model: "${modelShort}", prompt: <AGENT_PROMPT:${taskId} below>, run_in_background: true) \u2014 pass the AGENT_PROMPT:${taskId} content item verbatim
+2. When agent completes \u2192 gossip_relay(task_id: "${taskId}", result: "<full agent output>")
+3. Then re-call: gossip_skills(action: "develop", agent_id: "${agent_id}", category: "${category}", _utility_task_id: "${taskId}")
+
+Do ALL steps in order. Do not wait for user input between them.`
+              },
+              { type: "text", text: `AGENT_PROMPT:${taskId} (_utility)
+${system}
+
+---
+
+${user}` }
+            ]
+          };
+        } catch (err) {
+          process.stderr.write(`[gossipcat] Skill develop native prompt build failed: ${err.message}, falling back to direct LLM
+`);
+        }
+      }
       try {
         const result = await ctx.skillEngine.generate(agent_id, category);
         const { normalizeSkillName: nsn } = await Promise.resolve().then(() => (init_src4(), src_exports3));
@@ -40135,16 +40437,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: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43, readFileSync: readFileSync40 } = require("fs");
-      const { join: join48 } = require("path");
-      const dir = join48(process.cwd(), ".gossip", "skills");
-      mkdirSync21(dir, { recursive: true });
+      const { writeFileSync: writeFileSync18, mkdirSync: mkdirSync22, existsSync: existsSync44, readFileSync: readFileSync41 } = require("fs");
+      const { join: join49 } = require("path");
+      const dir = join49(process.cwd(), ".gossip", "skills");
+      mkdirSync22(dir, { recursive: true });
       const results = [];
       for (const sk of skills) {
         const name = normalizeSkillName2(sk.name);
-        const filePath = join48(dir, `${name}.md`);
-        if (existsSync43(filePath)) {
-          const existing = readFileSync40(filePath, "utf-8");
+        const filePath = join49(dir, `${name}.md`);
+        if (existsSync44(filePath)) {
+          const existing = readFileSync41(filePath, "utf-8");
           const fm = parseSkillFrontmatter2(existing);
           if (fm) {
             if (fm.generated_by === "manual") {
@@ -40161,7 +40463,7 @@ ${preview}` }]
             }
           }
         }
-        writeFileSync17(filePath, sk.content);
+        writeFileSync18(filePath, sk.content);
         tracker.recordResolution(name);
         results.push(`Created .gossip/skills/${name}.md`);
       }
@@ -40205,9 +40507,10 @@ server.tool(
   "Save a cognitive session summary to project memory. The next session will load this context automatically on MCP connect. Call before ending your session to preserve what was learned.",
   {
     notes: external_exports.string().optional().describe('Optional freeform user context (e.g., "focusing on security hardening")'),
+    force: external_exports.boolean().optional().describe("Bypass the refuse-gate for pending native tasks / consensus rounds. Audited to .gossip/forced-saves.jsonl."),
     _utility_task_id: external_exports.string().optional().describe("Internal: utility task ID for re-entry after native session summary")
   },
-  async ({ notes, _utility_task_id }) => {
+  async ({ notes, force, _utility_task_id }) => {
     await boot();
     if (_utility_task_id) {
       const stashed = _pendingSessionData.get(_utility_task_id);
@@ -40308,6 +40611,48 @@ server.tool(
 
 ${summary2}` }] };
     }
+    {
+      const pendingNative = [];
+      for (const [taskId, info] of ctx.nativeTaskMap) {
+        if (!ctx.nativeResultMap.has(taskId)) pendingNative.push(`${taskId} (${info.agentId})`);
+      }
+      const pendingConsensus = [];
+      const now = Date.now();
+      for (const [cid, round] of ctx.pendingConsensusRounds) {
+        if (round.deadline && now > round.deadline) continue;
+        if (round.pendingNativeAgents && round.pendingNativeAgents.size > 0) {
+          pendingConsensus.push(`${cid} (${round.pendingNativeAgents.size} agents)`);
+        }
+      }
+      if ((pendingNative.length > 0 || pendingConsensus.length > 0) && !force) {
+        const lines = ["\u26D4 session_save refused \u2014 work still in flight.\n"];
+        if (pendingNative.length > 0) {
+          lines.push(`Pending native tasks (${pendingNative.length}):`);
+          for (const t of pendingNative.slice(0, 10)) lines.push(`  - ${t}`);
+          lines.push("");
+        }
+        if (pendingConsensus.length > 0) {
+          lines.push(`Pending consensus rounds (${pendingConsensus.length}):`);
+          for (const c of pendingConsensus.slice(0, 10)) lines.push(`  - ${c}`);
+          lines.push("");
+        }
+        lines.push("Relay the results via gossip_relay / gossip_relay_cross_review, then re-call gossip_session_save.");
+        lines.push("To override (snapshot is intentional / tasks are abandoned): gossip_session_save(force: true).");
+        return { content: [{ type: "text", text: lines.join("\n") }], isError: true };
+      }
+      if (force && (pendingNative.length > 0 || pendingConsensus.length > 0)) {
+        try {
+          const { appendFileSync: af, mkdirSync: md } = require("fs");
+          const { join: j } = require("path");
+          md(j(process.cwd(), ".gossip"), { recursive: true });
+          af(
+            j(process.cwd(), ".gossip", "forced-saves.jsonl"),
+            JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), pendingNative, pendingConsensus, notes: notes || null }) + "\n"
+          );
+        } catch {
+        }
+      }
+    }
     let gossipText = "";
     try {
       const { existsSync: ex, readFileSync: rf } = require("fs");
@@ -40677,6 +41022,7 @@ server.tool(
       { name: "gossip_remember", desc: "Search an agent's archived knowledge files by keyword query." },
       { name: "gossip_verify_memory", desc: "On-demand staleness check for a memory file claim. Returns FRESH | STALE | CONTRADICTED | INCONCLUSIVE with file:line evidence." },
       { name: "gossip_tools", desc: "List available tools (this command)." },
+      { name: "gossip_guide", desc: "Show the gossipcat handbook for humans \u2014 invariants, operator playbook, caveats, hallucination patterns, glossary. Read the docs, not LLM context." },
       { name: "gossip_progress", desc: "Show active task progress and consensus phase. No params." },
       { name: "gossip_format", desc: "Return the CONSENSUS_OUTPUT_FORMAT block to paste into ad-hoc Agent() prompts so native subagents emit parseable <agent_finding> tags." },
       { name: "gossip_bug_feedback", desc: "File a GitHub issue on the gossipcat repo from an in-session bug report. Dedupes against open issues." }
@@ -40888,8 +41234,10 @@ function touchSession(sid) {
 `);
   }, HTTP_SESSION_TTL_MS);
 }
-function startHttpMcpTransport() {
-  const port = parseInt(process.env.GOSSIPCAT_HTTP_PORT ?? "24421", 10);
+async function startHttpMcpTransport() {
+  const httpPick = await pickStickyPort("GOSSIPCAT_HTTP_PORT", HTTP_MCP_STICKY_FILE);
+  const port = httpPick.source === "auto" ? 24421 : httpPick.port;
+  ctx.httpMcpPortSource = httpPick.source;
   const token = process.env.GOSSIPCAT_HTTP_TOKEN ?? "";
   const bindHost = process.env.GOSSIPCAT_HTTP_BIND === "0.0.0.0" && token ? "0.0.0.0" : "127.0.0.1";
   const tokenBuf = token ? Buffer.from(token) : null;
@@ -40983,9 +41331,13 @@ function startHttpMcpTransport() {
     res.end(JSON.stringify({ error: "Bad request" }));
   });
   httpServer.listen(port, bindHost, () => {
+    const addr = httpServer.address();
+    const bound = typeof addr === "object" && addr ? addr.port : port;
+    ctx.httpMcpPort = bound;
+    if (bound > 0) writeStickyPort(HTTP_MCP_STICKY_FILE, bound);
     const authNote = token ? " (token protected)" : " (no auth \u2014 set GOSSIPCAT_HTTP_TOKEN to secure)";
     const bindNote = bindHost === "0.0.0.0" ? " [remote]" : " [localhost only]";
-    process.stderr.write(`[gossipcat] HTTP MCP listening on :${port}/mcp${authNote}${bindNote}
+    process.stderr.write(`[gossipcat] HTTP MCP listening on :${bound}/mcp${authNote}${bindNote}
 `);
   });
   httpServer.on("error", (err) => {