gossipcat 0.1.0 → 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");
@@ -69,6 +72,46 @@ var init_mcp_context = __esm({
   }
 });
 
+// apps/cli/src/version.ts
+var version_exports = {};
+__export(version_exports, {
+  getGossipcatVersion: () => getGossipcatVersion
+});
+function getGossipcatVersion() {
+  if (cached2 !== null) return cached2;
+  cached2 = resolveVersion();
+  return cached2;
+}
+function resolveVersion() {
+  let dir = __dirname;
+  const root = (0, import_path.resolve)("/");
+  for (let i = 0; i < 20 && dir !== root; i++) {
+    const candidate = (0, import_path.resolve)(dir, "package.json");
+    if ((0, import_fs.existsSync)(candidate)) {
+      try {
+        const pkg = JSON.parse((0, import_fs.readFileSync)(candidate, "utf-8"));
+        if (pkg && pkg.name === "gossipcat" && typeof pkg.version === "string") {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    const parent = (0, import_path.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "unknown";
+}
+var import_fs, import_path, cached2;
+var init_version = __esm({
+  "apps/cli/src/version.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    cached2 = null;
+  }
+});
+
 // packages/orchestrator/src/llm-client.ts
 async function fetchWithRetry503(url2, init, providerName) {
   const res = await fetch(url2, init);
@@ -108,13 +151,13 @@ function createProvider(provider, model, apiKey, projectRoot, baseUrl) {
       throw new Error(`Unknown provider: ${provider}`);
   }
 }
-var import_crypto, import_fs, import_path, QuotaExhaustedException, QuotaTracker, AnthropicProvider, OpenAIProvider, GeminiProvider, OllamaProvider, NullProvider;
+var import_crypto, import_fs2, import_path2, QuotaExhaustedException, QuotaTracker, AnthropicProvider, OpenAIProvider, GeminiProvider, OllamaProvider, NullProvider;
 var init_llm_client = __esm({
   "packages/orchestrator/src/llm-client.ts"() {
     "use strict";
     import_crypto = require("crypto");
-    import_fs = require("fs");
-    import_path = require("path");
+    import_fs2 = require("fs");
+    import_path2 = require("path");
     QuotaExhaustedException = class extends Error {
       provider;
       retryAfterMs;
@@ -128,7 +171,7 @@ var init_llm_client = __esm({
     QuotaTracker = class {
       constructor(provider, projectRoot) {
         this.provider = provider;
-        this.statePath = projectRoot ? (0, import_path.join)(projectRoot, ".gossip", "quota-state.json") : null;
+        this.statePath = projectRoot ? (0, import_path2.join)(projectRoot, ".gossip", "quota-state.json") : null;
         this.load();
       }
       consecutive429s = 0;
@@ -136,9 +179,9 @@ var init_llm_client = __esm({
       reason = "quota";
       statePath;
       load() {
-        if (!this.statePath || !(0, import_fs.existsSync)(this.statePath)) return;
+        if (!this.statePath || !(0, import_fs2.existsSync)(this.statePath)) return;
         try {
-          const state = JSON.parse((0, import_fs.readFileSync)(this.statePath, "utf-8"));
+          const state = JSON.parse((0, import_fs2.readFileSync)(this.statePath, "utf-8"));
           if (state[this.provider]) {
             this.exhaustedUntil = state[this.provider].exhaustedUntil;
             this.consecutive429s = state[this.provider].consecutive429s;
@@ -150,15 +193,15 @@ var init_llm_client = __esm({
       persist() {
         if (!this.statePath) return;
         try {
-          const dir = (0, import_path.join)(this.statePath, "..");
-          if (!(0, import_fs.existsSync)(dir)) (0, import_fs.mkdirSync)(dir, { recursive: true });
+          const dir = (0, import_path2.join)(this.statePath, "..");
+          if (!(0, import_fs2.existsSync)(dir)) (0, import_fs2.mkdirSync)(dir, { recursive: true });
           let existing = {};
           try {
-            existing = JSON.parse((0, import_fs.readFileSync)(this.statePath, "utf-8"));
+            existing = JSON.parse((0, import_fs2.readFileSync)(this.statePath, "utf-8"));
           } catch {
           }
           existing[this.provider] = { exhaustedUntil: this.exhaustedUntil, consecutive429s: this.consecutive429s, reason: this.reason };
-          (0, import_fs.writeFileSync)(this.statePath, JSON.stringify(existing, null, 2));
+          (0, import_fs2.writeFileSync)(this.statePath, JSON.stringify(existing, null, 2));
         } catch {
         }
       }
@@ -3078,7 +3121,7 @@ var init_gossip_agent = __esm({
       }
       // ─── Public API ─────────────────────────────────────────────────────────────
       connect() {
-        return new Promise((resolve17, reject) => {
+        return new Promise((resolve18, reject) => {
           const ws = new import_ws.default(this.config.relayUrl);
           const timeout = setTimeout(() => {
             ws.removeAllListeners();
@@ -3111,7 +3154,7 @@ var init_gossip_agent = __esm({
                   ws.on("error", (err) => this.emit("error", err));
                   this.startKeepAlive();
                   this.emit("connect", msg.sessionId);
-                  resolve17();
+                  resolve18();
                 } else if (msg.type === "error") {
                   clearTimeout(timeout);
                   ws.removeAllListeners();
@@ -3137,7 +3180,7 @@ var init_gossip_agent = __esm({
           this.reconnectTimer = null;
         }
         if (!this.ws) return;
-        return new Promise((resolve17) => {
+        return new Promise((resolve18) => {
           this.intentionalDisconnect = true;
           this._connected = false;
           const ws = this.ws;
@@ -3148,7 +3191,7 @@ var init_gossip_agent = __esm({
             settled = true;
             this.intentionalDisconnect = false;
             this.emit("disconnect", code);
-            resolve17();
+            resolve18();
           };
           const timer = setTimeout(() => done(1e3), 2e3);
           ws.once("close", (code) => {
@@ -3187,8 +3230,8 @@ var init_gossip_agent = __esm({
           throw new Error("Not connected to relay");
         }
         const encoded = Buffer.from(this.codec.encode(envelope));
-        return new Promise((resolve17, reject) => {
-          this.ws.send(encoded, (err) => err ? reject(err) : resolve17());
+        return new Promise((resolve18, reject) => {
+          this.ws.send(encoded, (err) => err ? reject(err) : resolve18());
         });
       }
       // ─── Internal ────────────────────────────────────────────────────────────────
@@ -3632,7 +3675,7 @@ ${context}` : ""}
           this.toolCallBudget.set(name, used + 1);
         }
         const requestId = (0, import_crypto4.randomUUID)();
-        const resultPromise = new Promise((resolve17, reject) => {
+        const resultPromise = new Promise((resolve18, reject) => {
           const timer = setTimeout(() => {
             if (this.pendingToolCalls.has(requestId)) {
               this.pendingToolCalls.delete(requestId);
@@ -3643,7 +3686,7 @@ ${context}` : ""}
           this.pendingToolCalls.set(requestId, {
             resolve: (r) => {
               clearTimeout(timer);
-              resolve17(r);
+              resolve18(r);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -3708,12 +3751,12 @@ ${context}` : ""}
 });
 
 // packages/tools/src/file-tools.ts
-var import_promises, import_path2, FileTools;
+var import_promises, import_path3, FileTools;
 var init_file_tools = __esm({
   "packages/tools/src/file-tools.ts"() {
     "use strict";
     import_promises = require("fs/promises");
-    import_path2 = require("path");
+    import_path3 = require("path");
     FileTools = class {
       constructor(sandbox) {
         this.sandbox = sandbox;
@@ -3738,7 +3781,7 @@ var init_file_tools = __esm({
       }
       async fileWrite(args) {
         const absPath = this.sandbox.validatePath(args.path);
-        const dir = (0, import_path2.resolve)(absPath, "..");
+        const dir = (0, import_path3.resolve)(absPath, "..");
         await (0, import_promises.mkdir)(dir, { recursive: true });
         await (0, import_promises.writeFile)(absPath, args.content, "utf-8");
         return `Written ${args.content.length} bytes to ${args.path}`;
@@ -3783,7 +3826,7 @@ var init_file_tools = __esm({
         }
         for (const entry of entries) {
           if (entry === "node_modules" || entry === ".git") continue;
-          const fullPath = (0, import_path2.join)(dir, entry);
+          const fullPath = (0, import_path3.join)(dir, entry);
           let info;
           try {
             info = await (0, import_promises.stat)(fullPath);
@@ -3795,7 +3838,7 @@ var init_file_tools = __esm({
           } else {
             const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
             const regex = new RegExp(regexStr);
-            const relPath = (0, import_path2.relative)(this.sandbox.projectRoot, fullPath);
+            const relPath = (0, import_path3.relative)(this.sandbox.projectRoot, fullPath);
             if (regex.test(entry) || regex.test(relPath)) {
               results.push(relPath);
             }
@@ -3812,7 +3855,7 @@ var init_file_tools = __esm({
         }
         for (const entry of entries) {
           if (entry === "node_modules" || entry === ".git") continue;
-          const fullPath = (0, import_path2.join)(dir, entry);
+          const fullPath = (0, import_path3.join)(dir, entry);
           let info;
           try {
             info = await (0, import_promises.stat)(fullPath);
@@ -3825,7 +3868,7 @@ var init_file_tools = __esm({
             try {
               const content = await (0, import_promises.readFile)(fullPath, "utf-8");
               const lines = content.split("\n");
-              const relPath = (0, import_path2.relative)(this.sandbox.projectRoot, fullPath);
+              const relPath = (0, import_path3.relative)(this.sandbox.projectRoot, fullPath);
               lines.forEach((line, idx) => {
                 if (regex.test(line)) {
                   results.push(`${relPath}:${idx + 1}: ${line}`);
@@ -3849,7 +3892,7 @@ var init_file_tools = __esm({
           const entry = filtered[i];
           const isLast = i === filtered.length - 1;
           const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-          const fullPath = (0, import_path2.join)(dir, entry);
+          const fullPath = (0, import_path3.join)(dir, entry);
           let info;
           try {
             info = await (0, import_promises.stat)(fullPath);
@@ -4054,20 +4097,20 @@ var init_git_tools = __esm({
 });
 
 // packages/tools/src/skill-tools.ts
-var import_fs2, import_path3, SkillTools;
+var import_fs3, import_path4, SkillTools;
 var init_skill_tools = __esm({
   "packages/tools/src/skill-tools.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path3 = require("path");
+    import_fs3 = require("fs");
+    import_path4 = require("path");
     SkillTools = class {
       gapLogPath;
       constructor(projectRoot) {
-        const gossipDir2 = (0, import_path3.join)(projectRoot, ".gossip");
-        if (!(0, import_fs2.existsSync)(gossipDir2)) {
-          (0, import_fs2.mkdirSync)(gossipDir2, { recursive: true });
+        const gossipDir2 = (0, import_path4.join)(projectRoot, ".gossip");
+        if (!(0, import_fs3.existsSync)(gossipDir2)) {
+          (0, import_fs3.mkdirSync)(gossipDir2, { recursive: true });
         }
-        this.gapLogPath = (0, import_path3.join)(gossipDir2, "skill-gaps.jsonl");
+        this.gapLogPath = (0, import_path4.join)(gossipDir2, "skill-gaps.jsonl");
       }
       async suggestSkill(args, callerId) {
         const entry = {
@@ -4078,16 +4121,16 @@ var init_skill_tools = __esm({
           task_context: args.task_context,
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        (0, import_fs2.appendFileSync)(this.gapLogPath, JSON.stringify(entry) + "\n");
+        (0, import_fs3.appendFileSync)(this.gapLogPath, JSON.stringify(entry) + "\n");
         this.truncateIfNeeded();
         return `Suggestion noted: '${args.skill_name}'. Continue with your current skills.`;
       }
       truncateIfNeeded() {
         try {
-          const content = (0, import_fs2.readFileSync)(this.gapLogPath, "utf-8");
+          const content = (0, import_fs3.readFileSync)(this.gapLogPath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           if (lines.length > 5e3) {
-            (0, import_fs2.writeFileSync)(this.gapLogPath, lines.slice(-1e3).join("\n") + "\n");
+            (0, import_fs3.writeFileSync)(this.gapLogPath, lines.slice(-1e3).join("\n") + "\n");
           }
         } catch {
         }
@@ -4097,16 +4140,16 @@ var init_skill_tools = __esm({
 });
 
 // packages/tools/src/sandbox.ts
-var import_path4, import_fs3, Sandbox;
+var import_path5, import_fs4, Sandbox;
 var init_sandbox = __esm({
   "packages/tools/src/sandbox.ts"() {
     "use strict";
-    import_path4 = require("path");
-    import_fs3 = require("fs");
+    import_path5 = require("path");
+    import_fs4 = require("fs");
     Sandbox = class {
       root;
       constructor(projectRoot) {
-        this.root = (0, import_fs3.realpathSync)((0, import_path4.resolve)(projectRoot));
+        this.root = (0, import_fs4.realpathSync)((0, import_path5.resolve)(projectRoot));
       }
       get projectRoot() {
         return this.root;
@@ -4118,14 +4161,14 @@ var init_sandbox = __esm({
        * Resolves symlinks to prevent symlink escape attacks.
        */
       validatePath(filePath) {
-        const resolved = (0, import_path4.resolve)(this.root, filePath);
+        const resolved = (0, import_path5.resolve)(this.root, filePath);
         let checkPath = resolved;
-        while (!(0, import_fs3.existsSync)(checkPath)) {
-          const parent = (0, import_path4.dirname)(checkPath);
+        while (!(0, import_fs4.existsSync)(checkPath)) {
+          const parent = (0, import_path5.dirname)(checkPath);
           if (parent === checkPath) break;
           checkPath = parent;
         }
-        const real = (0, import_fs3.existsSync)(checkPath) ? (0, import_fs3.realpathSync)(checkPath) : checkPath;
+        const real = (0, import_fs4.existsSync)(checkPath) ? (0, import_fs4.realpathSync)(checkPath) : checkPath;
         const remainder = resolved.slice(checkPath.length);
         const fullReal = real + remainder;
         if (!fullReal.startsWith(this.root + "/") && fullReal !== this.root) {
@@ -8343,16 +8386,16 @@ var init_tool_schemas = __esm({
 // packages/tools/src/tool-server.ts
 function canonicalizeForBoundary(p) {
   let out = p;
-  if ((0, import_fs4.existsSync)(out)) {
+  if ((0, import_fs5.existsSync)(out)) {
     try {
-      out = (0, import_fs4.realpathSync)(out);
+      out = (0, import_fs5.realpathSync)(out);
     } catch {
     }
   } else {
-    const parent = (0, import_path5.dirname)(out);
-    if (parent !== out && (0, import_fs4.existsSync)(parent)) {
+    const parent = (0, import_path6.dirname)(out);
+    if (parent !== out && (0, import_fs5.existsSync)(parent)) {
       try {
-        out = (0, import_path5.join)((0, import_fs4.realpathSync)(parent), (0, import_path5.basename)(out));
+        out = (0, import_path6.join)((0, import_fs5.realpathSync)(parent), (0, import_path6.basename)(out));
       } catch {
       }
     }
@@ -8385,7 +8428,7 @@ function truncateAtLine(text, maxLength) {
   const cut = text.lastIndexOf("\n", maxLength);
   return text.slice(0, cut !== -1 ? cut : maxLength);
 }
-var import_msgpack4, import_crypto5, import_path5, import_fs4, CASE_INSENSITIVE_FS, ToolServer;
+var import_msgpack4, import_crypto5, import_path6, import_fs5, CASE_INSENSITIVE_FS, ToolServer;
 var init_tool_server = __esm({
   "packages/tools/src/tool-server.ts"() {
     "use strict";
@@ -8399,8 +8442,8 @@ var init_tool_server = __esm({
     init_skill_tools();
     init_sandbox();
     init_tool_schemas();
-    import_path5 = require("path");
-    import_fs4 = require("fs");
+    import_path6 = require("path");
+    import_fs5 = require("fs");
     CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
     ToolServer = class _ToolServer {
       agent;
@@ -8455,12 +8498,12 @@ var init_tool_server = __esm({
         return this.agent.agentId;
       }
       assignScope(agentId, scope) {
-        const abs = (0, import_path5.resolve)(this.sandbox.projectRoot, scope);
+        const abs = (0, import_path6.resolve)(this.sandbox.projectRoot, scope);
         this.agentScopes.set(agentId, canonicalizeForBoundary(abs));
         this.writeAgents.add(agentId);
       }
       assignRoot(agentId, root) {
-        const abs = (0, import_path5.resolve)(root);
+        const abs = (0, import_path6.resolve)(root);
         this.agentRoots.set(agentId, canonicalizeForBoundary(abs));
         this.writeAgents.add(agentId);
       }
@@ -8520,13 +8563,13 @@ var init_tool_server = __esm({
         if (toolName === "file_write") {
           const filePath = args.path;
           if (scope) {
-            const canonical = canonicalizeForBoundary((0, import_path5.resolve)(this.sandbox.projectRoot, filePath));
+            const canonical = canonicalizeForBoundary((0, import_path6.resolve)(this.sandbox.projectRoot, filePath));
             if (!canonical.startsWith(scope)) {
               throw new Error(`Write blocked: "${filePath}" is outside scope "${scope}"`);
             }
           }
           if (root) {
-            const canonical = canonicalizeForBoundary((0, import_path5.resolve)(root, filePath));
+            const canonical = canonicalizeForBoundary((0, import_path6.resolve)(root, filePath));
             if (!canonical.startsWith(root)) {
               throw new Error(`Write blocked: "${filePath}" is outside worktree root "${root}"`);
             }
@@ -8561,13 +8604,13 @@ var init_tool_server = __esm({
         if (toolName === "file_delete") {
           const filePath = args.path;
           if (scope) {
-            const canonical = canonicalizeForBoundary((0, import_path5.resolve)(this.sandbox.projectRoot, filePath));
+            const canonical = canonicalizeForBoundary((0, import_path6.resolve)(this.sandbox.projectRoot, filePath));
             if (!canonical.startsWith(scope)) {
               throw new Error(`Delete blocked: "${filePath}" is outside scope "${scope}"`);
             }
           }
           if (root) {
-            const canonical = canonicalizeForBoundary((0, import_path5.resolve)(root, filePath));
+            const canonical = canonicalizeForBoundary((0, import_path6.resolve)(root, filePath));
             if (!canonical.startsWith(root)) {
               throw new Error(`Delete blocked: "${filePath}" is outside worktree root "${root}"`);
             }
@@ -8603,7 +8646,7 @@ var init_tool_server = __esm({
           case "file_read": {
             const readScope = callerId ? this.agentScopes.get(callerId) : void 0;
             if (readScope) {
-              const canonical = canonicalizeForBoundary((0, import_path5.resolve)(this.sandbox.projectRoot, args.path));
+              const canonical = canonicalizeForBoundary((0, import_path6.resolve)(this.sandbox.projectRoot, args.path));
               if (!canonical.startsWith(readScope)) {
                 throw new Error(`Read blocked: "${args.path}" is outside scope "${readScope}"`);
               }
@@ -8797,7 +8840,7 @@ ${truncateAtLine(fullDiff, 3e3)}`;
       }
       async requestPeerReview(callerId, diff, testResult) {
         const requestId = (0, import_crypto5.randomUUID)();
-        const reviewPromise = new Promise((resolve17, reject) => {
+        const reviewPromise = new Promise((resolve18, reject) => {
           const timer = setTimeout(() => {
             this.pendingReviews.delete(requestId);
             reject(new Error("Review timed out"));
@@ -8806,7 +8849,7 @@ ${truncateAtLine(fullDiff, 3e3)}`;
           this.pendingReviews.set(requestId, {
             resolve: (r) => {
               clearTimeout(timer);
-              resolve17(r);
+              resolve18(r);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -8832,7 +8875,7 @@ ${truncateAtLine(fullDiff, 3e3)}`;
       }
       async handleRunTests(args, callerId) {
         const { fileGlob } = args;
-        const resolvedGlob = (0, import_path5.resolve)(this.sandbox.projectRoot, fileGlob.replace(/\*/g, "_"));
+        const resolvedGlob = (0, import_path6.resolve)(this.sandbox.projectRoot, fileGlob.replace(/\*/g, "_"));
         if (!resolvedGlob.startsWith(this.sandbox.projectRoot)) {
           throw new Error("run_tests: fileGlob must not contain path traversal");
         }
@@ -8840,7 +8883,7 @@ ${truncateAtLine(fullDiff, 3e3)}`;
           throw new Error("run_tests: fileGlob must not contain flags. Pass only file paths/globs.");
         }
         const scope = callerId ? this.agentScopes.get(callerId) : void 0;
-        const cwd = scope ? this.sandbox.validatePath((0, import_path5.resolve)(this.sandbox.projectRoot, scope)) : this.sandbox.projectRoot;
+        const cwd = scope ? this.sandbox.validatePath((0, import_path6.resolve)(this.sandbox.projectRoot, scope)) : this.sandbox.projectRoot;
         let output;
         let success2;
         try {
@@ -8860,11 +8903,11 @@ ${truncateAtLine(fullDiff, 3e3)}`;
       }
       async handleRunTypecheck(callerId) {
         const scope = callerId ? this.agentScopes.get(callerId) : void 0;
-        const cwd = scope ? this.sandbox.validatePath((0, import_path5.resolve)(this.sandbox.projectRoot, scope)) : this.sandbox.projectRoot;
+        const cwd = scope ? this.sandbox.validatePath((0, import_path6.resolve)(this.sandbox.projectRoot, scope)) : this.sandbox.projectRoot;
         let output;
         let success2;
         try {
-          const tsconfigPath = (0, import_path5.resolve)(this.sandbox.projectRoot, "tsconfig.json");
+          const tsconfigPath = (0, import_path6.resolve)(this.sandbox.projectRoot, "tsconfig.json");
           output = await this.shellTools.shellExec({
             command: "npx",
             args: ["tsc", "--noEmit", "--project", tsconfigPath],
@@ -9179,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 });
@@ -9247,16 +9301,16 @@ function resolveSkill(agentId, skill, projectRoot) {
   if (!normalized) return null;
   const filename = `${normalized}.md`;
   const bases = [
-    (0, import_path6.resolve)(projectRoot, ".gossip", "agents", agentId, "skills"),
-    (0, import_path6.resolve)(projectRoot, ".gossip", "skills"),
-    (0, import_path6.resolve)(__dirname, "default-skills")
+    (0, import_path7.resolve)(projectRoot, ".gossip", "agents", agentId, "skills"),
+    (0, import_path7.resolve)(projectRoot, ".gossip", "skills"),
+    (0, import_path7.resolve)(__dirname, "default-skills")
   ];
   for (const base of bases) {
-    const candidate = (0, import_path6.resolve)(base, filename);
-    if (!candidate.startsWith(base + import_path6.sep)) continue;
-    if ((0, import_fs5.existsSync)(candidate)) {
+    const candidate = (0, import_path7.resolve)(base, filename);
+    if (!candidate.startsWith(base + import_path7.sep)) continue;
+    if ((0, import_fs6.existsSync)(candidate)) {
       try {
-        return (0, import_fs5.readFileSync)(candidate, "utf-8");
+        return (0, import_fs6.readFileSync)(candidate, "utf-8");
       } catch (err) {
         process.stderr.write(
           `[skill-loader] Failed to read skill file ${candidate}: ${err?.message ?? err}
@@ -9271,12 +9325,12 @@ function resolveSkill(agentId, skill, projectRoot) {
 function resolveSkillExists(agentId, skill, projectRoot) {
   return resolveSkill(agentId, skill, projectRoot) !== null;
 }
-var import_fs5, import_path6, SAFE_AGENT_ID, MAX_CONTEXTUAL_SKILLS, MIN_KEYWORD_HITS, DEFAULT_KEYWORDS, patternCache, MAX_PATTERN_CACHE, MAX_KEYWORD_LENGTH;
+var import_fs6, import_path7, SAFE_AGENT_ID, MAX_CONTEXTUAL_SKILLS, MIN_KEYWORD_HITS, DEFAULT_KEYWORDS, patternCache, MAX_PATTERN_CACHE, MAX_KEYWORD_LENGTH;
 var init_skill_loader = __esm({
   "packages/orchestrator/src/skill-loader.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path6 = require("path");
+    import_fs6 = require("fs");
+    import_path7 = require("path");
     init_skill_parser();
     init_skill_name();
     SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]{0,62}$/;
@@ -9475,29 +9529,29 @@ Attributes can appear in any order. Do NOT include confirmations.`;
 });
 
 // packages/orchestrator/src/agent-memory.ts
-var import_fs6, import_path7, AgentMemoryReader;
+var import_fs7, import_path8, AgentMemoryReader;
 var init_agent_memory = __esm({
   "packages/orchestrator/src/agent-memory.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path7 = require("path");
+    import_fs7 = require("fs");
+    import_path8 = require("path");
     AgentMemoryReader = class {
       constructor(projectRoot) {
         this.projectRoot = projectRoot;
       }
       loadMemory(agentId, taskText) {
-        const memDir = (0, import_path7.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
-        const indexPath = (0, import_path7.join)(memDir, "MEMORY.md");
-        if (!(0, import_fs6.existsSync)(indexPath)) return null;
+        const memDir = (0, import_path8.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
+        const indexPath = (0, import_path8.join)(memDir, "MEMORY.md");
+        if (!(0, import_fs7.existsSync)(indexPath)) return null;
         const parts = [];
-        const indexContent = (0, import_fs6.readFileSync)(indexPath, "utf-8");
+        const indexContent = (0, import_fs7.readFileSync)(indexPath, "utf-8");
         const indexLines = indexContent.split("\n");
         parts.push(indexLines.length > 200 ? indexLines.slice(0, 200).join("\n") + "\n[Truncated]" : indexContent);
-        const knowledgeDir = (0, import_path7.join)(memDir, "knowledge");
-        if ((0, import_fs6.existsSync)(knowledgeDir)) {
+        const knowledgeDir = (0, import_path8.join)(memDir, "knowledge");
+        if ((0, import_fs7.existsSync)(knowledgeDir)) {
           const files = this.selectKnowledgeFiles(knowledgeDir, taskText);
           for (const file2 of files) {
-            let content = (0, import_fs6.readFileSync)(file2.path, "utf-8");
+            let content = (0, import_fs7.readFileSync)(file2.path, "utf-8");
             content = content.replace(/<\/?(?:agent-memory|system|instructions)>/gi, "");
             parts.push(`<agent-memory>
 ${content}
@@ -9507,11 +9561,11 @@ ${content}
             }
           }
         }
-        const projectKnowledgeDir = (0, import_path7.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "knowledge");
-        if ((0, import_fs6.existsSync)(projectKnowledgeDir)) {
+        const projectKnowledgeDir = (0, import_path8.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "knowledge");
+        if ((0, import_fs7.existsSync)(projectKnowledgeDir)) {
           const projectFiles = this.selectKnowledgeFiles(projectKnowledgeDir, taskText, 3);
           for (const file2 of projectFiles) {
-            let content = (0, import_fs6.readFileSync)(file2.path, "utf-8");
+            let content = (0, import_fs7.readFileSync)(file2.path, "utf-8");
             content = content.replace(/<\/?(?:agent-memory|system|instructions)>/gi, "");
             parts.push(`<project-context>
 ${content}
@@ -9521,19 +9575,19 @@ ${content}
             }
           }
         }
-        const calPath = (0, import_path7.join)(memDir, "calibration", "accuracy.md");
-        if ((0, import_fs6.existsSync)(calPath)) {
-          parts.push((0, import_fs6.readFileSync)(calPath, "utf-8"));
+        const calPath = (0, import_path8.join)(memDir, "calibration", "accuracy.md");
+        if ((0, import_fs7.existsSync)(calPath)) {
+          parts.push((0, import_fs7.readFileSync)(calPath, "utf-8"));
         }
         return parts.join("\n\n");
       }
       selectKnowledgeFiles(knowledgeDir, taskText, maxFiles = 5) {
-        const files = (0, import_fs6.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+        const files = (0, import_fs7.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
         const scored = [];
         const lower = taskText.toLowerCase();
         for (const file2 of files) {
-          const filePath = (0, import_path7.join)(knowledgeDir, file2);
-          const content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+          const filePath = (0, import_path8.join)(knowledgeDir, file2);
+          const content = (0, import_fs7.readFileSync)(filePath, "utf-8");
           const frontmatter = this.parseFrontmatter(content);
           if (frontmatter) {
             const warmth = this.calculateWarmth(frontmatter.importance, frontmatter.lastAccessed);
@@ -9547,7 +9601,7 @@ ${content}
           } else {
             const relevance = this.calculateRelevance(content.slice(0, 500), lower);
             try {
-              const mtime = (0, import_fs6.statSync)(filePath).mtimeMs;
+              const mtime = (0, import_fs7.statSync)(filePath).mtimeMs;
               const ageDays = (Date.now() - mtime) / 864e5;
               const ageFactor = 1 / (1 + ageDays / 30);
               scored.push({ path: filePath, score: Math.max(relevance * ageFactor, 0.05) });
@@ -9602,7 +9656,7 @@ ${content}
         const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         const fmEnd = content.indexOf("\n---", 4);
         if (fmEnd < 0) {
-          (0, import_fs6.writeFileSync)(filePath, content);
+          (0, import_fs7.writeFileSync)(filePath, content);
           return;
         }
         let frontmatter = content.slice(0, fmEnd);
@@ -9613,19 +9667,19 @@ ${content}
           const newCount = parseInt(countMatch[1]) + 1;
           frontmatter = frontmatter.replace(/accessCount:\s*\d+/, `accessCount: ${newCount}`);
         }
-        (0, import_fs6.writeFileSync)(filePath, frontmatter + body);
+        (0, import_fs7.writeFileSync)(filePath, frontmatter + body);
       }
     };
   }
 });
 
 // packages/orchestrator/src/memory-compactor.ts
-var import_fs7, import_path8, MAX_ARCHIVE_LINES, MemoryCompactor;
+var import_fs8, import_path9, MAX_ARCHIVE_LINES, MemoryCompactor;
 var init_memory_compactor = __esm({
   "packages/orchestrator/src/memory-compactor.ts"() {
     "use strict";
-    import_fs7 = require("fs");
-    import_path8 = require("path");
+    import_fs8 = require("fs");
+    import_path9 = require("path");
     MAX_ARCHIVE_LINES = 5e3;
     MemoryCompactor = class {
       constructor(projectRoot) {
@@ -9637,32 +9691,32 @@ var init_memory_compactor = __esm({
         return (importance ?? 0.5) * (1 / (1 + days / 30));
       }
       compactIfNeeded(agentId, maxEntries = 20) {
-        const memDir = (0, import_path8.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
-        const tasksPath = (0, import_path8.join)(memDir, "tasks.jsonl");
-        const lockPath = (0, import_path8.join)(memDir, "tasks.jsonl.lock");
-        if (!(0, import_fs7.existsSync)(tasksPath)) return { archived: 0 };
-        if ((0, import_fs7.existsSync)(lockPath)) {
+        const memDir = (0, import_path9.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
+        const tasksPath = (0, import_path9.join)(memDir, "tasks.jsonl");
+        const lockPath = (0, import_path9.join)(memDir, "tasks.jsonl.lock");
+        if (!(0, import_fs8.existsSync)(tasksPath)) return { archived: 0 };
+        if ((0, import_fs8.existsSync)(lockPath)) {
           try {
-            const lockTs = parseInt((0, import_fs7.readFileSync)(lockPath, "utf-8"), 10);
+            const lockTs = parseInt((0, import_fs8.readFileSync)(lockPath, "utf-8"), 10);
             if (!Number.isNaN(lockTs) && Date.now() - lockTs < 6e4) return { archived: 0 };
-            (0, import_fs7.unlinkSync)(lockPath);
+            (0, import_fs8.unlinkSync)(lockPath);
           } catch {
             try {
-              (0, import_fs7.unlinkSync)(lockPath);
+              (0, import_fs8.unlinkSync)(lockPath);
             } catch {
               return { archived: 0 };
             }
           }
         }
         try {
-          const fd = (0, import_fs7.openSync)(lockPath, import_fs7.constants.O_WRONLY | import_fs7.constants.O_CREAT | import_fs7.constants.O_EXCL);
-          (0, import_fs7.writeFileSync)(fd, `${Date.now()}`);
-          (0, import_fs7.closeSync)(fd);
+          const fd = (0, import_fs8.openSync)(lockPath, import_fs8.constants.O_WRONLY | import_fs8.constants.O_CREAT | import_fs8.constants.O_EXCL);
+          (0, import_fs8.writeFileSync)(fd, `${Date.now()}`);
+          (0, import_fs8.closeSync)(fd);
         } catch {
           return { archived: 0 };
         }
         try {
-          const lines = (0, import_fs7.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs8.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
           if (lines.length <= maxEntries) return { archived: 0 };
           const entries = [];
           let dropped = 0;
@@ -9679,7 +9733,7 @@ var init_memory_compactor = __esm({
           const toArchive = entries.slice(0, entries.length - maxEntries);
           const toKeep = entries.slice(entries.length - maxEntries);
           toKeep.sort((a, b) => a.idx - b.idx);
-          const archivePath = (0, import_path8.join)(memDir, "archive.jsonl");
+          const archivePath = (0, import_path9.join)(memDir, "archive.jsonl");
           for (const item of toArchive) {
             const archived = {
               archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -9687,22 +9741,22 @@ var init_memory_compactor = __esm({
               warmth: item.warmth,
               entry: item.entry
             };
-            (0, import_fs7.appendFileSync)(archivePath, JSON.stringify(archived) + "\n");
+            (0, import_fs8.appendFileSync)(archivePath, JSON.stringify(archived) + "\n");
           }
           try {
-            if ((0, import_fs7.existsSync)(archivePath)) {
-              const archiveLines = (0, import_fs7.readFileSync)(archivePath, "utf-8").trim().split("\n");
+            if ((0, import_fs8.existsSync)(archivePath)) {
+              const archiveLines = (0, import_fs8.readFileSync)(archivePath, "utf-8").trim().split("\n");
               if (archiveLines.length > MAX_ARCHIVE_LINES) {
-                (0, import_fs7.writeFileSync)(archivePath, archiveLines.slice(-MAX_ARCHIVE_LINES).join("\n") + "\n");
+                (0, import_fs8.writeFileSync)(archivePath, archiveLines.slice(-MAX_ARCHIVE_LINES).join("\n") + "\n");
               }
             }
           } catch {
           }
-          (0, import_fs7.writeFileSync)(tasksPath, toKeep.map((e) => e.line).join("\n") + "\n");
+          (0, import_fs8.writeFileSync)(tasksPath, toKeep.map((e) => e.line).join("\n") + "\n");
           return { archived: toArchive.length, dropped: dropped || void 0, message: `Compacted ${toArchive.length} memories for ${agentId}${dropped ? ` (${dropped} malformed lines dropped)` : ""}` };
         } finally {
           try {
-            (0, import_fs7.unlinkSync)(lockPath);
+            (0, import_fs8.unlinkSync)(lockPath);
           } catch {
           }
         }
@@ -9721,11 +9775,11 @@ function sanitizeName(name) {
 function discoverProjectStructure(projectRoot) {
   try {
     const parts = [];
-    const entries = (0, import_fs8.readdirSync)(projectRoot, { withFileTypes: true });
+    const entries = (0, import_fs9.readdirSync)(projectRoot, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || isSkipped(entry.name)) continue;
       try {
-        const allChildren = (0, import_fs8.readdirSync)((0, import_path9.join)(projectRoot, entry.name)).filter((f) => !f.startsWith("."));
+        const allChildren = (0, import_fs9.readdirSync)((0, import_path10.join)(projectRoot, entry.name)).filter((f) => !f.startsWith("."));
         if (allChildren.length === 0) continue;
         const shown = allChildren.slice(0, MAX_CHILDREN).map(sanitizeName);
         const suffix = allChildren.length > MAX_CHILDREN ? `, ...${allChildren.length - MAX_CHILDREN} more` : "";
@@ -9738,12 +9792,12 @@ function discoverProjectStructure(projectRoot) {
     return [];
   }
 }
-var import_fs8, import_path9, SKIP, MAX_CHILDREN;
+var import_fs9, import_path10, SKIP, MAX_CHILDREN;
 var init_project_structure = __esm({
   "packages/orchestrator/src/project-structure.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path9 = require("path");
+    import_fs9 = require("fs");
+    import_path10 = require("path");
     SKIP = /* @__PURE__ */ new Set([
       "node_modules",
       "build",
@@ -9784,12 +9838,12 @@ function truncateStartAndEnd(text, maxLen) {
 
 ${text.slice(-tail)}`;
 }
-var import_fs9, import_path10, MemoryWriter;
+var import_fs10, import_path11, MemoryWriter;
 var init_memory_writer = __esm({
   "packages/orchestrator/src/memory-writer.ts"() {
     "use strict";
-    import_fs9 = require("fs");
-    import_path10 = require("path");
+    import_fs10 = require("fs");
+    import_path11 = require("path");
     init_memory_compactor();
     init_project_structure();
     MemoryWriter = class {
@@ -9802,12 +9856,12 @@ var init_memory_writer = __esm({
         this.summaryLlm = llm;
       }
       getMemDir(agentId) {
-        return (0, import_path10.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
+        return (0, import_path11.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
       }
       ensureDirs(agentId) {
         const memDir = this.getMemDir(agentId);
-        (0, import_fs9.mkdirSync)((0, import_path10.join)(memDir, "knowledge"), { recursive: true });
-        (0, import_fs9.mkdirSync)((0, import_path10.join)(memDir, "calibration"), { recursive: true });
+        (0, import_fs10.mkdirSync)((0, import_path11.join)(memDir, "knowledge"), { recursive: true });
+        (0, import_fs10.mkdirSync)((0, import_path11.join)(memDir, "calibration"), { recursive: true });
         return memDir;
       }
       async writeTaskEntry(agentId, data) {
@@ -9825,7 +9879,7 @@ var init_memory_writer = __esm({
           importance: this.deriveImportance(data.scores),
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         };
-        (0, import_fs9.appendFileSync)((0, import_path10.join)(memDir, "tasks.jsonl"), JSON.stringify(entry) + "\n");
+        (0, import_fs10.appendFileSync)((0, import_path11.join)(memDir, "tasks.jsonl"), JSON.stringify(entry) + "\n");
       }
       /**
        * Extract key facts from a task result and write as a knowledge entry.
@@ -9834,7 +9888,7 @@ var init_memory_writer = __esm({
        */
       async writeKnowledgeFromResult(agentId, data) {
         const memDir = this.ensureDirs(agentId);
-        const knowledgeDir = (0, import_path10.join)(memDir, "knowledge");
+        const knowledgeDir = (0, import_path11.join)(memDir, "knowledge");
         const safeResult = data.result.length > 5e4 ? data.result.slice(0, 5e4) : data.result;
         let cognitiveSummary = null;
         if (this.summaryLlm) {
@@ -9884,7 +9938,7 @@ ${cleanSummary}` : cleanSummary;
           ...data.agentAccuracy !== void 0 && data.agentAccuracy < 0.4 ? ["> \u26A0 This agent has low accuracy (" + (data.agentAccuracy * 100).toFixed(0) + "%). Treat factual claims as unverified.\n"] : [],
           body
         ].join("\n");
-        (0, import_fs9.writeFileSync)((0, import_path10.join)(knowledgeDir, filename), content);
+        (0, import_fs10.writeFileSync)((0, import_path11.join)(knowledgeDir, filename), content);
       }
       /**
        * Generate a cognitive summary — what the agent learned, not just what it saw.
@@ -9925,7 +9979,7 @@ ${truncateStartAndEnd(result, 4e3)}`
       /** Session summary data shared across public methods */
       sessionSummaryData(data) {
         const memDir = this.ensureDirs("_project");
-        const knowledgeDir = (0, import_path10.join)(memDir, "knowledge");
+        const knowledgeDir = (0, import_path11.join)(memDir, "knowledge");
         const now = /* @__PURE__ */ new Date();
         const timestamp = now.toISOString().replace(/[:.]/g, "-").slice(0, 19);
         const today = now.toISOString().split("T")[0];
@@ -9948,9 +10002,9 @@ ${discovered.join("\n")}
         let existingMemoriesContext = "";
         const existingFiles = [];
         try {
-          const files = (0, import_fs9.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md"));
+          const files = (0, import_fs10.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md"));
           for (const f of files) {
-            const content = (0, import_fs9.readFileSync)((0, import_path10.join)(knowledgeDir, f), "utf-8");
+            const content = (0, import_fs10.readFileSync)((0, import_path11.join)(knowledgeDir, f), "utf-8");
             const descMatch = content.match(/description:\s*(.+)/);
             const desc = descMatch ? descMatch[1].trim() : "(no description)";
             existingFiles.push(f);
@@ -10060,10 +10114,18 @@ ${rawInput.slice(0, SESSION_SUMMARY_MAX_CHARS)}`;
           summaryBody = raw;
         } else {
           rawLlmResponse = raw;
-          const hasSummaryLine = /^SUMMARY:\s*.+/m.test(raw);
           const hasSectionHeader = /^##\s+\w/m.test(raw);
-          if (!hasSummaryLine || !hasSectionHeader) {
+          if (!hasSectionHeader) {
             process.stderr.write("[gossipcat] Session summary missing required structure, using raw fallback\n");
+            try {
+              const debugPath = (0, import_path11.join)(memDir, "last-malformed-summary.txt");
+              (0, import_fs10.writeFileSync)(debugPath, `# Malformed session summary @ ${timestamp}
+# No ## header found in LLM output.
+
+---
+${raw}`);
+            } catch {
+            }
             summaryBody = `> \u26A0\uFE0F LLM summary malformed \u2014 raw data below.
 
 ${rawInput.slice(0, SESSION_SUMMARY_MAX_CHARS)}`;
@@ -10105,15 +10167,15 @@ ${rawInput.slice(0, SESSION_SUMMARY_MAX_CHARS)}`;
         if (staleFiles.length > 0) {
           for (const sf of staleFiles) {
             try {
-              const filePath = (0, import_path10.join)(knowledgeDir, sf);
-              let fileContent = (0, import_fs9.readFileSync)(filePath, "utf-8");
+              const filePath = (0, import_path11.join)(knowledgeDir, sf);
+              let fileContent = (0, import_fs10.readFileSync)(filePath, "utf-8");
               fileContent = fileContent.replace(/importance:\s*[\d.]+/, "importance: 0.1");
               if (!/status:/.test(fileContent)) {
                 fileContent = fileContent.replace(/\n---/, "\nstatus: shipped\n---");
               } else {
                 fileContent = fileContent.replace(/status:\s*.+/, "status: shipped");
               }
-              (0, import_fs9.writeFileSync)(filePath, fileContent);
+              (0, import_fs10.writeFileSync)(filePath, fileContent);
               process.stderr.write(`[gossipcat] \u{1F5DC}\uFE0F  Marked stale: ${sf}
 `);
             } catch {
@@ -10134,8 +10196,8 @@ ${rawInput.slice(0, SESSION_SUMMARY_MAX_CHARS)}`;
           "",
           summaryBody
         ].filter((l) => l !== "").join("\n");
-        (0, import_fs9.writeFileSync)((0, import_path10.join)(knowledgeDir, filename), content);
-        const nextSessionPath = (0, import_path10.join)(this.projectRoot, ".gossip", "next-session.md");
+        (0, import_fs10.writeFileSync)((0, import_path11.join)(knowledgeDir, filename), content);
+        const nextSessionPath = (0, import_path11.join)(this.projectRoot, ".gossip", "next-session.md");
         const openMatch = summaryBody.match(/##\s+Open[^\n]*\n([\s\S]*?)(?=\n##|\s*$)/i);
         const NEXT_SESSION_MAX_CHARS = 1500;
         const nextSessionContent = openMatch ? `# Next Session
@@ -10145,11 +10207,11 @@ ${openMatch[0].trim()}
 
 ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
 `;
-        (0, import_fs9.writeFileSync)(nextSessionPath, nextSessionContent);
-        const migrationTasksPath = (0, import_path10.join)(memDir, "tasks.jsonl");
-        if ((0, import_fs9.existsSync)(migrationTasksPath)) {
+        (0, import_fs10.writeFileSync)(nextSessionPath, nextSessionContent);
+        const migrationTasksPath = (0, import_path11.join)(memDir, "tasks.jsonl");
+        if ((0, import_fs10.existsSync)(migrationTasksPath)) {
           try {
-            const mLines = (0, import_fs9.readFileSync)(migrationTasksPath, "utf-8").trim().split("\n").filter(Boolean);
+            const mLines = (0, import_fs10.readFileSync)(migrationTasksPath, "utf-8").trim().split("\n").filter(Boolean);
             let migrated = false;
             const fixed = mLines.map((line) => {
               try {
@@ -10163,7 +10225,7 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
                 return line;
               }
             });
-            if (migrated) (0, import_fs9.writeFileSync)(migrationTasksPath, fixed.join("\n") + "\n");
+            if (migrated) (0, import_fs10.writeFileSync)(migrationTasksPath, fixed.join("\n") + "\n");
           } catch {
           }
         }
@@ -10188,10 +10250,10 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
       /** Shared warmth-aware pruning — evicts lowest-warmth files, respects pinned */
       pruneKnowledgeDir(knowledgeDir, maxFiles) {
         try {
-          const existing = (0, import_fs9.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md")).sort();
+          const existing = (0, import_fs10.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md")).sort();
           if (existing.length >= maxFiles) {
             const scored = existing.map((f) => {
-              const content = (0, import_fs9.readFileSync)((0, import_path10.join)(knowledgeDir, f), "utf-8");
+              const content = (0, import_fs10.readFileSync)((0, import_path11.join)(knowledgeDir, f), "utf-8");
               const importance = parseFloat(content.match(/importance:\s*([\d.]+)/)?.[1] ?? "0.5");
               const isPinned = /pinned:\s*true/i.test(content);
               const ts = f.slice(0, 19).replace(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})/, "$1T$2:$3:$4");
@@ -10210,10 +10272,10 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
               );
             }
             for (const item of toEvict) {
-              (0, import_fs9.unlinkSync)((0, import_path10.join)(knowledgeDir, item.file));
+              (0, import_fs10.unlinkSync)((0, import_path11.join)(knowledgeDir, item.file));
             }
           }
-          const sessionFiles = (0, import_fs9.readdirSync)(knowledgeDir).filter((f) => f.endsWith("-session.md")).sort();
+          const sessionFiles = (0, import_fs10.readdirSync)(knowledgeDir).filter((f) => f.endsWith("-session.md")).sort();
           const MAX_SESSION_FILES = 5;
           const SESSION_TTL_DAYS = 14;
           for (const sf of sessionFiles) {
@@ -10221,10 +10283,10 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
               const ts = sf.slice(0, 19).replace(/^(\d{4}-\d{2}-\d{2})T(\d{2})-(\d{2})-(\d{2})/, "$1T$2:$3:$4");
               const days = (Date.now() - new Date(ts).getTime()) / 864e5;
               if (days > SESSION_TTL_DAYS) {
-                const sfPath = (0, import_path10.join)(knowledgeDir, sf);
-                const sfContent = (0, import_fs9.readFileSync)(sfPath, "utf-8");
+                const sfPath = (0, import_path11.join)(knowledgeDir, sf);
+                const sfContent = (0, import_fs10.readFileSync)(sfPath, "utf-8");
                 if (!/importance:\s*0\.1/.test(sfContent)) {
-                  (0, import_fs9.writeFileSync)(sfPath, sfContent.replace(/importance:\s*[\d.]+/, "importance: 0.1"));
+                  (0, import_fs10.writeFileSync)(sfPath, sfContent.replace(/importance:\s*[\d.]+/, "importance: 0.1"));
                 }
               }
             } catch {
@@ -10235,7 +10297,7 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
             const bodies = [];
             for (const sf of toCompact) {
               try {
-                const sfContent = (0, import_fs9.readFileSync)((0, import_path10.join)(knowledgeDir, sf), "utf-8");
+                const sfContent = (0, import_fs10.readFileSync)((0, import_path11.join)(knowledgeDir, sf), "utf-8");
                 const body = sfContent.split("---").slice(2).join("---").trim();
                 if (body) bodies.push(body.slice(0, 800));
               } catch {
@@ -10255,10 +10317,10 @@ ${truncateAtWord(summaryBody, NEXT_SESSION_MAX_CHARS)}
                 "",
                 ...bodies
               ].join("\n").slice(0, 3e3);
-              (0, import_fs9.writeFileSync)((0, import_path10.join)(knowledgeDir, digestName), digestContent);
+              (0, import_fs10.writeFileSync)((0, import_path11.join)(knowledgeDir, digestName), digestContent);
               for (const sf of toCompact) {
                 try {
-                  (0, import_fs9.unlinkSync)((0, import_path10.join)(knowledgeDir, sf));
+                  (0, import_fs10.unlinkSync)((0, import_path11.join)(knowledgeDir, sf));
                 } catch {
                 }
               }
@@ -10441,7 +10503,7 @@ ${result}`;
       writeConsensusKnowledge(agentId, findings) {
         if (findings.length === 0) return;
         const memDir = this.ensureDirs(agentId);
-        const knowledgeDir = (0, import_path10.join)(memDir, "knowledge");
+        const knowledgeDir = (0, import_path11.join)(memDir, "knowledge");
         const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
         const filename = `${timestamp}-consensus.md`;
@@ -10471,7 +10533,7 @@ ${result}`;
           })
         ].join("\n");
         this.pruneKnowledgeDir(knowledgeDir, 25);
-        (0, import_fs9.writeFileSync)((0, import_path10.join)(knowledgeDir, filename), content);
+        (0, import_fs10.writeFileSync)((0, import_path11.join)(knowledgeDir, filename), content);
       }
       /**
        * Update task memory importance based on consensus signals.
@@ -10494,14 +10556,14 @@ ${result}`;
           taskAdj.set(s.taskId, (taskAdj.get(s.taskId) ?? 0) + weight);
         }
         for (const [agentId, taskAdjustments] of adjustments) {
-          const memDir = (0, import_path10.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
-          const tasksPath = (0, import_path10.join)(memDir, "tasks.jsonl");
-          const lockPath = (0, import_path10.join)(memDir, "tasks.jsonl.lock");
-          if (!(0, import_fs9.existsSync)(tasksPath)) continue;
-          if ((0, import_fs9.existsSync)(lockPath)) continue;
+          const memDir = (0, import_path11.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
+          const tasksPath = (0, import_path11.join)(memDir, "tasks.jsonl");
+          const lockPath = (0, import_path11.join)(memDir, "tasks.jsonl.lock");
+          if (!(0, import_fs10.existsSync)(tasksPath)) continue;
+          if ((0, import_fs10.existsSync)(lockPath)) continue;
           try {
-            (0, import_fs9.writeFileSync)(lockPath, `${Date.now()}`);
-            const lines = (0, import_fs9.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+            (0, import_fs10.writeFileSync)(lockPath, `${Date.now()}`);
+            const lines = (0, import_fs10.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
             let modified = false;
             const updated = lines.map((line) => {
               try {
@@ -10518,12 +10580,12 @@ ${result}`;
               }
             });
             if (modified) {
-              (0, import_fs9.writeFileSync)(tasksPath, updated.join("\n") + "\n");
+              (0, import_fs10.writeFileSync)(tasksPath, updated.join("\n") + "\n");
             }
           } catch {
           } finally {
             try {
-              (0, import_fs9.unlinkSync)(lockPath);
+              (0, import_fs10.unlinkSync)(lockPath);
             } catch {
             }
           }
@@ -10533,13 +10595,13 @@ ${result}`;
         const memDir = this.getMemDir(agentId);
         const parts = [`# Agent Memory \u2014 ${agentId}
 `];
-        const knowledgeDir = (0, import_path10.join)(memDir, "knowledge");
-        if ((0, import_fs9.existsSync)(knowledgeDir)) {
-          const files = (0, import_fs9.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md")).sort().reverse();
+        const knowledgeDir = (0, import_path11.join)(memDir, "knowledge");
+        if ((0, import_fs10.existsSync)(knowledgeDir)) {
+          const files = (0, import_fs10.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md")).sort().reverse();
           if (files.length > 0) {
             parts.push("## Knowledge (most recent first)");
             for (const file2 of files) {
-              const content = (0, import_fs9.readFileSync)((0, import_path10.join)(knowledgeDir, file2), "utf-8");
+              const content = (0, import_fs10.readFileSync)((0, import_path11.join)(knowledgeDir, file2), "utf-8");
               const descMatch = content.match(/description:\s*(.+)/);
               const desc = descMatch ? descMatch[1].trim() : file2.replace(".md", "");
               parts.push(`- [${file2.replace(".md", "")}](knowledge/${file2}) \u2014 ${desc}`);
@@ -10547,17 +10609,17 @@ ${result}`;
             parts.push("");
           }
         }
-        const calPath = (0, import_path10.join)(memDir, "calibration", "accuracy.md");
-        if ((0, import_fs9.existsSync)(calPath)) {
-          const content = (0, import_fs9.readFileSync)(calPath, "utf-8");
+        const calPath = (0, import_path11.join)(memDir, "calibration", "accuracy.md");
+        if ((0, import_fs10.existsSync)(calPath)) {
+          const content = (0, import_fs10.readFileSync)(calPath, "utf-8");
           const descMatch = content.match(/description:\s*(.+)/);
           parts.push("## Calibration");
           parts.push(`- [accuracy](calibration/accuracy.md) \u2014 ${descMatch ? descMatch[1].trim() : "accuracy data"}`);
           parts.push("");
         }
-        const tasksPath = (0, import_path10.join)(memDir, "tasks.jsonl");
-        if ((0, import_fs9.existsSync)(tasksPath)) {
-          const lines = (0, import_fs9.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+        const tasksPath = (0, import_path11.join)(memDir, "tasks.jsonl");
+        if ((0, import_fs10.existsSync)(tasksPath)) {
+          const lines = (0, import_fs10.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
           const recent = lines.slice(-5).reverse();
           if (recent.length > 0) {
             parts.push("## Recent Tasks");
@@ -10574,12 +10636,12 @@ ${result}`;
           }
         }
         try {
-          const knowledgeDir2 = (0, import_path10.join)(memDir, "knowledge");
-          if ((0, import_fs9.existsSync)(knowledgeDir2)) {
-            const knowledgeFiles = (0, import_fs9.readdirSync)(knowledgeDir2).filter((f) => f.endsWith(".md")).sort().reverse().slice(0, 5);
+          const knowledgeDir2 = (0, import_path11.join)(memDir, "knowledge");
+          if ((0, import_fs10.existsSync)(knowledgeDir2)) {
+            const knowledgeFiles = (0, import_fs10.readdirSync)(knowledgeDir2).filter((f) => f.endsWith(".md")).sort().reverse().slice(0, 5);
             const patterns = [];
             for (const kf of knowledgeFiles) {
-              const kContent = (0, import_fs9.readFileSync)((0, import_path10.join)(knowledgeDir2, kf), "utf-8");
+              const kContent = (0, import_fs10.readFileSync)((0, import_path11.join)(knowledgeDir2, kf), "utf-8");
               const decisionsMatch = kContent.match(/Decisions: (.+)/);
               if (decisionsMatch) patterns.push(decisionsMatch[1].trim());
               const failuresMatch = kContent.match(/Failures: (.+)/);
@@ -10591,19 +10653,19 @@ ${result}`;
           }
         } catch {
         }
-        (0, import_fs9.writeFileSync)((0, import_path10.join)(memDir, "MEMORY.md"), parts.join("\n"));
+        (0, import_fs10.writeFileSync)((0, import_path11.join)(memDir, "MEMORY.md"), parts.join("\n"));
       }
     };
   }
 });
 
 // packages/orchestrator/src/task-graph.ts
-var import_fs10, import_path11, MAX_SCAN_LINES, TaskGraph;
+var import_fs11, import_path12, MAX_SCAN_LINES, TaskGraph;
 var init_task_graph = __esm({
   "packages/orchestrator/src/task-graph.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path11 = require("path");
+    import_fs11 = require("fs");
+    import_path12 = require("path");
     MAX_SCAN_LINES = 1e3;
     TaskGraph = class {
       graphPath;
@@ -10613,14 +10675,14 @@ var init_task_graph = __esm({
       // taskId → last event line number
       eventCount = 0;
       constructor(projectRoot) {
-        const gossipDir2 = (0, import_path11.join)(projectRoot, ".gossip");
-        (0, import_fs10.mkdirSync)(gossipDir2, { recursive: true });
-        this.graphPath = (0, import_path11.join)(gossipDir2, "task-graph.jsonl");
-        this.syncMetaPath = (0, import_path11.join)(gossipDir2, "task-graph-sync.json");
-        this.indexPath = (0, import_path11.join)(gossipDir2, "task-graph-index.json");
+        const gossipDir2 = (0, import_path12.join)(projectRoot, ".gossip");
+        (0, import_fs11.mkdirSync)(gossipDir2, { recursive: true });
+        this.graphPath = (0, import_path12.join)(gossipDir2, "task-graph.jsonl");
+        this.syncMetaPath = (0, import_path12.join)(gossipDir2, "task-graph-sync.json");
+        this.indexPath = (0, import_path12.join)(gossipDir2, "task-graph-index.json");
         this.loadIndex();
-        if ((0, import_fs10.existsSync)(this.graphPath)) {
-          const buf = (0, import_fs10.readFileSync)(this.graphPath);
+        if ((0, import_fs11.existsSync)(this.graphPath)) {
+          const buf = (0, import_fs11.readFileSync)(this.graphPath);
           let count = 0;
           for (let i = 0; i < buf.length; i++) {
             if (buf[i] === 10) count++;
@@ -10629,9 +10691,9 @@ var init_task_graph = __esm({
         }
       }
       loadIndex() {
-        if ((0, import_fs10.existsSync)(this.indexPath)) {
+        if ((0, import_fs11.existsSync)(this.indexPath)) {
           try {
-            const data = JSON.parse((0, import_fs10.readFileSync)(this.indexPath, "utf-8"));
+            const data = JSON.parse((0, import_fs11.readFileSync)(this.indexPath, "utf-8"));
             this.index = new Map(Object.entries(data).map(([k, v]) => [k, Number(v)]));
           } catch {
           }
@@ -10639,10 +10701,10 @@ var init_task_graph = __esm({
       }
       /** Save index to disk (call explicitly, not on every append) */
       flushIndex() {
-        (0, import_fs10.writeFileSync)(this.indexPath, JSON.stringify(Object.fromEntries(this.index)));
+        (0, import_fs11.writeFileSync)(this.indexPath, JSON.stringify(Object.fromEntries(this.index)));
       }
       appendEvent(event) {
-        (0, import_fs10.appendFileSync)(this.graphPath, JSON.stringify(event) + "\n");
+        (0, import_fs11.appendFileSync)(this.graphPath, JSON.stringify(event) + "\n");
         if ("taskId" in event) {
           this.index.set(event.taskId, this.eventCount);
         }
@@ -10724,8 +10786,8 @@ var init_task_graph = __esm({
       }
       // ── Read methods ─────────────────────────────────────────────────────
       readEvents() {
-        if (!(0, import_fs10.existsSync)(this.graphPath)) return [];
-        const content = (0, import_fs10.readFileSync)(this.graphPath, "utf-8");
+        if (!(0, import_fs11.existsSync)(this.graphPath)) return [];
+        const content = (0, import_fs11.readFileSync)(this.graphPath, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         const tail = lines.slice(-MAX_SCAN_LINES);
         return tail.map((line) => {
@@ -10807,14 +10869,14 @@ var init_task_graph = __esm({
         return this.eventCount;
       }
       getSyncMeta() {
-        if (!(0, import_fs10.existsSync)(this.syncMetaPath)) {
+        if (!(0, import_fs11.existsSync)(this.syncMetaPath)) {
           return { lastSync: "", lastSyncEventCount: 0 };
         }
-        return JSON.parse((0, import_fs10.readFileSync)(this.syncMetaPath, "utf-8"));
+        return JSON.parse((0, import_fs11.readFileSync)(this.syncMetaPath, "utf-8"));
       }
       updateSyncMeta(meta3) {
         const current = this.getSyncMeta();
-        (0, import_fs10.writeFileSync)(this.syncMetaPath, JSON.stringify({ ...current, ...meta3 }, null, 2));
+        (0, import_fs11.writeFileSync)(this.syncMetaPath, JSON.stringify({ ...current, ...meta3 }, null, 2));
       }
       getUnsynced(lastSyncTimestamp) {
         if (!lastSyncTimestamp) return this.readEvents();
@@ -10825,12 +10887,12 @@ var init_task_graph = __esm({
 });
 
 // packages/orchestrator/src/skill-catalog.ts
-var import_fs11, import_path12, SkillCatalog;
+var import_fs12, import_path13, SkillCatalog;
 var init_skill_catalog = __esm({
   "packages/orchestrator/src/skill-catalog.ts"() {
     "use strict";
-    import_fs11 = require("fs");
-    import_path12 = require("path");
+    import_fs12 = require("fs");
+    import_path13 = require("path");
     init_skill_name();
     init_skill_parser();
     SkillCatalog = class {
@@ -10839,11 +10901,11 @@ var init_skill_catalog = __esm({
       projectSkillsDir;
       projectFileMtimes = /* @__PURE__ */ new Map();
       constructor(projectRoot, catalogPath) {
-        const defaultPath = catalogPath || (0, import_path12.resolve)(__dirname, "default-skills", "catalog.json");
-        this.defaultSkillsDir = (0, import_path12.resolve)(__dirname, "default-skills");
-        this.projectSkillsDir = projectRoot ? (0, import_path12.join)(projectRoot, ".gossip", "skills") : null;
+        const defaultPath = catalogPath || (0, import_path13.resolve)(__dirname, "default-skills", "catalog.json");
+        this.defaultSkillsDir = (0, import_path13.resolve)(__dirname, "default-skills");
+        this.projectSkillsDir = projectRoot ? (0, import_path13.join)(projectRoot, ".gossip", "skills") : null;
         try {
-          const raw = (0, import_fs11.readFileSync)(defaultPath, "utf-8");
+          const raw = (0, import_fs12.readFileSync)(defaultPath, "utf-8");
           const data = JSON.parse(raw);
           this.entries = data.skills.map((s) => ({
             ...s,
@@ -10884,7 +10946,7 @@ var init_skill_catalog = __esm({
       }
       validate() {
         const issues = [];
-        const mdFiles = (0, import_fs11.readdirSync)(this.defaultSkillsDir).filter((f) => f.endsWith(".md")).map((f) => normalizeSkillName(f.replace(".md", "")));
+        const mdFiles = (0, import_fs12.readdirSync)(this.defaultSkillsDir).filter((f) => f.endsWith(".md")).map((f) => normalizeSkillName(f.replace(".md", "")));
         for (const file2 of mdFiles) {
           if (!this.entries.find((e) => e.name === file2)) {
             issues.push(`Skill file '${file2}' has no catalog entry`);
@@ -10893,15 +10955,15 @@ var init_skill_catalog = __esm({
         return issues;
       }
       loadProjectSkills() {
-        if (!this.projectSkillsDir || !(0, import_fs11.existsSync)(this.projectSkillsDir)) return;
-        const files = (0, import_fs11.readdirSync)(this.projectSkillsDir).filter((f) => f.endsWith(".md"));
+        if (!this.projectSkillsDir || !(0, import_fs12.existsSync)(this.projectSkillsDir)) return;
+        const files = (0, import_fs12.readdirSync)(this.projectSkillsDir).filter((f) => f.endsWith(".md"));
         const newMtimes = /* @__PURE__ */ new Map();
         for (const file2 of files) {
-          const filePath = (0, import_path12.join)(this.projectSkillsDir, file2);
+          const filePath = (0, import_path13.join)(this.projectSkillsDir, file2);
           try {
-            const mtime = (0, import_fs11.statSync)(filePath).mtimeMs;
+            const mtime = (0, import_fs12.statSync)(filePath).mtimeMs;
             newMtimes.set(file2, mtime);
-            const content = (0, import_fs11.readFileSync)(filePath, "utf-8");
+            const content = (0, import_fs12.readFileSync)(filePath, "utf-8");
             const fm = parseSkillFrontmatter(content);
             if (!fm) continue;
             const entry = {
@@ -10923,14 +10985,14 @@ var init_skill_catalog = __esm({
         this.projectFileMtimes = newMtimes;
       }
       reloadIfChanged() {
-        if (!this.projectSkillsDir || !(0, import_fs11.existsSync)(this.projectSkillsDir)) return;
-        const files = (0, import_fs11.readdirSync)(this.projectSkillsDir).filter((f) => f.endsWith(".md"));
+        if (!this.projectSkillsDir || !(0, import_fs12.existsSync)(this.projectSkillsDir)) return;
+        const files = (0, import_fs12.readdirSync)(this.projectSkillsDir).filter((f) => f.endsWith(".md"));
         let changed = files.length !== this.projectFileMtimes.size;
         if (!changed) {
           for (const file2 of files) {
-            const filePath = (0, import_path12.join)(this.projectSkillsDir, file2);
+            const filePath = (0, import_path13.join)(this.projectSkillsDir, file2);
             try {
-              const mtime = (0, import_fs11.statSync)(filePath).mtimeMs;
+              const mtime = (0, import_fs12.statSync)(filePath).mtimeMs;
               if (mtime !== this.projectFileMtimes.get(file2)) {
                 changed = true;
                 break;
@@ -10951,12 +11013,12 @@ var init_skill_catalog = __esm({
 });
 
 // packages/orchestrator/src/skill-gap-tracker.ts
-var import_fs12, import_path13, MAX_LOG_LINES, TRUNCATE_TO, SkillGapTracker;
+var import_fs13, import_path14, MAX_LOG_LINES, TRUNCATE_TO, SkillGapTracker;
 var init_skill_gap_tracker = __esm({
   "packages/orchestrator/src/skill-gap-tracker.ts"() {
     "use strict";
-    import_fs12 = require("fs");
-    import_path13 = require("path");
+    import_fs13 = require("fs");
+    import_path14 = require("path");
     init_skill_name();
     MAX_LOG_LINES = 5e3;
     TRUNCATE_TO = 1e3;
@@ -10965,8 +11027,8 @@ var init_skill_gap_tracker = __esm({
       resolutionsPath;
       resolutionsCache = null;
       constructor(projectRoot) {
-        this.gapLogPath = (0, import_path13.join)(projectRoot, ".gossip", "skill-gaps.jsonl");
-        this.resolutionsPath = (0, import_path13.join)(projectRoot, ".gossip", "skill-resolutions.json");
+        this.gapLogPath = (0, import_path14.join)(projectRoot, ".gossip", "skill-gaps.jsonl");
+        this.resolutionsPath = (0, import_path14.join)(projectRoot, ".gossip", "skill-resolutions.json");
         this.migrateResolutions();
       }
       checkThresholds() {
@@ -10994,9 +11056,9 @@ var init_skill_gap_tracker = __esm({
         const normalized = normalizeSkillName(skillName);
         const resolutions = this.loadResolutions();
         resolutions[normalized] = (/* @__PURE__ */ new Date()).toISOString();
-        const dir = (0, import_path13.join)(this.resolutionsPath, "..");
-        if (!(0, import_fs12.existsSync)(dir)) (0, import_fs12.mkdirSync)(dir, { recursive: true });
-        (0, import_fs12.writeFileSync)(this.resolutionsPath, JSON.stringify(resolutions, null, 2));
+        const dir = (0, import_path14.join)(this.resolutionsPath, "..");
+        if (!(0, import_fs13.existsSync)(dir)) (0, import_fs13.mkdirSync)(dir, { recursive: true });
+        (0, import_fs13.writeFileSync)(this.resolutionsPath, JSON.stringify(resolutions, null, 2));
         this.resolutionsCache = resolutions;
       }
       getSuggestionsSince(agentId, sinceMs) {
@@ -11005,9 +11067,9 @@ var init_skill_gap_tracker = __esm({
         );
       }
       appendSuggestion(suggestion) {
-        const dir = (0, import_path13.join)(this.gapLogPath, "..");
-        if (!(0, import_fs12.existsSync)(dir)) (0, import_fs12.mkdirSync)(dir, { recursive: true });
-        (0, import_fs12.appendFileSync)(this.gapLogPath, JSON.stringify(suggestion) + "\n");
+        const dir = (0, import_path14.join)(this.gapLogPath, "..");
+        if (!(0, import_fs13.existsSync)(dir)) (0, import_fs13.mkdirSync)(dir, { recursive: true });
+        (0, import_fs13.appendFileSync)(this.gapLogPath, JSON.stringify(suggestion) + "\n");
         this.truncateIfNeeded();
       }
       getPendingSkills() {
@@ -11035,9 +11097,9 @@ var init_skill_gap_tracker = __esm({
         );
       }
       readSuggestions() {
-        if (!(0, import_fs12.existsSync)(this.gapLogPath)) return [];
+        if (!(0, import_fs13.existsSync)(this.gapLogPath)) return [];
         try {
-          const lines = (0, import_fs12.readFileSync)(this.gapLogPath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs13.readFileSync)(this.gapLogPath, "utf-8").trim().split("\n").filter(Boolean);
           return lines.map((line) => {
             try {
               return JSON.parse(line);
@@ -11051,12 +11113,12 @@ var init_skill_gap_tracker = __esm({
       }
       loadResolutions() {
         if (this.resolutionsCache) return this.resolutionsCache;
-        if (!(0, import_fs12.existsSync)(this.resolutionsPath)) {
+        if (!(0, import_fs13.existsSync)(this.resolutionsPath)) {
           this.resolutionsCache = {};
           return this.resolutionsCache;
         }
         try {
-          this.resolutionsCache = JSON.parse((0, import_fs12.readFileSync)(this.resolutionsPath, "utf-8"));
+          this.resolutionsCache = JSON.parse((0, import_fs13.readFileSync)(this.resolutionsPath, "utf-8"));
           return this.resolutionsCache;
         } catch {
           this.resolutionsCache = {};
@@ -11064,10 +11126,10 @@ var init_skill_gap_tracker = __esm({
         }
       }
       migrateResolutions() {
-        if ((0, import_fs12.existsSync)(this.resolutionsPath)) return;
-        if (!(0, import_fs12.existsSync)(this.gapLogPath)) return;
+        if ((0, import_fs13.existsSync)(this.resolutionsPath)) return;
+        if (!(0, import_fs13.existsSync)(this.gapLogPath)) return;
         try {
-          const lines = (0, import_fs12.readFileSync)(this.gapLogPath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs13.readFileSync)(this.gapLogPath, "utf-8").trim().split("\n").filter(Boolean);
           const resolutions = {};
           for (const line of lines) {
             try {
@@ -11079,21 +11141,21 @@ var init_skill_gap_tracker = __esm({
             }
           }
           if (Object.keys(resolutions).length > 0) {
-            const dir = (0, import_path13.join)(this.resolutionsPath, "..");
-            if (!(0, import_fs12.existsSync)(dir)) (0, import_fs12.mkdirSync)(dir, { recursive: true });
-            (0, import_fs12.writeFileSync)(this.resolutionsPath, JSON.stringify(resolutions, null, 2));
+            const dir = (0, import_path14.join)(this.resolutionsPath, "..");
+            if (!(0, import_fs13.existsSync)(dir)) (0, import_fs13.mkdirSync)(dir, { recursive: true });
+            (0, import_fs13.writeFileSync)(this.resolutionsPath, JSON.stringify(resolutions, null, 2));
             this.resolutionsCache = resolutions;
           }
         } catch {
         }
       }
       truncateIfNeeded() {
-        if (!(0, import_fs12.existsSync)(this.gapLogPath)) return;
+        if (!(0, import_fs13.existsSync)(this.gapLogPath)) return;
         try {
-          const content = (0, import_fs12.readFileSync)(this.gapLogPath, "utf-8");
+          const content = (0, import_fs13.readFileSync)(this.gapLogPath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           if (lines.length > MAX_LOG_LINES) {
-            (0, import_fs12.writeFileSync)(this.gapLogPath, lines.slice(-TRUNCATE_TO).join("\n") + "\n");
+            (0, import_fs13.writeFileSync)(this.gapLogPath, lines.slice(-TRUNCATE_TO).join("\n") + "\n");
           }
         } catch {
         }
@@ -11103,12 +11165,12 @@ var init_skill_gap_tracker = __esm({
 });
 
 // packages/orchestrator/src/scope-tracker.ts
-var import_path14, import_fs13, ScopeTracker;
+var import_path15, import_fs14, ScopeTracker;
 var init_scope_tracker = __esm({
   "packages/orchestrator/src/scope-tracker.ts"() {
     "use strict";
-    import_path14 = require("path");
-    import_fs13 = require("fs");
+    import_path15 = require("path");
+    import_fs14 = require("fs");
     ScopeTracker = class {
       // taskId → scope (for release)
       constructor(projectRoot) {
@@ -11119,15 +11181,15 @@ var init_scope_tracker = __esm({
       taskToScope = /* @__PURE__ */ new Map();
       normalize(scope) {
         if (!scope || !scope.trim()) throw new Error("Scope must not be empty");
-        const realRoot = (0, import_fs13.realpathSync)(this.projectRoot);
-        const abs = (0, import_path14.resolve)(realRoot, scope);
+        const realRoot = (0, import_fs14.realpathSync)(this.projectRoot);
+        const abs = (0, import_path15.resolve)(realRoot, scope);
         let real;
         try {
-          real = (0, import_fs13.realpathSync)(abs);
+          real = (0, import_fs14.realpathSync)(abs);
         } catch {
           real = abs;
         }
-        const rel = (0, import_path14.relative)(realRoot, real);
+        const rel = (0, import_path15.relative)(realRoot, real);
         if (rel.startsWith("..")) throw new Error(`Scope "${scope}" resolves outside project root`);
         if (rel === "") throw new Error(`Scope "${scope}" resolves to project root \u2014 too broad`);
         return rel.endsWith("/") ? rel : rel + "/";
@@ -11165,14 +11227,14 @@ var init_scope_tracker = __esm({
 });
 
 // packages/orchestrator/src/worktree-manager.ts
-var import_child_process3, import_util8, import_promises2, import_path15, import_os, execFileAsync3, WorktreeManager;
+var import_child_process3, import_util8, import_promises2, import_path16, import_os, execFileAsync3, WorktreeManager;
 var init_worktree_manager = __esm({
   "packages/orchestrator/src/worktree-manager.ts"() {
     "use strict";
     import_child_process3 = require("child_process");
     import_util8 = require("util");
     import_promises2 = require("fs/promises");
-    import_path15 = require("path");
+    import_path16 = require("path");
     import_os = require("os");
     execFileAsync3 = (0, import_util8.promisify)(import_child_process3.execFile);
     WorktreeManager = class {
@@ -11181,7 +11243,7 @@ var init_worktree_manager = __esm({
       }
       async create(taskId) {
         const branch = `gossip-${taskId}`;
-        const wtPath = await (0, import_promises2.mkdtemp)((0, import_path15.join)((0, import_os.tmpdir)(), "gossip-wt-"));
+        const wtPath = await (0, import_promises2.mkdtemp)((0, import_path16.join)((0, import_os.tmpdir)(), "gossip-wt-"));
         await execFileAsync3("git", ["branch", branch, "HEAD"], { cwd: this.projectRoot });
         try {
           await execFileAsync3("git", ["worktree", "add", wtPath, branch], { cwd: this.projectRoot });
@@ -11256,12 +11318,13 @@ function getSeverityMultiplier(severity) {
 function clamp(v, min, max) {
   return Math.max(min, Math.min(max, v));
 }
-var import_fs14, import_path16, CIRCUIT_BREAKER_THRESHOLD, NEGATIVE_SIGNALS, SIGNAL_EXPIRY_DAYS, KNOWN_SIGNALS, SEVERITY_MULTIPLIER, PerformanceReader;
+var import_fs15, import_path17, CIRCUIT_BREAKER_THRESHOLD, NEGATIVE_SIGNALS, SIGNAL_EXPIRY_DAYS, KNOWN_SIGNALS, SEVERITY_MULTIPLIER, PerformanceReader;
 var init_performance_reader = __esm({
   "packages/orchestrator/src/performance-reader.ts"() {
     "use strict";
-    import_fs14 = require("fs");
-    import_path16 = require("path");
+    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;
@@ -11290,13 +11353,13 @@ var init_performance_reader = __esm({
       cachedScores = null;
       cachedMtimeMs = 0;
       constructor(projectRoot) {
-        this.filePath = (0, import_path16.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+        this.filePath = (0, import_path17.join)(projectRoot, ".gossip", "agent-performance.jsonl");
       }
       /** Read all signals and compute per-agent scores (cached by file mtime) */
       getScores() {
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_fs14.statSync)(this.filePath).mtimeMs;
+          mtimeMs = (0, import_fs15.statSync)(this.filePath).mtimeMs;
         } catch {
         }
         if (this.cachedScores && mtimeMs === this.cachedMtimeMs) {
@@ -11345,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) {
@@ -11372,9 +11436,9 @@ var init_performance_reader = __esm({
        * Don't unify these — see getCountersSince doc and consensus 9369ebfc-a3654b51 f1.
        */
       readSignalsRaw() {
-        if (!(0, import_fs14.existsSync)(this.filePath)) return [];
+        if (!(0, import_fs15.existsSync)(this.filePath)) return [];
         try {
-          const lines = (0, import_fs14.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs15.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
           const all = lines.map((line) => {
             try {
               return JSON.parse(line);
@@ -11407,10 +11471,10 @@ var init_performance_reader = __esm({
         }
       }
       readSignals() {
-        if (!(0, import_fs14.existsSync)(this.filePath)) return [];
+        if (!(0, import_fs15.existsSync)(this.filePath)) return [];
         try {
           const expiryMs = Date.now() - SIGNAL_EXPIRY_DAYS * 864e5;
-          const lines = (0, import_fs14.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs15.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
           const all = lines.map((line) => {
             try {
               return JSON.parse(line);
@@ -11622,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),
@@ -11630,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, {
@@ -11675,11 +11740,11 @@ var init_performance_reader = __esm({
         return result;
       }
       getImplScore(agentId) {
-        if (!(0, import_fs14.existsSync)(this.filePath)) return null;
+        if (!(0, import_fs15.existsSync)(this.filePath)) return null;
         try {
           const now = Date.now();
           const expiryMs = now - SIGNAL_EXPIRY_DAYS * 864e5;
-          const lines = (0, import_fs14.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
+          const lines = (0, import_fs15.readFileSync)(this.filePath, "utf-8").trim().split("\n").filter(Boolean);
           let pass = 0, fail = 0, approved = 0, rejected = 0, lastImplSignalMs = 0;
           for (const line of lines) {
             try {
@@ -11718,12 +11783,12 @@ var init_performance_reader = __esm({
 });
 
 // packages/orchestrator/src/skill-counters.ts
-var import_fs15, import_path17, STALE_THRESHOLD, PROMOTION_RATE, PROMOTION_MIN_WINDOW, SkillCounterTracker;
+var import_fs16, import_path18, STALE_THRESHOLD, PROMOTION_RATE, PROMOTION_MIN_WINDOW, SkillCounterTracker;
 var init_skill_counters = __esm({
   "packages/orchestrator/src/skill-counters.ts"() {
     "use strict";
-    import_fs15 = require("fs");
-    import_path17 = require("path");
+    import_fs16 = require("fs");
+    import_path18 = require("path");
     STALE_THRESHOLD = 30;
     PROMOTION_RATE = 0.8;
     PROMOTION_MIN_WINDOW = 20;
@@ -11732,7 +11797,7 @@ var init_skill_counters = __esm({
       filePath;
       dirty = false;
       constructor(projectRoot) {
-        this.filePath = (0, import_path17.join)(projectRoot, ".gossip", "skill-counters.json");
+        this.filePath = (0, import_path18.join)(projectRoot, ".gossip", "skill-counters.json");
         this.load();
       }
       /**
@@ -11807,15 +11872,15 @@ var init_skill_counters = __esm({
       /** Flush counters to disk. Call during gossip_collect. */
       flush() {
         if (!this.dirty) return;
-        const dir = (0, import_path17.dirname)(this.filePath);
-        if (!(0, import_fs15.existsSync)(dir)) (0, import_fs15.mkdirSync)(dir, { recursive: true });
-        (0, import_fs15.writeFileSync)(this.filePath, JSON.stringify(this.data, null, 2) + "\n");
+        const dir = (0, import_path18.dirname)(this.filePath);
+        if (!(0, import_fs16.existsSync)(dir)) (0, import_fs16.mkdirSync)(dir, { recursive: true });
+        (0, import_fs16.writeFileSync)(this.filePath, JSON.stringify(this.data, null, 2) + "\n");
         this.dirty = false;
       }
       load() {
         try {
-          if ((0, import_fs15.existsSync)(this.filePath)) {
-            const raw = JSON.parse((0, import_fs15.readFileSync)(this.filePath, "utf-8"));
+          if ((0, import_fs16.existsSync)(this.filePath)) {
+            const raw = JSON.parse((0, import_fs16.readFileSync)(this.filePath, "utf-8"));
             if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
             for (const [agentId, skills] of Object.entries(raw)) {
               if (!skills || typeof skills !== "object") {
@@ -11842,14 +11907,14 @@ function shortConsensusId() {
   const hex3 = (0, import_crypto6.randomUUID)().replace(/-/g, "");
   return hex3.slice(0, 8) + "-" + hex3.slice(8, 16);
 }
-var import_promises3, import_fs16, import_crypto6, import_path18, SUMMARY_HEADER, FALLBACK_MAX_LENGTH, MAX_SUMMARY_LENGTH, MAX_CROSS_REVIEW_ENTRIES, VALID_ACTIONS, ANCHOR_PATTERN, ConsensusEngine;
+var import_promises3, import_fs17, import_crypto6, import_path19, SUMMARY_HEADER, FALLBACK_MAX_LENGTH, MAX_SUMMARY_LENGTH, MAX_CROSS_REVIEW_ENTRIES, VALID_ACTIONS, ANCHOR_PATTERN, ConsensusEngine;
 var init_consensus_engine = __esm({
   "packages/orchestrator/src/consensus-engine.ts"() {
     "use strict";
     import_promises3 = require("fs/promises");
-    import_fs16 = require("fs");
+    import_fs17 = require("fs");
     import_crypto6 = require("crypto");
-    import_path18 = require("path");
+    import_path19 = require("path");
     SUMMARY_HEADER = "## Consensus Summary";
     FALLBACK_MAX_LENGTH = 2e3;
     MAX_SUMMARY_LENGTH = 5e3;
@@ -11885,7 +11950,7 @@ var init_consensus_engine = __esm({
         for (const r of results) {
           const wt = r.worktreeInfo?.path;
           if (wt && typeof wt === "string") {
-            next.add((0, import_path18.resolve)(wt));
+            next.add((0, import_path19.resolve)(wt));
           }
         }
         let changed = next.size !== this.currentWorktreeRoots.size;
@@ -12713,9 +12778,9 @@ ${safeSnippet}
        */
       /** Guard: resolved path must stay inside one of the valid roots */
       isInsideAnyRoot(candidate, roots) {
-        const normalized = (0, import_path18.resolve)(candidate);
+        const normalized = (0, import_path19.resolve)(candidate);
         return roots.some((root) => {
-          const normalizedRoot = (0, import_path18.resolve)(root);
+          const normalizedRoot = (0, import_path19.resolve)(root);
           return normalized === normalizedRoot || normalized.startsWith(normalizedRoot + "/");
         });
       }
@@ -12725,7 +12790,7 @@ ${safeSnippet}
         const fileName = fileRef.split("/").pop();
         for (const root of roots) {
           try {
-            const candidate = (0, import_path18.join)(root, fileRef);
+            const candidate = (0, import_path19.join)(root, fileRef);
             if (this.isInsideAnyRoot(candidate, roots)) {
               await (0, import_promises3.stat)(candidate);
               return candidate;
@@ -12734,7 +12799,7 @@ ${safeSnippet}
           }
           if (fileName !== fileRef) {
             try {
-              const candidate = (0, import_path18.join)(root, fileName);
+              const candidate = (0, import_path19.join)(root, fileName);
               if (this.isInsideAnyRoot(candidate, roots)) {
                 await (0, import_promises3.stat)(candidate);
                 return candidate;
@@ -12744,7 +12809,7 @@ ${safeSnippet}
           }
           const searchDirs = ["packages", "src", "apps", "tests", "test", "tools", "scripts", "lib"];
           for (const dir of searchDirs) {
-            const found = await this.findFile((0, import_path18.join)(root, dir), fileName, roots);
+            const found = await this.findFile((0, import_path19.join)(root, dir), fileName, roots);
             if (found) return found;
           }
         }
@@ -12754,7 +12819,7 @@ ${safeSnippet}
         try {
           const entries = await (0, import_promises3.readdir)(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = (0, import_path18.join)(dir, entry.name);
+            const fullPath = (0, import_path19.join)(dir, entry.name);
             if (entry.isFile() && entry.name === fileName) {
               if (!this.isInsideAnyRoot(fullPath, validRoots)) return null;
               return fullPath;
@@ -12780,7 +12845,7 @@ ${safeSnippet}
         const sourceExts = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
         for (const root of roots) {
           for (const dir of searchDirs) {
-            const result = await this.grepDir((0, import_path18.join)(root, dir), identifier, sourceExts, CONTEXT_LINES);
+            const result = await this.grepDir((0, import_path19.join)(root, dir), identifier, sourceExts, CONTEXT_LINES);
             if (result) return result;
           }
         }
@@ -12791,7 +12856,7 @@ ${safeSnippet}
         try {
           const entries = await (0, import_promises3.readdir)(dir, { withFileTypes: true });
           for (const entry of entries) {
-            const fullPath = (0, import_path18.join)(dir, entry.name);
+            const fullPath = (0, import_path19.join)(dir, entry.name);
             if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== ".git" && entry.name !== "dist") {
               const found = await this.grepDir(fullPath, identifier, exts, contextLines);
               if (found) return found;
@@ -13285,11 +13350,11 @@ ${safeSnippet}
       dumpFailedCrossReview(reviewerAgentId, text) {
         if (!this.config.projectRoot) return;
         try {
-          const dir = (0, import_path18.join)(this.config.projectRoot, ".gossip", "cross-review-failures");
-          (0, import_fs16.mkdirSync)(dir, { recursive: true });
+          const dir = (0, import_path19.join)(this.config.projectRoot, ".gossip", "cross-review-failures");
+          (0, import_fs17.mkdirSync)(dir, { recursive: true });
           const safeId2 = reviewerAgentId.replace(/[^a-zA-Z0-9_-]/g, "_");
           const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-          (0, import_fs16.writeFileSync)((0, import_path18.join)(dir, `${safeId2}-${ts}.txt`), text);
+          (0, import_fs17.writeFileSync)((0, import_path19.join)(dir, `${safeId2}-${ts}.txt`), text);
         } catch {
         }
       }
@@ -13362,12 +13427,12 @@ function validateSignal(signal) {
       throw new Error(`Signal validation failed: unknown type "${signal.type}"`);
   }
 }
-var import_fs17, import_path19, VALID_CONSENSUS_SIGNALS, VALID_IMPL_SIGNALS, VALID_META_SIGNALS, PerformanceWriter;
+var import_fs18, import_path20, VALID_CONSENSUS_SIGNALS, VALID_IMPL_SIGNALS, VALID_META_SIGNALS, PerformanceWriter;
 var init_performance_writer = __esm({
   "packages/orchestrator/src/performance-writer.ts"() {
     "use strict";
-    import_fs17 = require("fs");
-    import_path19 = require("path");
+    import_fs18 = require("fs");
+    import_path20 = require("path");
     VALID_CONSENSUS_SIGNALS = /* @__PURE__ */ new Set([
       "agreement",
       "disagreement",
@@ -13393,19 +13458,19 @@ var init_performance_writer = __esm({
     PerformanceWriter = class {
       filePath;
       constructor(projectRoot) {
-        const dir = (0, import_path19.join)(projectRoot, ".gossip");
-        if (!(0, import_fs17.existsSync)(dir)) (0, import_fs17.mkdirSync)(dir, { recursive: true });
-        this.filePath = (0, import_path19.join)(dir, "agent-performance.jsonl");
+        const dir = (0, import_path20.join)(projectRoot, ".gossip");
+        if (!(0, import_fs18.existsSync)(dir)) (0, import_fs18.mkdirSync)(dir, { recursive: true });
+        this.filePath = (0, import_path20.join)(dir, "agent-performance.jsonl");
       }
       appendSignal(signal) {
         validateSignal(signal);
-        (0, import_fs17.appendFileSync)(this.filePath, JSON.stringify(signal) + "\n");
+        (0, import_fs18.appendFileSync)(this.filePath, JSON.stringify(signal) + "\n");
       }
       appendSignals(signals) {
         if (signals.length === 0) return;
         for (const s of signals) validateSignal(s);
         const data = signals.map((s) => JSON.stringify(s)).join("\n") + "\n";
-        (0, import_fs17.appendFileSync)(this.filePath, data);
+        (0, import_fs18.appendFileSync)(this.filePath, data);
       }
     };
   }
@@ -13604,12 +13669,12 @@ ${topFindings}`;
 });
 
 // packages/orchestrator/src/session-context.ts
-var import_fs18, import_path20, log3, SessionContext;
+var import_fs19, import_path21, log3, SessionContext;
 var init_session_context = __esm({
   "packages/orchestrator/src/session-context.ts"() {
     "use strict";
-    import_fs18 = require("fs");
-    import_path20 = require("path");
+    import_fs19 = require("fs");
+    import_path21 = require("path");
     log3 = (msg) => process.stderr.write(`[gossipcat] ${msg}
 `);
     SessionContext = class _SessionContext {
@@ -13623,7 +13688,7 @@ var init_session_context = __esm({
         this.projectRoot = config2.projectRoot;
         this.llm = config2.llm;
         try {
-          const gossipPath = (0, import_path20.join)(config2.projectRoot, ".gossip", "agents", "_project", "memory", "session-gossip.jsonl");
+          const gossipPath = (0, import_path21.join)(config2.projectRoot, ".gossip", "agents", "_project", "memory", "session-gossip.jsonl");
           const { existsSync: ex, readFileSync: rf } = require("fs");
           if (ex(gossipPath)) {
             const lines = rf(gossipPath, "utf-8").trim().split("\n").filter(Boolean);
@@ -13675,9 +13740,9 @@ var init_session_context = __esm({
               this.sessionGossip.shift();
             }
             try {
-              const gossipPath = (0, import_path20.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "session-gossip.jsonl");
-              (0, import_fs18.mkdirSync)((0, import_path20.dirname)(gossipPath), { recursive: true });
-              (0, import_fs18.appendFileSync)(gossipPath, JSON.stringify({ agentId, taskSummary: summary, timestamp: Date.now() }) + "\n");
+              const gossipPath = (0, import_path21.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "session-gossip.jsonl");
+              (0, import_fs19.mkdirSync)((0, import_path21.dirname)(gossipPath), { recursive: true });
+              (0, import_fs19.appendFileSync)(gossipPath, JSON.stringify({ agentId, taskSummary: summary, timestamp: Date.now() }) + "\n");
               this.rotateJsonlFile(gossipPath, 100, 50);
             } catch {
             }
@@ -13698,10 +13763,10 @@ ${result.slice(0, 2e3)}` }
       /** Rotate a JSONL file: if over maxEntries lines, keep only the last keepEntries. */
       rotateJsonlFile(filePath, maxEntries, keepEntries) {
         try {
-          const content = (0, import_fs18.readFileSync)(filePath, "utf-8");
+          const content = (0, import_fs19.readFileSync)(filePath, "utf-8");
           const lines = content.trim().split("\n").filter((l) => l.length > 0);
           if (lines.length > maxEntries) {
-            (0, import_fs18.writeFileSync)(filePath, lines.slice(-keepEntries).join("\n") + "\n");
+            (0, import_fs19.writeFileSync)(filePath, lines.slice(-keepEntries).join("\n") + "\n");
           }
         } catch {
         }
@@ -13720,13 +13785,13 @@ function shouldSkipConsensus(task, agents, costMode, agreementHistory) {
   const firstWord = task.trim().split(/\s+/)[0] || "";
   return OBSERVATION_VERBS.test(firstWord);
 }
-var import_crypto8, import_fs19, import_path21, log4, DispatchPipeline, SECURITY_KEYWORDS, OBSERVATION_VERBS;
+var import_crypto8, import_fs20, import_path22, log4, DispatchPipeline, SECURITY_KEYWORDS, OBSERVATION_VERBS;
 var init_dispatch_pipeline = __esm({
   "packages/orchestrator/src/dispatch-pipeline.ts"() {
     "use strict";
     import_crypto8 = require("crypto");
-    import_fs19 = require("fs");
-    import_path21 = require("path");
+    import_fs20 = require("fs");
+    import_path22 = require("path");
     init_types2();
     init_skill_loader();
     init_prompt_assembler();
@@ -13815,8 +13880,8 @@ var init_dispatch_pipeline = __esm({
         this.sessionContext = new SessionContext({ llm: config2.llm ?? null, projectRoot: config2.projectRoot });
         this.worktreeManager.pruneOrphans().catch((err) => log4(`Orphan cleanup failed: ${err.message}`));
         try {
-          const projectMemDir = (0, import_path21.join)(config2.projectRoot, ".gossip", "agents", "_project", "memory");
-          (0, import_fs19.mkdirSync)(projectMemDir, { recursive: true });
+          const projectMemDir = (0, import_path22.join)(config2.projectRoot, ".gossip", "agents", "_project", "memory");
+          (0, import_fs20.mkdirSync)(projectMemDir, { recursive: true });
         } catch {
         }
       }
@@ -13887,11 +13952,11 @@ var init_dispatch_pipeline = __esm({
         const specRefs = extractSpecReferences(task);
         if (specRefs.length > 0) {
           try {
-            const specPath = (0, import_path21.resolve)(this.projectRoot, specRefs[0]);
-            const realSpecPath = (0, import_fs19.realpathSync)(specPath);
-            const realRoot = (0, import_fs19.realpathSync)(this.projectRoot);
+            const specPath = (0, import_path22.resolve)(this.projectRoot, specRefs[0]);
+            const realSpecPath = (0, import_fs20.realpathSync)(specPath);
+            const realRoot = (0, import_fs20.realpathSync)(this.projectRoot);
             if (realSpecPath.startsWith(realRoot + "/")) {
-              const specContent = (0, import_fs19.readFileSync)(realSpecPath, "utf-8");
+              const specContent = (0, import_fs20.readFileSync)(realSpecPath, "utf-8");
               const implFiles = extractSpecReferences(task, specContent);
               const enrichment = buildSpecReviewEnrichment(implFiles);
               if (enrichment) specReviewContext = enrichment;
@@ -13899,7 +13964,7 @@ var init_dispatch_pipeline = __esm({
           } catch {
           }
         }
-        const memoryDir = (0, import_path21.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "knowledge");
+        const memoryDir = (0, import_path22.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "knowledge");
         const promptContent = assemblePrompt({
           memory: memory || void 0,
           memoryDir,
@@ -13959,7 +14024,7 @@ var init_dispatch_pipeline = __esm({
                   const elapsedMs = (entry.completedAt ?? Date.now()) - entry.startedAt;
                   process.stderr.write(`[gossipcat] \u2705 relay \u2190 ${entry.agentId} [${entry.id}] OK (${(elapsedMs / 1e3).toFixed(1)}s, ${(event.payload.result || "").length} chars)
 `);
-                  (0, import_fs19.appendFileSync)((0, import_path21.join)(this.projectRoot, ".gossip", "task-graph.jsonl"), JSON.stringify({
+                  (0, import_fs20.appendFileSync)((0, import_path22.join)(this.projectRoot, ".gossip", "task-graph.jsonl"), JSON.stringify({
                     type: "task.completed",
                     taskId: entry.id,
                     agentId: entry.agentId,
@@ -13983,7 +14048,7 @@ var init_dispatch_pipeline = __esm({
                   const elapsedMs = (entry.completedAt ?? Date.now()) - entry.startedAt;
                   process.stderr.write(`[gossipcat] \u274C relay \u2190 ${entry.agentId} [${entry.id}] FAILED (${(elapsedMs / 1e3).toFixed(1)}s) \u2014 ${event.payload.error}
 `);
-                  (0, import_fs19.appendFileSync)((0, import_path21.join)(this.projectRoot, ".gossip", "task-graph.jsonl"), JSON.stringify({
+                  (0, import_fs20.appendFileSync)((0, import_path22.join)(this.projectRoot, ".gossip", "task-graph.jsonl"), JSON.stringify({
                     type: "task.failed",
                     taskId: entry.id,
                     agentId: entry.agentId,
@@ -14910,13 +14975,13 @@ function parseYamlLikeToolCall(content) {
   const args = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   return { tool, args };
 }
-var import_fs20, import_path22, log5, AGENT_ID_RE, TAG_PATTERN, BLOCK_RE, BLOCK_IN_FENCE_RE, ToolRouter, ToolExecutor;
+var import_fs21, import_path23, log5, AGENT_ID_RE, TAG_PATTERN, BLOCK_RE, BLOCK_IN_FENCE_RE, ToolRouter, ToolExecutor;
 var init_tool_router = __esm({
   "packages/orchestrator/src/tool-router.ts"() {
     "use strict";
     init_tool_definitions();
-    import_fs20 = require("fs");
-    import_path22 = require("path");
+    import_fs21 = require("fs");
+    import_path23 = require("path");
     log5 = (msg) => process.stderr.write(`[tool-router] ${msg}
 `);
     AGENT_ID_RE = /^[a-zA-Z0-9_-]+$/;
@@ -15322,12 +15387,12 @@ ${agentOutputs}` }
           const fsp = await import("fs/promises");
           const updatedIds = [];
           for (const id of pending.agentIds) {
-            const agentDir = (0, import_path22.join)(this.projectRoot, ".gossip", "agents", id);
-            const filePath = (0, import_path22.join)(agentDir, "instructions.md");
-            if (!(0, import_fs20.existsSync)(agentDir)) {
+            const agentDir = (0, import_path23.join)(this.projectRoot, ".gossip", "agents", id);
+            const filePath = (0, import_path23.join)(agentDir, "instructions.md");
+            if (!(0, import_fs21.existsSync)(agentDir)) {
               await fsp.mkdir(agentDir, { recursive: true });
             }
-            if ((0, import_fs20.existsSync)(filePath)) {
+            if ((0, import_fs21.existsSync)(filePath)) {
               await fsp.appendFile(filePath, `
 
 ${pending.instruction}`, "utf-8");
@@ -15441,9 +15506,9 @@ ${collectResult.consensus.summary}`;
       async handlePlan(args) {
         let task = String(args.task);
         try {
-          const specPath = (0, import_path22.join)(this.projectRoot, ".gossip", "spec.md");
-          if ((0, import_fs20.existsSync)(specPath)) {
-            const spec = (0, import_fs20.readFileSync)(specPath, "utf-8");
+          const specPath = (0, import_path23.join)(this.projectRoot, ".gossip", "spec.md");
+          if ((0, import_fs21.existsSync)(specPath)) {
+            const spec = (0, import_fs21.readFileSync)(specPath, "utf-8");
             task = `${task}
 
 [Project Spec]
@@ -15501,11 +15566,11 @@ ${taskLines.join("\n")}`,
         if (!this.llm) {
           return { text: "Tool error: LLM not available for spec generation" };
         }
-        const specPath = (0, import_path22.join)(this.projectRoot, ".gossip", "spec.md");
+        const specPath = (0, import_path23.join)(this.projectRoot, ".gossip", "spec.md");
         let existingSpec = "";
         try {
-          if ((0, import_fs20.existsSync)(specPath)) {
-            existingSpec = (0, import_fs20.readFileSync)(specPath, "utf-8");
+          if ((0, import_fs21.existsSync)(specPath)) {
+            existingSpec = (0, import_fs21.readFileSync)(specPath, "utf-8");
           }
         } catch {
         }
@@ -15540,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_path22.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}
@@ -15579,11 +15644,11 @@ ${lines.join("\n")}` };
         if (!this.registry.get(agentId)) {
           return { text: `Tool error: agent "${agentId}" not found in registry` };
         }
-        const tasksPath = (0, import_path22.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "tasks.jsonl");
-        if (!(0, import_fs20.existsSync)(tasksPath)) {
+        const tasksPath = (0, import_path23.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "tasks.jsonl");
+        if (!(0, import_fs21.existsSync)(tasksPath)) {
           return { text: `Agent "${agentId}" \u2014 no task history found.` };
         }
-        const rawLines = (0, import_fs20.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+        const rawLines = (0, import_fs21.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
         const last5 = rawLines.slice(-5).map((line) => {
           try {
             return JSON.parse(line);
@@ -15600,11 +15665,11 @@ Last ${last5.length} tasks:
 ${formatted.join("\n")}` };
       }
       handleAgentPerformance() {
-        const perfPath = (0, import_path22.join)(this.projectRoot, ".gossip", "agent-performance.jsonl");
-        if (!(0, import_fs20.existsSync)(perfPath)) {
+        const perfPath = (0, import_path23.join)(this.projectRoot, ".gossip", "agent-performance.jsonl");
+        if (!(0, import_fs21.existsSync)(perfPath)) {
           return { text: "No performance data found." };
         }
-        const rawLines = (0, import_fs20.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+        const rawLines = (0, import_fs21.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
         const last20 = rawLines.slice(-20).map((line) => {
           try {
             return JSON.parse(line);
@@ -15655,11 +15720,11 @@ Instruction: "${instruction}"`,
         if (!this.registry.get(agentId)) {
           return { text: `Tool error: agent "${agentId}" not found in registry` };
         }
-        const tasksPath = (0, import_path22.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "tasks.jsonl");
-        if (!(0, import_fs20.existsSync)(tasksPath)) {
+        const tasksPath = (0, import_path23.join)(this.projectRoot, ".gossip", "agents", agentId, "memory", "tasks.jsonl");
+        if (!(0, import_fs21.existsSync)(tasksPath)) {
           return { text: `No task history for agent "${agentId}".` };
         }
-        const rawLines = (0, import_fs20.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+        const rawLines = (0, import_fs21.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
         const entries = rawLines.slice(-limit).map((line) => {
           try {
             return JSON.parse(line);
@@ -15719,17 +15784,34 @@ ${formatted.join("\n")}` };
 });
 
 // packages/orchestrator/src/archetype-catalog.ts
-var import_fs21, import_path23, DEFAULT_PATH, ArchetypeCatalog;
+function findArchetypeCatalog() {
+  const candidates = [
+    (0, import_path24.resolve)(__dirname, "data", "archetypes.json"),
+    // bundled prod: dist-mcp/data/archetypes.json
+    (0, import_path24.resolve)(__dirname, "..", "..", "..", "data", "archetypes.json"),
+    // dev ts-node: packages/orchestrator/src → repo/data
+    (0, import_path24.resolve)(process.cwd(), "data", "archetypes.json")
+    // last-resort dev fallback
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs22.existsSync)(p)) return p;
+  }
+  return null;
+}
+var import_fs22, import_path24, ArchetypeCatalog;
 var init_archetype_catalog = __esm({
   "packages/orchestrator/src/archetype-catalog.ts"() {
     "use strict";
-    import_fs21 = require("fs");
-    import_path23 = require("path");
-    DEFAULT_PATH = (0, import_path23.resolve)(__dirname, "..", "..", "..", "data", "archetypes.json");
+    import_fs22 = require("fs");
+    import_path24 = require("path");
     ArchetypeCatalog = class {
       archetypes;
       constructor(catalogPath) {
-        const raw = (0, import_fs21.readFileSync)(catalogPath ?? DEFAULT_PATH, "utf-8");
+        const path2 = catalogPath ?? findArchetypeCatalog();
+        if (!path2) {
+          throw new Error("archetypes.json not found \u2014 tried bundled dist-mcp/data/, dev ts-node path, and cwd/data/. Reinstall gossipcat.");
+        }
+        const raw = (0, import_fs22.readFileSync)(path2, "utf-8");
         this.archetypes = JSON.parse(raw);
       }
       /** Return all archetype IDs */
@@ -15779,13 +15861,13 @@ var init_archetype_catalog = __esm({
 });
 
 // packages/orchestrator/src/project-initializer.ts
-var import_fs22, import_path24, SIGNAL_DIRS, SIGNAL_FILES, LANG_FILES, ProjectInitializer;
+var import_fs23, import_path25, SIGNAL_DIRS, SIGNAL_FILES, LANG_FILES, ProjectInitializer;
 var init_project_initializer = __esm({
   "packages/orchestrator/src/project-initializer.ts"() {
     "use strict";
     init_archetype_catalog();
-    import_fs22 = require("fs");
-    import_path24 = require("path");
+    import_fs23 = require("fs");
+    import_path25 = require("path");
     SIGNAL_DIRS = [
       "src",
       "pages",
@@ -15817,16 +15899,16 @@ var init_project_initializer = __esm({
         this.config = config2;
       }
       scanDirectory(root) {
-        const absRoot = (0, import_path24.resolve)(root);
+        const absRoot = (0, import_path25.resolve)(root);
         const signals = { dependencies: [], directories: [], files: [] };
         for (const [file2, lang] of Object.entries(LANG_FILES)) {
-          if (this.safeExists(absRoot, (0, import_path24.join)(absRoot, file2))) signals.language = lang;
+          if (this.safeExists(absRoot, (0, import_path25.join)(absRoot, file2))) signals.language = lang;
         }
-        const pkgPath = (0, import_path24.join)(absRoot, "package.json");
+        const pkgPath = (0, import_path25.join)(absRoot, "package.json");
         if (this.safeExists(absRoot, pkgPath)) {
           signals.files.push("package.json");
           try {
-            const pkg = JSON.parse((0, import_fs22.readFileSync)(pkgPath, "utf-8"));
+            const pkg = JSON.parse((0, import_fs23.readFileSync)(pkgPath, "utf-8"));
             signals.dependencies = [
               ...Object.keys(pkg.dependencies || {}),
               ...Object.keys(pkg.devDependencies || {})
@@ -15836,18 +15918,18 @@ var init_project_initializer = __esm({
           if (!signals.language) signals.language = "JavaScript";
         }
         for (const dir of SIGNAL_DIRS) {
-          const p = (0, import_path24.join)(absRoot, dir);
+          const p = (0, import_path25.join)(absRoot, dir);
           if (this.safeExists(absRoot, p) && this.isDir(p)) signals.directories.push(`${dir}/`);
         }
-        const wfPath = (0, import_path24.join)(absRoot, ".github", "workflows");
+        const wfPath = (0, import_path25.join)(absRoot, ".github", "workflows");
         if (this.safeExists(absRoot, wfPath) && this.isDir(wfPath)) {
           signals.directories.push(".github/workflows/");
         }
         for (const file2 of SIGNAL_FILES) {
-          if (this.safeExists(absRoot, (0, import_path24.join)(absRoot, file2))) signals.files.push(file2);
+          if (this.safeExists(absRoot, (0, import_path25.join)(absRoot, file2))) signals.files.push(file2);
         }
         for (const file2 of Object.keys(LANG_FILES)) {
-          if (this.safeExists(absRoot, (0, import_path24.join)(absRoot, file2))) signals.files.push(file2);
+          if (this.safeExists(absRoot, (0, import_path25.join)(absRoot, file2))) signals.files.push(file2);
         }
         return signals;
       }
@@ -15865,7 +15947,8 @@ var init_project_initializer = __esm({
         for (const p of ["google", "anthropic", "openai"]) {
           if (await this.config.keyProvider(p)) providers.push(p);
         }
-        if (!providers.length) {
+        const hostIsClaudeCode = process.env.CLAUDECODE === "1" || !!process.env.CLAUDE_CODE_ENTRYPOINT;
+        if (!providers.length && !hostIsClaudeCode) {
           return { text: "No API keys available. Run gossipcat setup to configure providers." };
         }
         const catalog = new ArchetypeCatalog(this.config.catalogPath);
@@ -15877,11 +15960,14 @@ var init_project_initializer = __esm({
           anthropic: { best: "claude-opus-4-6", fast: "claude-sonnet-4-6", cheapest: "claude-haiku-4-5" },
           openai: { best: "gpt-4o", fast: "gpt-4o", cheapest: "gpt-4o-mini" }
         };
-        const availableModels = providers.map((p) => {
-          const tiers = MODEL_TIERS[p];
-          if (!tiers) return `${p}: (use any available model)`;
-          return `${p}: ${tiers.best} (best), ${tiers.fast} (fast), ${tiers.cheapest} (cheapest)`;
-        }).join("\n");
+        const availableModels = [
+          ...hostIsClaudeCode ? ["none: none (native Claude Code orchestration \u2014 no API key needed, preferred for main_agent on this host)"] : [],
+          ...providers.map((p) => {
+            const tiers = MODEL_TIERS[p];
+            if (!tiers) return `${p}: (use any available model)`;
+            return `${p}: ${tiers.best} (best), ${tiers.fast} (fast), ${tiers.cheapest} (cheapest)`;
+          })
+        ].join("\n");
         const brainstormCtx = signals.brainstormContext;
         const systemPrompt = `You are configuring an agent team for a software project.
 
@@ -15928,7 +16014,7 @@ You may add additional skills from the table above based on project needs. Do NO
 - Pick the best archetype and customize roles for this specific project
 - Use ONLY the exact model names listed above
 - Choose models based on project complexity: simple \u2192 "fast" for all, complex \u2192 "best" for critical roles
-- For the main_agent (orchestrator), use the "best" model from the primary provider
+- For the main_agent (orchestrator): ${hostIsClaudeCode ? 'PREFER { "provider": "none", "model": "none" } \u2014 native Claude Code orchestration needs no API key and is the zero-config default on this host. Only pick a keyed provider if the user explicitly asks for one.' : 'use the "best" model from the primary provider'}
 - Do NOT include agent IDs \u2014 the system generates them automatically
 - **Scale team size to project complexity.** Simple (single-page app, script, simple game) \u2192 1-2 agents. Medium \u2192 2-3. Complex multi-module \u2192 4-5. NEVER duplicate roles.
 - Max 5 agents, prefer fewer. Every agent costs money.
@@ -15979,13 +16065,13 @@ ${agentList}`,
       }
       async writeConfig(projectRoot) {
         if (!this.pendingProposal) throw new Error("No pending proposal to write");
-        const gossipDir2 = (0, import_path24.join)(projectRoot, ".gossip");
-        if (!(0, import_fs22.existsSync)(gossipDir2)) (0, import_fs22.mkdirSync)(gossipDir2, { recursive: true });
+        const gossipDir2 = (0, import_path25.join)(projectRoot, ".gossip");
+        if (!(0, import_fs23.existsSync)(gossipDir2)) (0, import_fs23.mkdirSync)(gossipDir2, { recursive: true });
         const agents = {};
         for (const a of this.pendingProposal.agents || []) {
           agents[a.id] = { provider: a.provider, model: a.model, preset: a.preset, skills: a.skills || [] };
-          const agentDir = (0, import_path24.join)(gossipDir2, "agents", a.id);
-          if (!(0, import_fs22.existsSync)(agentDir)) (0, import_fs22.mkdirSync)(agentDir, { recursive: true });
+          const agentDir = (0, import_path25.join)(gossipDir2, "agents", a.id);
+          if (!(0, import_fs23.existsSync)(agentDir)) (0, import_fs23.mkdirSync)(agentDir, { recursive: true });
         }
         const config2 = {
           main_agent: this.pendingProposal.main_agent,
@@ -15996,20 +16082,20 @@ ${agentList}`,
           },
           agents
         };
-        (0, import_fs22.writeFileSync)((0, import_path24.join)(gossipDir2, "config.json"), JSON.stringify(config2, null, 2));
+        (0, import_fs23.writeFileSync)((0, import_path25.join)(gossipDir2, "config.json"), JSON.stringify(config2, null, 2));
       }
       safeExists(root, target) {
-        const resolved = (0, import_path24.resolve)(target);
+        const resolved = (0, import_path25.resolve)(target);
         if (!resolved.startsWith(root)) return false;
         try {
-          return !(0, import_fs22.lstatSync)(resolved).isSymbolicLink();
+          return !(0, import_fs23.lstatSync)(resolved).isSymbolicLink();
         } catch {
           return false;
         }
       }
       isDir(target) {
         try {
-          return (0, import_fs22.lstatSync)(target).isDirectory();
+          return (0, import_fs23.lstatSync)(target).isDirectory();
         } catch {
           return false;
         }
@@ -16019,12 +16105,12 @@ ${agentList}`,
 });
 
 // packages/orchestrator/src/team-manager.ts
-var import_fs23, import_path25, TeamManager;
+var import_fs24, import_path26, TeamManager;
 var init_team_manager = __esm({
   "packages/orchestrator/src/team-manager.ts"() {
     "use strict";
-    import_fs23 = require("fs");
-    import_path25 = require("path");
+    import_fs24 = require("fs");
+    import_path26 = require("path");
     TeamManager = class {
       registry;
       pipeline;
@@ -16080,8 +16166,8 @@ var init_team_manager = __esm({
       applyAdd(config2) {
         this.registry.register(config2);
         this.writeConfig();
-        const dir = (0, import_path25.join)(this.projectRoot, ".gossip", "agents", config2.id);
-        if (!(0, import_fs23.existsSync)(dir)) (0, import_fs23.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path26.join)(this.projectRoot, ".gossip", "agents", config2.id);
+        if (!(0, import_fs24.existsSync)(dir)) (0, import_fs24.mkdirSync)(dir, { recursive: true });
         this.pendingAction = null;
       }
       applyRemove(agentId) {
@@ -16115,11 +16201,11 @@ var init_team_manager = __esm({
         };
       }
       writeConfig() {
-        const configPath = (0, import_path25.join)(this.projectRoot, ".gossip", "config.json");
+        const configPath = (0, import_path26.join)(this.projectRoot, ".gossip", "config.json");
         let existing = {};
-        if ((0, import_fs23.existsSync)(configPath)) {
+        if ((0, import_fs24.existsSync)(configPath)) {
           try {
-            existing = JSON.parse((0, import_fs23.readFileSync)(configPath, "utf-8"));
+            existing = JSON.parse((0, import_fs24.readFileSync)(configPath, "utf-8"));
           } catch {
           }
         }
@@ -16131,9 +16217,9 @@ var init_team_manager = __esm({
           ...a.preset ? { preset: a.preset } : {},
           skills: a.skills
         }));
-        const dir = (0, import_path25.join)(this.projectRoot, ".gossip");
-        if (!(0, import_fs23.existsSync)(dir)) (0, import_fs23.mkdirSync)(dir, { recursive: true });
-        (0, import_fs23.writeFileSync)(configPath, JSON.stringify(existing, null, 2) + "\n");
+        const dir = (0, import_path26.join)(this.projectRoot, ".gossip");
+        if (!(0, import_fs24.existsSync)(dir)) (0, import_fs24.mkdirSync)(dir, { recursive: true });
+        (0, import_fs24.writeFileSync)(configPath, JSON.stringify(existing, null, 2) + "\n");
       }
     };
   }
@@ -16355,8 +16441,8 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync41, 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;
@@ -16365,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 = existsSync41(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();
@@ -16548,16 +16634,16 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync41, 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 = existsSync41(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();
@@ -17078,12 +17164,12 @@ var init_consensus_types = __esm({
 });
 
 // packages/orchestrator/src/skill-index.ts
-var import_fs24, import_path26, DANGEROUS_KEYS, SkillIndex;
+var import_fs25, import_path27, DANGEROUS_KEYS, SkillIndex;
 var init_skill_index = __esm({
   "packages/orchestrator/src/skill-index.ts"() {
     "use strict";
-    import_fs24 = require("fs");
-    import_path26 = require("path");
+    import_fs25 = require("fs");
+    import_path27 = require("path");
     init_skill_name();
     DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype", "_project"]);
     SkillIndex = class {
@@ -17092,7 +17178,7 @@ var init_skill_index = __esm({
       dirty = false;
       _exists = false;
       constructor(projectRoot) {
-        this.filePath = (0, import_path26.join)(projectRoot, ".gossip", "skill-index.json");
+        this.filePath = (0, import_path27.join)(projectRoot, ".gossip", "skill-index.json");
         this.load();
       }
       /** Bind a skill to an agent (creates or updates the slot) */
@@ -17284,7 +17370,7 @@ var init_skill_index = __esm({
       }
       load() {
         try {
-          const raw = (0, import_fs24.readFileSync)(this.filePath, "utf-8");
+          const raw = (0, import_fs25.readFileSync)(this.filePath, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
             for (const key of Object.keys(parsed)) {
@@ -17306,9 +17392,9 @@ var init_skill_index = __esm({
       }
       save() {
         if (!this.dirty) return;
-        const dir = (0, import_path26.dirname)(this.filePath);
-        (0, import_fs24.mkdirSync)(dir, { recursive: true });
-        (0, import_fs24.writeFileSync)(this.filePath, JSON.stringify(this.data, null, 2) + "\n");
+        const dir = (0, import_path27.dirname)(this.filePath);
+        (0, import_fs25.mkdirSync)(dir, { recursive: true });
+        (0, import_fs25.writeFileSync)(this.filePath, JSON.stringify(this.data, null, 2) + "\n");
         this._exists = true;
         this.dirty = false;
       }
@@ -17323,12 +17409,12 @@ function safeId(value) {
   }
   return encodeURIComponent(value);
 }
-var import_fs25, import_path27, TaskGraphSync;
+var import_fs26, import_path28, TaskGraphSync;
 var init_task_graph_sync = __esm({
   "packages/orchestrator/src/task-graph-sync.ts"() {
     "use strict";
-    import_fs25 = require("fs");
-    import_path27 = require("path");
+    import_fs26 = require("fs");
+    import_path28 = require("path");
     TaskGraphSync = class {
       constructor(graph, supabaseUrl, supabaseKey, userId, projectId, projectRoot, displayName, migration) {
         this.graph = graph;
@@ -17338,7 +17424,7 @@ var init_task_graph_sync = __esm({
         this.projectId = projectId;
         this.displayName = displayName;
         this.migration = migration;
-        this.gossipDir = (0, import_path27.join)(projectRoot, ".gossip");
+        this.gossipDir = (0, import_path28.join)(projectRoot, ".gossip");
       }
       gossipDir;
       migrationDone = false;
@@ -17461,9 +17547,9 @@ var init_task_graph_sync = __esm({
         });
       }
       async syncAgentScores() {
-        const perfPath = (0, import_path27.join)(this.gossipDir, "agent-performance.jsonl");
-        if (!(0, import_fs25.existsSync)(perfPath)) return 0;
-        const content = (0, import_fs25.readFileSync)(perfPath, "utf-8");
+        const perfPath = (0, import_path28.join)(this.gossipDir, "agent-performance.jsonl");
+        if (!(0, import_fs26.existsSync)(perfPath)) return 0;
+        const content = (0, import_fs26.readFileSync)(perfPath, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         const meta3 = this.graph.getSyncMeta();
         let synced = 0;
@@ -17610,61 +17696,61 @@ Return JSON: { "<agentId>": "<summary>", ... }`
 // packages/orchestrator/src/rules-loader.ts
 function findBundledRules() {
   const candidates = [
-    (0, import_path28.resolve)(__dirname, "default-rules", "gossipcat-rules.md"),
-    (0, import_path28.resolve)(__dirname, "..", "default-rules", "gossipcat-rules.md"),
-    (0, import_path28.resolve)(process.cwd(), "packages", "orchestrator", "src", "default-rules", "gossipcat-rules.md")
+    (0, import_path29.resolve)(__dirname, "default-rules", "gossipcat-rules.md"),
+    (0, import_path29.resolve)(__dirname, "..", "default-rules", "gossipcat-rules.md"),
+    (0, import_path29.resolve)(process.cwd(), "packages", "orchestrator", "src", "default-rules", "gossipcat-rules.md")
   ];
   for (const p of candidates) {
-    if ((0, import_fs26.existsSync)(p)) return p;
+    if ((0, import_fs27.existsSync)(p)) return p;
   }
   return null;
 }
 function ensureRulesFile(projectRoot) {
-  const target = (0, import_path28.join)(projectRoot, ".gossip", "rules.md");
-  if ((0, import_fs26.existsSync)(target)) return { created: false, path: target };
+  const target = (0, import_path29.join)(projectRoot, ".gossip", "rules.md");
+  if ((0, import_fs27.existsSync)(target)) return { created: false, path: target };
   const bundled = findBundledRules();
   if (!bundled) return { created: false, path: null };
   try {
-    (0, import_fs26.mkdirSync)((0, import_path28.dirname)(target), { recursive: true });
-    (0, import_fs26.copyFileSync)(bundled, target);
+    (0, import_fs27.mkdirSync)((0, import_path29.dirname)(target), { recursive: true });
+    (0, import_fs27.copyFileSync)(bundled, target);
     return { created: true, path: target };
   } catch {
     return { created: false, path: null };
   }
 }
 function readRulesContent(projectRoot) {
-  const local = (0, import_path28.join)(projectRoot, ".gossip", "rules.md");
-  if ((0, import_fs26.existsSync)(local)) {
+  const local = (0, import_path29.join)(projectRoot, ".gossip", "rules.md");
+  if ((0, import_fs27.existsSync)(local)) {
     try {
-      return (0, import_fs26.readFileSync)(local, "utf-8");
+      return (0, import_fs27.readFileSync)(local, "utf-8");
     } catch {
     }
   }
   const bundled = findBundledRules();
   if (bundled) {
     try {
-      return (0, import_fs26.readFileSync)(bundled, "utf-8");
+      return (0, import_fs27.readFileSync)(bundled, "utf-8");
     } catch {
     }
   }
   return null;
 }
-var import_fs26, import_path28;
+var import_fs27, import_path29;
 var init_rules_loader = __esm({
   "packages/orchestrator/src/rules-loader.ts"() {
     "use strict";
-    import_fs26 = require("fs");
-    import_path28 = require("path");
+    import_fs27 = require("fs");
+    import_path29 = require("path");
   }
 });
 
 // packages/orchestrator/src/bootstrap.ts
-var import_fs27, import_path29, log6, BootstrapGenerator;
+var import_fs28, import_path30, log6, BootstrapGenerator;
 var init_bootstrap = __esm({
   "packages/orchestrator/src/bootstrap.ts"() {
     "use strict";
-    import_fs27 = require("fs");
-    import_path29 = require("path");
+    import_fs28 = require("fs");
+    import_path30 = require("path");
     init_rules_loader();
     log6 = (msg) => process.stderr.write(`[gossipcat] ${msg}
 `);
@@ -17687,23 +17773,23 @@ var init_bootstrap = __esm({
         };
       }
       migrateConfig() {
-        const oldPath = (0, import_path29.resolve)(this.projectRoot, "gossip.agents.json");
-        const newPath = (0, import_path29.resolve)(this.projectRoot, ".gossip", "config.json");
-        if (!(0, import_fs27.existsSync)(newPath) && (0, import_fs27.existsSync)(oldPath)) {
-          (0, import_fs27.mkdirSync)((0, import_path29.resolve)(this.projectRoot, ".gossip"), { recursive: true });
-          (0, import_fs27.copyFileSync)(oldPath, newPath);
+        const oldPath = (0, import_path30.resolve)(this.projectRoot, "gossip.agents.json");
+        const newPath = (0, import_path30.resolve)(this.projectRoot, ".gossip", "config.json");
+        if (!(0, import_fs28.existsSync)(newPath) && (0, import_fs28.existsSync)(oldPath)) {
+          (0, import_fs28.mkdirSync)((0, import_path30.resolve)(this.projectRoot, ".gossip"), { recursive: true });
+          (0, import_fs28.copyFileSync)(oldPath, newPath);
           log6("Migrated config to .gossip/config.json \u2014 gossip.agents.json is now ignored.");
         }
       }
       loadConfig() {
         const paths = [
-          (0, import_path29.resolve)(this.projectRoot, ".gossip", "config.json"),
-          (0, import_path29.resolve)(this.projectRoot, "gossip.agents.json")
+          (0, import_path30.resolve)(this.projectRoot, ".gossip", "config.json"),
+          (0, import_path30.resolve)(this.projectRoot, "gossip.agents.json")
         ];
         for (const p of paths) {
-          if ((0, import_fs27.existsSync)(p)) {
+          if ((0, import_fs28.existsSync)(p)) {
             try {
-              return JSON.parse((0, import_fs27.readFileSync)(p, "utf-8"));
+              return JSON.parse((0, import_fs28.readFileSync)(p, "utf-8"));
             } catch {
               log6("Config parse error, falling back to setup mode");
               return null;
@@ -17724,9 +17810,9 @@ var init_bootstrap = __esm({
             skills: ac.skills || [],
             taskCount: 0
           };
-          const tasksPath = (0, import_path29.join)(this.projectRoot, ".gossip", "agents", id, "memory", "tasks.jsonl");
-          if ((0, import_fs27.existsSync)(tasksPath)) {
-            const lines = (0, import_fs27.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
+          const tasksPath = (0, import_path30.join)(this.projectRoot, ".gossip", "agents", id, "memory", "tasks.jsonl");
+          if ((0, import_fs28.existsSync)(tasksPath)) {
+            const lines = (0, import_fs28.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean);
             let count = 0;
             let lastTs = "";
             for (const line of lines) {
@@ -17740,9 +17826,9 @@ var init_bootstrap = __esm({
             summary.taskCount = count;
             if (lastTs) summary.lastActive = lastTs.split("T")[0];
           }
-          const memPath = (0, import_path29.join)(this.projectRoot, ".gossip", "agents", id, "memory", "MEMORY.md");
-          if ((0, import_fs27.existsSync)(memPath)) {
-            const content = (0, import_fs27.readFileSync)(memPath, "utf-8").slice(0, 500);
+          const memPath = (0, import_path30.join)(this.projectRoot, ".gossip", "agents", id, "memory", "MEMORY.md");
+          if ((0, import_fs28.existsSync)(memPath)) {
+            const content = (0, import_fs28.readFileSync)(memPath, "utf-8").slice(0, 500);
             const knowledgeLines = content.match(/- \[([^\]]+)\]/g);
             if (knowledgeLines?.length) {
               summary.topics = knowledgeLines.map((l) => l.replace(/- \[([^\]]+)\].*/, "$1")).join(", ");
@@ -17975,13 +18061,13 @@ Skills are auto-injected from agent config. Project-wide skills in .gossip/skill
        * Returns the body content of the top knowledge files, capped at 2500 chars.
        */
       readProjectMemory() {
-        const knowledgeDir = (0, import_path29.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "knowledge");
-        if (!(0, import_fs27.existsSync)(knowledgeDir)) return null;
-        const files = (0, import_fs27.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md"));
+        const knowledgeDir = (0, import_path30.join)(this.projectRoot, ".gossip", "agents", "_project", "memory", "knowledge");
+        if (!(0, import_fs28.existsSync)(knowledgeDir)) return null;
+        const files = (0, import_fs28.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md") && !f.endsWith("-session.md"));
         if (files.length === 0) return null;
         const scored = files.map((f) => {
           try {
-            const content = (0, import_fs27.readFileSync)((0, import_path29.join)(knowledgeDir, f), "utf-8");
+            const content = (0, import_fs28.readFileSync)((0, import_path30.join)(knowledgeDir, f), "utf-8");
             const importance = parseFloat(content.match(/importance:\s*([\d.]+)/)?.[1] ?? "0.5");
             const isPinned = /pinned:\s*true/i.test(content);
             const tsPart = f.slice(0, 19);
@@ -18006,9 +18092,9 @@ Skills are auto-injected from agent config. Project-wide skills in .gossip/skill
        * Annotates TODO/remaining lines where the referenced tool actually exists.
        */
       verifyToolClaims(content) {
-        const mcpPath = (0, import_path29.join)(this.projectRoot, "apps", "cli", "src", "mcp-server-sdk.ts");
-        if (!(0, import_fs27.existsSync)(mcpPath)) return content;
-        const rawSource = (0, import_fs27.readFileSync)(mcpPath, "utf-8");
+        const mcpPath = (0, import_path30.join)(this.projectRoot, "apps", "cli", "src", "mcp-server-sdk.ts");
+        if (!(0, import_fs28.existsSync)(mcpPath)) return content;
+        const rawSource = (0, import_fs28.readFileSync)(mcpPath, "utf-8");
         const source = rawSource.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "");
         const keywordRe = /TODO|remaining|deferred|needed|pending/i;
         const toolRe = /gossip_\w+/;
@@ -18026,10 +18112,10 @@ Skills are auto-injected from agent config. Project-wide skills in .gossip/skill
       }
       /** Read .gossip/next-session.md if it exists — user/orchestrator notes for the next session */
       readNextSessionNotes() {
-        const notesPath = (0, import_path29.join)(this.projectRoot, ".gossip", "next-session.md");
-        if (!(0, import_fs27.existsSync)(notesPath)) return null;
+        const notesPath = (0, import_path30.join)(this.projectRoot, ".gossip", "next-session.md");
+        if (!(0, import_fs28.existsSync)(notesPath)) return null;
         try {
-          const content = (0, import_fs27.readFileSync)(notesPath, "utf-8").trim();
+          const content = (0, import_fs28.readFileSync)(notesPath, "utf-8").trim();
           if (content.length === 0) return null;
           return this.verifyToolClaims(content.slice(0, 3e3));
         } catch {
@@ -18243,13 +18329,13 @@ var init_check_effectiveness = __esm({
 });
 
 // packages/orchestrator/src/skill-engine.ts
-var import_fs28, import_crypto9, import_path30, SAFE_NAME, KNOWN_CATEGORIES, CATEGORY_KEYWORDS, REQUIRED_SECTIONS, BUNDLED_TEMPLATE, SkillEngine;
+var import_fs29, import_crypto9, import_path31, SAFE_NAME, KNOWN_CATEGORIES, CATEGORY_KEYWORDS, REQUIRED_SECTIONS, BUNDLED_TEMPLATE, SkillEngine;
 var init_skill_engine = __esm({
   "packages/orchestrator/src/skill-engine.ts"() {
     "use strict";
-    import_fs28 = require("fs");
+    import_fs29 = require("fs");
     import_crypto9 = require("crypto");
-    import_path30 = require("path");
+    import_path31 = require("path");
     init_skill_name();
     init_check_effectiveness();
     SAFE_NAME = /^[a-z0-9][a-z0-9_-]{0,62}$/;
@@ -18329,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.`);
         }
@@ -18350,9 +18442,9 @@ NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
           }
         }
         let projectContext = "";
-        const bootstrapPath = (0, import_path30.join)(this.projectRoot, ".gossip", "bootstrap.md");
-        if ((0, import_fs28.existsSync)(bootstrapPath)) {
-          projectContext = (0, import_fs28.readFileSync)(bootstrapPath, "utf-8").slice(0, 1500);
+        const bootstrapPath = (0, import_path31.join)(this.projectRoot, ".gossip", "bootstrap.md");
+        if ((0, import_fs29.existsSync)(bootstrapPath)) {
+          projectContext = (0, import_fs29.readFileSync)(bootstrapPath, "utf-8").slice(0, 1500);
         }
         if (this.techStackCache === void 0) {
           this.techStackCache = await this.detectTechStack();
@@ -18368,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.
@@ -18383,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."}
@@ -18418,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_path30.join)(this.projectRoot, ".gossip", "agents", agentId, "skills");
-        (0, import_fs28.mkdirSync)(skillDir, { recursive: true });
-        const skillPath = (0, import_path30.join)(skillDir, `${skillName}.md`);
-        (0, import_fs28.writeFileSync)(skillPath, cleaned);
-        return { path: skillPath, content: cleaned };
+        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 });
+        (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
@@ -18481,24 +18588,24 @@ ${fm}
         }
       }
       loadTemplate() {
-        const userDir = (0, import_path30.join)(this.projectRoot, ".gossip", "skill-templates");
-        if ((0, import_fs28.existsSync)(userDir)) {
-          const files = (0, import_fs28.readdirSync)(userDir).filter((f) => f.endsWith(".md"));
+        const userDir = (0, import_path31.join)(this.projectRoot, ".gossip", "skill-templates");
+        if ((0, import_fs29.existsSync)(userDir)) {
+          const files = (0, import_fs29.readdirSync)(userDir).filter((f) => f.endsWith(".md"));
           if (files.length > 0) {
-            return (0, import_fs28.readFileSync)((0, import_path30.join)(userDir, files[0]), "utf-8");
+            return (0, import_fs29.readFileSync)((0, import_path31.join)(userDir, files[0]), "utf-8");
           }
         }
         const home = process.env.HOME || process.env.USERPROFILE || "";
-        const cacheBase = (0, import_path30.join)(home, ".claude", "plugins", "cache", "claude-plugins-official", "superpowers");
-        if ((0, import_fs28.existsSync)(cacheBase)) {
+        const cacheBase = (0, import_path31.join)(home, ".claude", "plugins", "cache", "claude-plugins-official", "superpowers");
+        if ((0, import_fs29.existsSync)(cacheBase)) {
           try {
-            const versions = (0, import_fs28.readdirSync)(cacheBase).sort().reverse();
+            const versions = (0, import_fs29.readdirSync)(cacheBase).sort().reverse();
             for (const ver of versions) {
-              const skillPath = (0, import_path30.join)(cacheBase, ver, "skills", "systematic-debugging", "SKILL.md");
-              if ((0, import_fs28.existsSync)(skillPath)) {
-                const realPath = (0, import_fs28.realpathSync)(skillPath);
-                if (realPath.startsWith((0, import_path30.resolve)(cacheBase))) {
-                  return (0, import_fs28.readFileSync)(realPath, "utf-8");
+              const skillPath = (0, import_path31.join)(cacheBase, ver, "skills", "systematic-debugging", "SKILL.md");
+              if ((0, import_fs29.existsSync)(skillPath)) {
+                const realPath = (0, import_fs29.realpathSync)(skillPath);
+                if (realPath.startsWith((0, import_path31.resolve)(cacheBase))) {
+                  return (0, import_fs29.readFileSync)(realPath, "utf-8");
                 }
               }
             }
@@ -18514,20 +18621,20 @@ ${fm}
        */
       async detectTechStack() {
         const inputs = [];
-        const pkgPaths = [(0, import_path30.join)(this.projectRoot, "package.json")];
+        const pkgPaths = [(0, import_path31.join)(this.projectRoot, "package.json")];
         try {
-          const packagesDir = (0, import_path30.join)(this.projectRoot, "packages");
-          if ((0, import_fs28.existsSync)(packagesDir)) {
-            for (const dir of (0, import_fs28.readdirSync)(packagesDir)) {
-              const p = (0, import_path30.join)(packagesDir, dir, "package.json");
-              if ((0, import_fs28.existsSync)(p)) pkgPaths.push(p);
+          const packagesDir = (0, import_path31.join)(this.projectRoot, "packages");
+          if ((0, import_fs29.existsSync)(packagesDir)) {
+            for (const dir of (0, import_fs29.readdirSync)(packagesDir)) {
+              const p = (0, import_path31.join)(packagesDir, dir, "package.json");
+              if ((0, import_fs29.existsSync)(p)) pkgPaths.push(p);
             }
           }
         } catch {
         }
         for (const p of pkgPaths.slice(0, 5)) {
           try {
-            const pkg = JSON.parse((0, import_fs28.readFileSync)(p, "utf-8"));
+            const pkg = JSON.parse((0, import_fs29.readFileSync)(p, "utf-8"));
             const deps = Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
             if (deps.length > 0) {
               inputs.push(`${p.replace(this.projectRoot + "/", "")}: ${deps.join(", ")}`);
@@ -18536,7 +18643,7 @@ ${fm}
           }
         }
         try {
-          const srcDirs = ["src", "packages", "apps", "lib"].filter((d) => (0, import_fs28.existsSync)((0, import_path30.join)(this.projectRoot, d)));
+          const srcDirs = ["src", "packages", "apps", "lib"].filter((d) => (0, import_fs29.existsSync)((0, import_path31.join)(this.projectRoot, d)));
           inputs.push(`Source dirs: ${srcDirs.join(", ") || "root"}`);
         } catch {
         }
@@ -18563,10 +18670,10 @@ ${inputs.join("\n")}
         }
       }
       loadCategoryFindings(category) {
-        const filePath = (0, import_path30.join)(this.projectRoot, ".gossip", "agent-performance.jsonl");
-        if (!(0, import_fs28.existsSync)(filePath)) return [];
+        const filePath = (0, import_path31.join)(this.projectRoot, ".gossip", "agent-performance.jsonl");
+        if (!(0, import_fs29.existsSync)(filePath)) return [];
         try {
-          return (0, import_fs28.readFileSync)(filePath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
+          return (0, import_fs29.readFileSync)(filePath, "utf-8").trim().split("\n").filter(Boolean).map((line) => {
             try {
               return JSON.parse(line);
             } catch {
@@ -18596,10 +18703,10 @@ ${inputs.join("\n")}
           return { status: "pending", shouldUpdate: false };
         }
         const skillPath = this.resolveSkillPath(agentId, category);
-        if (!(0, import_fs28.existsSync)(skillPath)) {
+        if (!(0, import_fs29.existsSync)(skillPath)) {
           return { status: "pending", shouldUpdate: false };
         }
-        const raw = (0, import_fs28.readFileSync)(skillPath, "utf-8");
+        const raw = (0, import_fs29.readFileSync)(skillPath, "utf-8");
         const { frontmatter: rawFrontmatter, body } = this.parseSkillFile(raw);
         const nowMs = Date.now();
         const { frontmatter, mutated } = this.migrateIfNeeded(
@@ -18677,7 +18784,7 @@ ${inputs.join("\n")}
        */
       resolveSkillPath(agentId, category) {
         const skillName = normalizeSkillName(category);
-        return (0, import_path30.join)(this.projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
+        return (0, import_path31.join)(this.projectRoot, ".gossip", "agents", agentId, "skills", `${skillName}.md`);
       }
       /**
        * Splits a skill file into its frontmatter key-value map and the body text
@@ -18765,11 +18872,11 @@ ${fmLines.join("\n")}
 ---${body}`;
         const tmpPath = `${skillPath}.tmp.${process.pid}.${(0, import_crypto9.randomBytes)(4).toString("hex")}`;
         try {
-          (0, import_fs28.writeFileSync)(tmpPath, content, "utf-8");
-          (0, import_fs28.renameSync)(tmpPath, skillPath);
+          (0, import_fs29.writeFileSync)(tmpPath, content, "utf-8");
+          (0, import_fs29.renameSync)(tmpPath, skillPath);
         } catch (err) {
           try {
-            (0, import_fs28.unlinkSync)(tmpPath);
+            (0, import_fs29.unlinkSync)(tmpPath);
           } catch {
           }
           throw err;
@@ -18780,12 +18887,12 @@ ${fmLines.join("\n")}
 });
 
 // packages/orchestrator/src/memory-searcher.ts
-var import_fs29, import_path31, MAX_QUERY_LENGTH, MAX_KEYWORDS, MAX_TASK_FILE_BYTES, MemorySearcher;
+var import_fs30, import_path32, MAX_QUERY_LENGTH, MAX_KEYWORDS, MAX_TASK_FILE_BYTES, MemorySearcher;
 var init_memory_searcher = __esm({
   "packages/orchestrator/src/memory-searcher.ts"() {
     "use strict";
-    import_fs29 = require("fs");
-    import_path31 = require("path");
+    import_fs30 = require("fs");
+    import_path32 = require("path");
     MAX_QUERY_LENGTH = 500;
     MAX_KEYWORDS = 20;
     MAX_TASK_FILE_BYTES = 2 * 1024 * 1024;
@@ -18800,19 +18907,19 @@ var init_memory_searcher = __esm({
         const limit = Math.min(maxResults, 10);
         const keywords = this.extractKeywords(safeQuery);
         if (keywords.length === 0) return [];
-        const memDir = (0, import_path31.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
-        if (!(0, import_fs29.existsSync)(memDir)) return [];
+        const memDir = (0, import_path32.join)(this.projectRoot, ".gossip", "agents", agentId, "memory");
+        if (!(0, import_fs30.existsSync)(memDir)) return [];
         const results = [];
-        const knowledgeDir = (0, import_path31.join)(memDir, "knowledge");
-        if ((0, import_fs29.existsSync)(knowledgeDir)) {
-          const files = (0, import_fs29.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+        const knowledgeDir = (0, import_path32.join)(memDir, "knowledge");
+        if ((0, import_fs30.existsSync)(knowledgeDir)) {
+          const files = (0, import_fs30.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
           for (const file2 of files) {
-            const filePath = (0, import_path31.join)(knowledgeDir, file2);
+            const filePath = (0, import_path32.join)(knowledgeDir, file2);
             try {
-              const content = (0, import_fs29.readFileSync)(filePath, "utf-8");
+              const content = (0, import_fs30.readFileSync)(filePath, "utf-8");
               const frontmatter = this.parseFrontmatter(content);
               const body = content.replace(/^---[\s\S]*?---\n*/, "");
-              const name = frontmatter?.name || (0, import_path31.basename)(file2, ".md");
+              const name = frontmatter?.name || (0, import_path32.basename)(file2, ".md");
               const description = frontmatter?.description || "";
               const importance = frontmatter?.importance ?? 0.5;
               const score = this.scoreContent(keywords, name, description, body, importance);
@@ -18829,12 +18936,12 @@ var init_memory_searcher = __esm({
             }
           }
         }
-        const tasksPath = (0, import_path31.join)(memDir, "tasks.jsonl");
-        if ((0, import_fs29.existsSync)(tasksPath)) {
+        const tasksPath = (0, import_path32.join)(memDir, "tasks.jsonl");
+        if ((0, import_fs30.existsSync)(tasksPath)) {
           try {
-            const stat3 = (0, import_fs29.statSync)(tasksPath);
+            const stat3 = (0, import_fs30.statSync)(tasksPath);
             if (stat3.size > MAX_TASK_FILE_BYTES) return results.sort((a, b) => b.score - a.score).slice(0, limit);
-            const lines = (0, import_fs29.readFileSync)(tasksPath, "utf-8").split("\n").filter((l) => l.trim());
+            const lines = (0, import_fs30.readFileSync)(tasksPath, "utf-8").split("\n").filter((l) => l.trim());
             for (const line of lines) {
               try {
                 const entry = JSON.parse(line);
@@ -19120,9 +19227,9 @@ function prependScopeNote(prompt) {
 }
 function readSandboxMode(projectRoot) {
   try {
-    const p = (0, import_path32.join)(projectRoot, ".gossip", "config.json");
-    if (!(0, import_fs30.existsSync)(p)) return "warn";
-    const raw = JSON.parse((0, import_fs30.readFileSync)(p, "utf-8"));
+    const p = (0, import_path33.join)(projectRoot, ".gossip", "config.json");
+    if (!(0, import_fs31.existsSync)(p)) return "warn";
+    const raw = JSON.parse((0, import_fs31.readFileSync)(p, "utf-8"));
     const mode = raw?.sandboxEnforcement;
     if (mode === "off" || mode === "warn" || mode === "block") return mode;
     return "warn";
@@ -19132,17 +19239,17 @@ function readSandboxMode(projectRoot) {
 }
 function recordDispatchMetadata(projectRoot, meta3) {
   try {
-    const dir = (0, import_path32.join)(projectRoot, ".gossip");
-    (0, import_fs30.mkdirSync)(dir, { recursive: true });
-    (0, import_fs30.appendFileSync)((0, import_path32.join)(dir, METADATA_FILE), JSON.stringify(meta3) + "\n");
+    const dir = (0, import_path33.join)(projectRoot, ".gossip");
+    (0, import_fs31.mkdirSync)(dir, { recursive: true });
+    (0, import_fs31.appendFileSync)((0, import_path33.join)(dir, METADATA_FILE), JSON.stringify(meta3) + "\n");
   } catch {
   }
 }
 function lookupDispatchMetadata(projectRoot, taskId) {
   try {
-    const p = (0, import_path32.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs30.existsSync)(p)) return null;
-    const raw = (0, import_fs30.readFileSync)(p, "utf-8");
+    const p = (0, import_path33.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs31.existsSync)(p)) return null;
+    const raw = (0, import_fs31.readFileSync)(p, "utf-8");
     const lines = raw.split("\n").filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
@@ -19174,21 +19281,21 @@ function parseGitStatus(porcelain) {
 function normalizeScope(scope, projectRoot) {
   let s = scope.trim();
   if (!s) return "";
-  if ((0, import_path32.isAbsolute)(s)) {
-    s = (0, import_path32.relative)(projectRoot, s);
+  if ((0, import_path33.isAbsolute)(s)) {
+    s = (0, import_path33.relative)(projectRoot, s);
   } else if (s.startsWith("./")) {
     s = s.slice(2);
   }
-  s = (0, import_path32.normalize)(s).replace(/\/+$/, "");
+  s = (0, import_path33.normalize)(s).replace(/\/+$/, "");
   if (s === "." || s === "") return "";
   return s;
 }
 function isInsideScope(filePath, scope) {
   if (!scope) return true;
-  const f = (0, import_path32.normalize)(filePath).replace(/^\.\//, "");
+  const f = (0, import_path33.normalize)(filePath).replace(/^\.\//, "");
   const s = scope.replace(/^\.\//, "").replace(/\/+$/, "");
   if (f === s) return true;
-  return f.startsWith(s + "/") || f.startsWith(s + import_path32.sep);
+  return f.startsWith(s + "/") || f.startsWith(s + import_path33.sep);
 }
 function detectBoundaryEscapes(meta3, modifiedFiles, projectRoot) {
   const mode = meta3.writeMode;
@@ -19250,8 +19357,8 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
   } catch {
   }
   try {
-    const dir = (0, import_path32.join)(projectRoot, ".gossip");
-    (0, import_fs30.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path33.join)(projectRoot, ".gossip");
+    (0, import_fs31.mkdirSync)(dir, { recursive: true });
     const line = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       taskId: meta3.taskId,
@@ -19262,17 +19369,17 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
       action: mode
       // "warn" or "block"
     };
-    (0, import_fs30.appendFileSync)((0, import_path32.join)(dir, BOUNDARY_ESCAPE_FILE), JSON.stringify(line) + "\n");
+    (0, import_fs31.appendFileSync)((0, import_path33.join)(dir, BOUNDARY_ESCAPE_FILE), JSON.stringify(line) + "\n");
   } catch {
   }
 }
-var import_child_process4, import_fs30, import_path32, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SYSTEM_PREFIXES, SCOPE_NOTE, __test__;
+var import_child_process4, import_fs31, import_path33, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SYSTEM_PREFIXES, SCOPE_NOTE, __test__;
 var init_sandbox2 = __esm({
   "apps/cli/src/sandbox.ts"() {
     "use strict";
     import_child_process4 = require("child_process");
-    import_fs30 = require("fs");
-    import_path32 = require("path");
+    import_fs31 = require("fs");
+    import_path33 = require("path");
     METADATA_FILE = "dispatch-metadata.jsonl";
     BOUNDARY_ESCAPE_FILE = "boundary-escapes.jsonl";
     SYSTEM_PREFIXES = [
@@ -19356,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,
@@ -19405,6 +19512,10 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
   round.pendingNativeAgents.delete(agent_id);
   process.stderr.write(`[gossipcat] \u{1F4E8} Cross-review received from ${agent_id}. Remaining: ${round.pendingNativeAgents.size}
 `);
+  let parsedCount = 0;
+  let acceptedCount = 0;
+  const rejectedPeerIds = /* @__PURE__ */ new Set();
+  let parseError = null;
   try {
     const { ConsensusEngine: ConsensusEngine2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
     const parseLlm = ctx.mainAgent.getLlm();
@@ -19414,14 +19525,51 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
       projectRoot: process.cwd()
     });
     const entries = engine.parseCrossReviewResponse(agent_id, result, 50);
+    parsedCount = entries.length;
     const validPeerIds = new Set(round.allResults.map((r) => r.agentId));
-    const filtered = entries.filter((e) => e.peerAgentId !== agent_id && validPeerIds.has(e.peerAgentId));
+    const filtered = entries.filter((e) => {
+      const selfReview = e.peerAgentId === agent_id;
+      const unknownPeer = !validPeerIds.has(e.peerAgentId);
+      if (selfReview || unknownPeer) {
+        if (e.peerAgentId) rejectedPeerIds.add(e.peerAgentId);
+        return false;
+      }
+      return true;
+    });
+    acceptedCount = filtered.length;
     round.nativeCrossReviewEntries.push(...filtered);
+    if (parsedCount > 0 && acceptedCount === 0) {
+      process.stderr.write(
+        `[gossipcat] \u26A0\uFE0F  Cross-review from ${agent_id}: all ${parsedCount} entries rejected. Bad peer IDs: [${[...rejectedPeerIds].join(", ")}]. Valid round members: [${[...validPeerIds].join(", ")}]. Expected findingId format "<peerAgentId>:f<N>".
+`
+      );
+    } else if (parsedCount > acceptedCount) {
+      process.stderr.write(
+        `[gossipcat] \u26A0\uFE0F  Cross-review from ${agent_id}: ${parsedCount - acceptedCount}/${parsedCount} entries rejected (bad peer IDs: [${[...rejectedPeerIds].join(", ")}]).
+`
+      );
+    }
   } catch (err) {
-    process.stderr.write(`[gossipcat] Failed to parse cross-review from ${agent_id}: ${err.message}
+    parseError = err.message;
+    process.stderr.write(`[gossipcat] Failed to parse cross-review from ${agent_id}: ${parseError}
 `);
   }
   persistPendingConsensus();
+  const validPeerList = [...new Set(round.allResults.map((r) => r.agentId))].join(", ");
+  let diagnostic = "";
+  if (parseError) {
+    diagnostic = `
+\u26A0\uFE0F  Parse error: ${parseError}`;
+  } else if (parsedCount > 0 && acceptedCount === 0) {
+    diagnostic = `
+\u26A0\uFE0F  All ${parsedCount} entries were REJECTED. Bad peer IDs: [${[...rejectedPeerIds].join(", ")}]. Valid round members: [${validPeerList}]. Expected findingId format "<peerAgentId>:f<N>" using exact agent IDs from the round.`;
+  } else if (parsedCount > acceptedCount) {
+    diagnostic = `
+\u26A0\uFE0F  ${parsedCount - acceptedCount}/${parsedCount} entries rejected (bad peer IDs: [${[...rejectedPeerIds].join(", ")}]). Valid round members: [${validPeerList}].`;
+  } else if (parsedCount > 0) {
+    diagnostic = `
+\u2705 ${acceptedCount}/${parsedCount} entries accepted.`;
+  }
   if (round.pendingNativeAgents.size > 0) {
     const EXTENSION_MS = 6e5;
     const MAX_TOTAL_MS = 36e5;
@@ -19430,7 +19578,7 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
     return {
       content: [{
         type: "text",
-        text: `Cross-review from ${agent_id} received. Waiting for ${round.pendingNativeAgents.size} more agent(s): ${[...round.pendingNativeAgents].join(", ")}`
+        text: `Cross-review from ${agent_id} received. Waiting for ${round.pendingNativeAgents.size} more agent(s): ${[...round.pendingNativeAgents].join(", ")}${diagnostic}`
       }]
     };
   }
@@ -19467,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,
@@ -19512,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] = {
@@ -19537,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}
 `);
@@ -19545,11 +19693,11 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync41, readFileSync: readFileSync40, unlinkSync: unlinkSync4 } = require("fs");
-    const { join: join48 } = require("path");
-    const filePath = join48(projectRoot, ".gossip", CONSENSUS_FILE);
-    if (!existsSync41(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) {
@@ -19592,15 +19740,15 @@ __export(check_effectiveness_runner_exports, {
   runCheckEffectivenessForAllSkills: () => runCheckEffectivenessForAllSkills
 });
 async function runCheckEffectivenessForAllSkills(opts) {
-  const baseDir = (0, import_path34.join)(opts.projectRoot, ".gossip", "agents");
-  if (!(0, import_fs32.existsSync)(baseDir)) return;
-  const agentDirs = (0, import_fs32.readdirSync)(baseDir);
+  const baseDir = (0, import_path35.join)(opts.projectRoot, ".gossip", "agents");
+  if (!(0, import_fs33.existsSync)(baseDir)) return;
+  const agentDirs = (0, import_fs33.readdirSync)(baseDir);
   for (const agentId of agentDirs) {
-    const skillsDir = (0, import_path34.join)(baseDir, agentId, "skills");
-    if (!(0, import_fs32.existsSync)(skillsDir)) continue;
+    const skillsDir = (0, import_path35.join)(baseDir, agentId, "skills");
+    if (!(0, import_fs33.existsSync)(skillsDir)) continue;
     const role = opts.registryGet(agentId)?.role;
     if (role === "implementer") continue;
-    const files = (0, import_fs32.readdirSync)(skillsDir).filter((f) => f.endsWith(".md"));
+    const files = (0, import_fs33.readdirSync)(skillsDir).filter((f) => f.endsWith(".md"));
     for (const file2 of files) {
       const category = file2.replace(/\.md$/, "");
       try {
@@ -19621,12 +19769,12 @@ async function runCheckEffectivenessForAllSkills(opts) {
     }
   }
 }
-var import_fs32, import_path34;
+var import_fs33, import_path35;
 var init_check_effectiveness_runner = __esm({
   "apps/cli/src/handlers/check-effectiveness-runner.ts"() {
     "use strict";
-    import_fs32 = require("fs");
-    import_path34 = require("path");
+    import_fs33 = require("fs");
+    import_path35 = require("path");
   }
 });
 
@@ -20309,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_path35.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if ((0, import_fs33.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_fs33.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);
@@ -20364,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_path35.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if ((0, import_fs33.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_fs33.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;
@@ -20397,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_fs33, import_path35;
+var import_fs35, import_path37;
 var init_api_overview = __esm({
   "packages/relay/src/dashboard/api-overview.ts"() {
     "use strict";
-    import_fs33 = require("fs");
-    import_path35 = require("path");
+    import_fs35 = require("fs");
+    import_path37 = require("path");
   }
 });
 
 // packages/relay/src/dashboard/api-agents.ts
 function readTaskGraphByAgent(projectRoot) {
-  const taskGraphPath = (0, import_path36.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_fs34.existsSync)(taskGraphPath)) return result;
+  if (!(0, import_fs36.existsSync)(taskGraphPath)) return result;
   let lines;
   try {
-    lines = (0, import_fs34.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;
   }
@@ -20509,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_fs34, import_path36, 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_fs34 = require("fs");
-    import_path36 = require("path");
+    import_fs36 = require("fs");
+    import_path38 = require("path");
     DEFAULT_SCORE = {
       agentId: "",
       accuracy: 0.5,
@@ -20545,7 +20718,7 @@ var init_api_agents = __esm({
 
 // packages/relay/src/dashboard/api-skills.ts
 function isCorrupt(projectRoot, index) {
-  return (0, import_fs35.existsSync)((0, import_path37.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 {
@@ -20574,13 +20747,13 @@ async function skillsBindHandler(projectRoot, body) {
     return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
   }
 }
-var import_fs35, import_path37, 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_fs35 = require("fs");
-    import_path37 = require("path");
+    import_fs37 = require("fs");
+    import_path39 = require("path");
     AGENT_ID_RE2 = /^[a-zA-Z0-9_-]{1,64}$/;
   }
 });
@@ -20588,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_path38.join)(projectRoot, ".gossip", "agents", agentId, "memory");
+  const memDir = (0, import_path40.join)(projectRoot, ".gossip", "agents", agentId, "memory");
   let index = "";
-  const indexPath = (0, import_path38.join)(memDir, "MEMORY.md");
-  if ((0, import_fs36.existsSync)(indexPath)) {
+  const indexPath = (0, import_path40.join)(memDir, "MEMORY.md");
+  if ((0, import_fs38.existsSync)(indexPath)) {
     try {
-      index = (0, import_fs36.readFileSync)(indexPath, "utf-8");
+      index = (0, import_fs38.readFileSync)(indexPath, "utf-8");
     } catch {
     }
   }
   const knowledge = [];
-  const knowledgeDir = (0, import_path38.join)(memDir, "knowledge");
+  const knowledgeDir = (0, import_path40.join)(memDir, "knowledge");
   const knowledgeDirs = [knowledgeDir, memDir];
   for (const dir of knowledgeDirs) {
-    if (!(0, import_fs36.existsSync)(dir)) continue;
+    if (!(0, import_fs38.existsSync)(dir)) continue;
     try {
-      const files = (0, import_fs36.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_fs36.readFileSync)((0, import_path38.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 {
@@ -20616,10 +20789,10 @@ async function memoryHandler(projectRoot, agentId) {
     }
   }
   const tasks = [];
-  const tasksPath = (0, import_path38.join)(memDir, "tasks.jsonl");
-  if ((0, import_fs36.existsSync)(tasksPath)) {
+  const tasksPath = (0, import_path40.join)(memDir, "tasks.jsonl");
+  if ((0, import_fs38.existsSync)(tasksPath)) {
     try {
-      const lines = (0, import_fs36.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));
@@ -20647,12 +20820,12 @@ function parseFrontmatter(raw) {
   }
   return { frontmatter: fm, content: raw.slice(end + 3).trim() };
 }
-var import_fs36, import_path38, 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_fs36 = require("fs");
-    import_path38 = 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"]);
   }
@@ -20664,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_path39.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs37.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_fs37.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);
@@ -20739,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_fs37, import_path39, 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_fs37 = require("fs");
-    import_path39 = 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;
@@ -20756,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_path40.join)(projectRoot, ".gossip", "agent-performance.jsonl");
-  if (!(0, import_fs38.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_fs38.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);
@@ -20776,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_fs38, import_path40, 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_fs38 = require("fs");
-    import_path40 = require("path");
+    import_fs40 = require("fs");
+    import_path42 = require("path");
     MAX_LIMIT = 200;
     DEFAULT_LIMIT = 50;
   }
@@ -20789,29 +20962,29 @@ var init_api_signals = __esm({
 
 // packages/relay/src/dashboard/api-learnings.ts
 async function learningsHandler(projectRoot) {
-  const agentsDir = (0, import_path41.join)(projectRoot, ".gossip", "agents");
-  if (!(0, import_fs39.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_fs39.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_path41.join)(agentsDir, agentId, "memory", "knowledge");
-    if (!(0, import_fs39.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_fs39.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_path41.join)(knowledgeDir, filename);
+      const filepath = (0, import_path43.join)(knowledgeDir, filename);
       try {
-        const stat3 = (0, import_fs39.statSync)(filepath);
-        const raw = (0, import_fs39.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,
@@ -20838,12 +21011,12 @@ function parseFrontmatter2(raw) {
   }
   return fm;
 }
-var import_fs39, import_path41, MAX_LEARNINGS;
+var import_fs41, import_path43, MAX_LEARNINGS;
 var init_api_learnings = __esm({
   "packages/relay/src/dashboard/api-learnings.ts"() {
     "use strict";
-    import_fs39 = require("fs");
-    import_path41 = require("path");
+    import_fs41 = require("fs");
+    import_path43 = require("path");
     MAX_LEARNINGS = 10;
   }
 });
@@ -20854,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_path42.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs40.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_fs40.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);
@@ -20914,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_fs40, import_path42;
+var import_fs42, import_path44;
 var init_api_tasks = __esm({
   "packages/relay/src/dashboard/api-tasks.ts"() {
     "use strict";
-    import_fs40 = require("fs");
-    import_path42 = 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_path43.join)(projectRoot, ".gossip", "task-graph.jsonl");
-  if (!(0, import_fs41.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_fs41.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);
@@ -20957,12 +21130,12 @@ async function activeTasksHandler(projectRoot) {
   active.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
   return { tasks: active.slice(0, 10) };
 }
-var import_fs41, import_path43;
+var import_fs43, import_path45;
 var init_api_active_tasks = __esm({
   "packages/relay/src/dashboard/api-active-tasks.ts"() {
     "use strict";
-    import_fs41 = require("fs");
-    import_path43 = require("path");
+    import_fs43 = require("fs");
+    import_path45 = require("path");
   }
 });
 
@@ -20975,25 +21148,25 @@ function categorize(text) {
   return "other";
 }
 function logsHandler(projectRoot, query) {
-  const logPath = (0, import_path44.join)(projectRoot, ".gossip", "mcp.log");
-  if (!(0, import_fs42.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_fs42.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_fs42.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_fs42.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_fs42.closeSync)(fd);
+    (0, import_fs44.closeSync)(fd);
   }
   let raw = buf.toString("utf-8");
   let lineOffset = 0;
@@ -21001,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_fs42.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_fs42.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++;
@@ -21015,7 +21188,7 @@ function logsHandler(projectRoot, query) {
         pos += n;
       }
     } finally {
-      (0, import_fs42.closeSync)(scanFd);
+      (0, import_fs44.closeSync)(scanFd);
     }
   }
   const allLines = raw.split("\n").filter(Boolean);
@@ -21033,12 +21206,12 @@ function logsHandler(projectRoot, query) {
   entries = entries.slice(-clampedTail);
   return { entries, totalLines, fileSize, filter };
 }
-var import_fs42, import_path44, CATEGORY_PATTERNS2;
+var import_fs44, import_path46, CATEGORY_PATTERNS2;
 var init_api_logs = __esm({
   "packages/relay/src/dashboard/api-logs.ts"() {
     "use strict";
-    import_fs42 = require("fs");
-    import_path44 = require("path");
+    import_fs44 = require("fs");
+    import_path46 = require("path");
     CATEGORY_PATTERNS2 = [
       [/^\[worker:/, "worker"],
       [/^\[Gemini\]/, "gemini"],
@@ -21066,8 +21239,22 @@ var init_api_logs = __esm({
 });
 
 // packages/relay/src/dashboard/routes.ts
+function resolveDashboardRoot(projectRoot) {
+  const candidates = [
+    (0, import_path47.resolve)(__dirname, "..", "dist-dashboard"),
+    // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
+    (0, import_path47.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    // tsc dev: packages/relay/dist/dashboard → repo-root
+    (0, import_path47.join)(projectRoot, "dist-dashboard")
+    // legacy dev fallback (git-clone running from repo root)
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs45.existsSync)(p)) return p;
+  }
+  return null;
+}
 function readBody(req) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve18, reject) => {
     const chunks = [];
     let size = 0;
     let tooLarge = false;
@@ -21082,14 +21269,14 @@ function readBody(req) {
       chunks.push(chunk);
     });
     req.on("end", () => {
-      if (!tooLarge) resolve17(Buffer.concat(chunks).toString("utf-8"));
+      if (!tooLarge) resolve18(Buffer.concat(chunks).toString("utf-8"));
     });
     req.on("error", (err) => {
       if (!tooLarge) reject(err);
     });
   });
 }
-var import_fs43, import_path45, 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";
@@ -21103,8 +21290,8 @@ var init_routes = __esm({
     init_api_tasks();
     init_api_active_tasks();
     init_api_logs();
-    import_fs43 = require("fs");
-    import_path45 = require("path");
+    import_fs45 = require("fs");
+    import_path47 = require("path");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
     DashboardRouter = class {
@@ -21112,8 +21299,10 @@ var init_routes = __esm({
         this.auth = auth;
         this.projectRoot = projectRoot;
         this.ctx = ctx2;
+        this.dashboardRoot = resolveDashboardRoot(projectRoot);
       }
       authAttempts = /* @__PURE__ */ new Map();
+      dashboardRoot;
       /** Update live context (call when agents connect/disconnect) */
       updateContext(ctx2) {
         if (ctx2.agentConfigs !== void 0) this.ctx.agentConfigs = ctx2.agentConfigs;
@@ -21279,18 +21468,24 @@ var init_routes = __esm({
         return true;
       }
       serveDashboard(res) {
-        const htmlPath = (0, import_path45.join)(this.projectRoot, "dist-dashboard", "index.html");
-        if (!(0, import_fs43.existsSync)(htmlPath)) {
+        if (!this.dashboardRoot) {
           res.writeHead(503, { "Content-Type": "text/plain" });
-          res.end("Dashboard not built. Run: npm run build:dashboard");
+          res.end("Dashboard assets not found. Reinstall gossipcat or rebuild from source.");
           return true;
         }
-        const html = (0, import_fs43.readFileSync)(htmlPath, "utf-8");
+        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_fs45.readFileSync)(htmlPath, "utf-8");
         res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
         res.end(html);
         return true;
       }
       serveStaticFile(res, url2) {
+        if (!this.dashboardRoot) return false;
         const relativePath = url2.replace(/^\/dashboard\//, "");
         if (relativePath.includes("..")) {
           res.writeHead(404);
@@ -21310,16 +21505,16 @@ var init_routes = __esm({
         const ext = "." + (relativePath.split(".").pop() || "");
         const mime = MIME[ext];
         if (!mime) return false;
-        const filePath = (0, import_path45.join)(this.projectRoot, "dist-dashboard", relativePath);
+        const filePath = (0, import_path47.join)(this.dashboardRoot, relativePath);
         try {
-          const realFile = (0, import_fs43.realpathSync)(filePath);
-          const realBase = (0, import_fs43.realpathSync)((0, import_path45.resolve)(this.projectRoot, "dist-dashboard"));
+          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_fs43.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;
@@ -21334,15 +21529,15 @@ var init_routes = __esm({
         return match ? match[1] : null;
       }
       getConsensusReports(page = 1, pageSize = 5) {
-        const { readdirSync: readdirSync13, readFileSync: readFileSync40, existsSync: existsSync41 } = require("fs");
-        const reportsDir = (0, import_path45.join)(this.projectRoot, ".gossip", "consensus-reports");
-        if (!existsSync41(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_path45.join)(reportsDir, a)).mtimeMs;
-              const bTime = statSync9((0, import_path45.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;
@@ -21353,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_fs43.realpathSync)(reportsDir);
+          const realReportsDir = (0, import_fs45.realpathSync)(reportsDir);
           const reports = files.map((f) => {
             try {
-              const filePath = (0, import_path45.join)(reportsDir, f);
-              const realFile = (0, import_fs43.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;
             }
@@ -21370,29 +21565,29 @@ var init_routes = __esm({
         }
       }
       archiveFindings() {
-        const { readdirSync: readdirSync13, readFileSync: readFileSync40, renameSync: renameSync2, writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync41 } = require("fs");
-        const reportsDir = (0, import_path45.join)(this.projectRoot, ".gossip", "consensus-reports");
-        const archiveDir = (0, import_path45.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 (existsSync41(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_path45.join)(reportsDir, f), (0, import_path45.join)(archiveDir, f));
+                renameSync2((0, import_path47.join)(reportsDir, f), (0, import_path47.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path45.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path47.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
-        if (existsSync41(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);
@@ -21405,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 = existsSync41(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) {
@@ -21422,14 +21617,14 @@ var init_routes = __esm({
 });
 
 // packages/relay/src/dashboard/ws.ts
-var import_ws3, import_fs44, import_fs45, import_path46, 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_fs44 = require("fs");
-    import_fs45 = require("fs");
-    import_path46 = require("path");
+    import_fs46 = require("fs");
+    import_fs47 = require("fs");
+    import_path48 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -21454,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_path46.join)(projectRoot, ".gossip", "mcp.log");
-        if (!(0, import_fs44.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_fs44.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs46.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs45.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs47.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -21479,7 +21674,7 @@ var init_ws = __esm({
         if (this.logReading) return;
         this.logReading = true;
         try {
-          const currentSize = (0, import_fs44.statSync)(this.logPath).size;
+          const currentSize = (0, import_fs46.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -21492,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_fs44.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;
@@ -21586,7 +21781,7 @@ var init_server = __esm({
         return `ws://localhost:${this._port}`;
       }
       async start() {
-        return new Promise((resolve17) => {
+        return new Promise((resolve18) => {
           this.httpServer = (0, import_http.createServer)(this.handleHttp.bind(this));
           if (this.config.dashboard) {
             this.dashboardAuth = new DashboardAuth();
@@ -21631,7 +21826,7 @@ var init_server = __esm({
           this.httpServer.listen(this.config.port, this.config.host ?? "127.0.0.1", () => {
             const addr = this.httpServer.address();
             this._port = addr.port;
-            resolve17();
+            resolve18();
           });
         });
       }
@@ -21650,9 +21845,9 @@ var init_server = __esm({
         for (const client of this.wss.clients) {
           client.close(1001, "Server shutting down");
         }
-        return new Promise((resolve17) => {
+        return new Promise((resolve18) => {
           this.wss.close(() => {
-            this.httpServer.close(() => resolve17());
+            this.httpServer.close(() => resolve18());
           });
         });
       }
@@ -21848,18 +22043,18 @@ __export(config_exports, {
 function findConfigPath(projectRoot) {
   const root = projectRoot || process.cwd();
   const candidates = [
-    (0, import_path47.resolve)(root, ".gossip", "config.json"),
-    (0, import_path47.resolve)(root, "gossip.agents.json"),
-    (0, import_path47.resolve)(root, "gossip.agents.yaml"),
-    (0, import_path47.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_fs46.existsSync)(p)) return p;
+    if ((0, import_fs48.existsSync)(p)) return p;
   }
   return null;
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs46.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs48.readFileSync)(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -21938,19 +22133,19 @@ function configToAgentConfigs(config2) {
 }
 function loadClaudeSubagents(projectRoot, existingIds) {
   const root = projectRoot || process.cwd();
-  const agentsDir = (0, import_path47.join)(root, ".claude", "agents");
-  if (!(0, import_fs46.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_fs46.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_path47.join)(agentsDir, file2);
+    const filePath = (0, import_path49.join)(agentsDir, file2);
     try {
-      const content = (0, import_fs46.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];
@@ -22005,12 +22200,12 @@ function inferSkills(description, name) {
   if (skills.length === 0) skills.push("general");
   return skills;
 }
-var import_fs46, import_path47, 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_fs46 = require("fs");
-    import_path47 = 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" },
@@ -22025,14 +22220,14 @@ var keychain_exports = {};
 __export(keychain_exports, {
   Keychain: () => Keychain
 });
-var import_child_process5, import_os2, import_fs47, import_path48, 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_fs47 = require("fs");
-    import_path48 = 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}$/;
@@ -22074,10 +22269,10 @@ var init_keychain = __esm({
         return (0, import_crypto15.pbkdf2Sync)(seed, salt, 6e5, 32, "sha256");
       }
       loadEncryptedFile() {
-        const filePath = (0, import_path48.join)(process.cwd(), ENCRYPTED_FILE);
-        if (!(0, import_fs47.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_fs47.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);
@@ -22095,9 +22290,9 @@ var init_keychain = __esm({
         }
       }
       saveEncryptedFile() {
-        const filePath = (0, import_path48.join)(process.cwd(), ENCRYPTED_FILE);
-        const dir = (0, import_path48.join)(process.cwd(), ".gossip");
-        if (!(0, import_fs47.existsSync)(dir)) (0, import_fs47.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);
@@ -22105,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_fs47.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") {
@@ -22205,17 +22400,17 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path49.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path51.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs48.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_fs48.mkdirSync)((0, import_path49.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs50.mkdirSync)((0, import_path51.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs48.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs50.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs48.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs50.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
@@ -22265,12 +22460,12 @@ function getProjectId(projectRoot) {
   }
   return (0, import_crypto16.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 16);
 }
-var import_fs48, import_path49, 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_fs48 = require("fs");
-    import_path49 = require("path");
+    import_fs50 = require("fs");
+    import_path51 = require("path");
     import_crypto16 = require("crypto");
     import_child_process6 = require("child_process");
   }
@@ -22282,14 +22477,8 @@ __export(gossip_update_exports, {
   handleGossipUpdate: () => handleGossipUpdate
 });
 function getCurrentVersion() {
-  try {
-    const pkgPath = (0, import_path50.resolve)(__dirname, "..", "..", "..", "..", "package.json");
-    if ((0, import_fs49.existsSync)(pkgPath)) {
-      return JSON.parse((0, import_fs49.readFileSync)(pkgPath, "utf-8")).version ?? "0.0.0";
-    }
-  } catch {
-  }
-  return "0.0.0";
+  const v = getGossipcatVersion();
+  return v === "unknown" ? "0.0.0" : v;
 }
 async function getLatestVersion() {
   const res = await fetch("https://registry.npmjs.org/gossipcat/latest");
@@ -22298,9 +22487,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path50.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path52.resolve)(__dirname, "..", "..", "..", "..");
   if (process.env.npm_config_global === "true") return "global";
-  if ((0, import_fs49.existsSync)((0, import_path50.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) {
@@ -22351,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_path50.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
+      cwd: method === "git-clone" ? (0, import_path52.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
     });
   } catch (err) {
     return {
@@ -22373,13 +22562,14 @@ Run /mcp reconnect in Claude Code to load the new version.`
     }]
   };
 }
-var import_child_process7, import_fs49, import_path50;
+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_fs49 = require("fs");
-    import_path50 = require("path");
+    import_fs51 = require("fs");
+    import_path52 = require("path");
+    init_version();
   }
 });
 
@@ -22542,8 +22732,8 @@ var init_verify_memory = __esm({
 });
 
 // apps/cli/src/mcp-server-sdk.ts
-var import_fs50 = require("fs");
-var import_path51 = 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");
@@ -36320,6 +36510,7 @@ config(en_default());
 var import_crypto17 = require("crypto");
 var import_http2 = require("http");
 init_mcp_context();
+init_version();
 
 // apps/cli/src/handlers/native-tasks.ts
 var import_crypto10 = require("crypto");
@@ -36724,8 +36915,8 @@ ${utilityBlocks.join("\n\n")}`;
 
 // apps/cli/src/handlers/dispatch.ts
 var import_crypto11 = require("crypto");
-var import_fs31 = require("fs");
-var import_path33 = require("path");
+var import_fs32 = require("fs");
+var import_path34 = require("path");
 init_src4();
 init_src3();
 init_mcp_context();
@@ -36842,7 +37033,7 @@ var AGENT_PROVIDER_MAP = {
 };
 function readQuotaState() {
   try {
-    const raw = (0, import_fs31.readFileSync)((0, import_path33.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
+    const raw = (0, import_fs32.readFileSync)((0, import_path34.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -37188,8 +37379,8 @@ async function handleDispatchConsensus(taskDefs, _utility_task_id) {
       });
       const lenses = await Promise.race([
         lensPromise,
-        new Promise((resolve17) => {
-          timerId = setTimeout(() => resolve17(null), LENS_TIMEOUT_MS);
+        new Promise((resolve18) => {
+          timerId = setTimeout(() => resolve18(null), LENS_TIMEOUT_MS);
         })
       ]);
       if (timerId) clearTimeout(timerId);
@@ -37405,7 +37596,7 @@ Relay may be down. Check gossip_status() for connection state.` }] };
         process.stderr.write(`[gossipcat] \u23F3 Consensus: ${doneCount}/${pendingNativeIds.length} agents complete (${agentStatus})
 `);
       }
-      await new Promise((resolve17) => setTimeout(resolve17, POLL_INTERVAL));
+      await new Promise((resolve18) => setTimeout(resolve18, POLL_INTERVAL));
     }
     const arrived = pendingNativeIds.filter((id) => ctx.nativeResultMap.has(id)).length;
     const timedOutCount = pendingNativeIds.filter((id) => {
@@ -37902,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_path51.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_fs50.mkdirSync)(gossipDir, { recursive: true });
+  (0, import_fs52.mkdirSync)(gossipDir, { recursive: true });
 } catch {
 }
-var logStream = (0, import_fs50.createWriteStream)((0, import_path51.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);
 });
@@ -38071,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: existsSync41, readdirSync: readdirSync13, readFileSync: readFileSync40 } = require("fs");
-  const { join: join48 } = require("path");
-  const reportsDir = join48(projectRoot, ".gossip", "consensus-reports");
-  if (!existsSync41(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) {
@@ -38144,12 +38407,21 @@ async function refreshBootstrap() {
 async function doBoot() {
   const m = await getModules();
   const configPath = m.findConfigPath();
-  if (!configPath) throw new Error("No gossip.agents.json found. Run gossipcat setup first.");
-  const config2 = m.loadConfig(configPath);
+  let config2;
+  if (configPath) {
+    config2 = m.loadConfig(configPath);
+  } else {
+    process.stderr.write("[gossipcat] \u26A0\uFE0F  No gossip.agents.json found \u2014 booting in degraded mode (dashboard + relay only). Run gossip_setup inside Claude Code to create your agent team.\n");
+    config2 = {
+      main_agent: { provider: "none", model: "none" },
+      utility_model: { provider: "none", model: "none" },
+      agents: {}
+    };
+  }
   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_path51.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) {
@@ -38162,8 +38434,11 @@ async function doBoot() {
     }
   }
   const relayApiKey = (0, import_crypto17.randomBytes)(32).toString("hex");
+  const relayPick = await pickStickyPort("GOSSIPCAT_PORT", RELAY_STICKY_FILE);
+  const relayPort = relayPick.port;
+  ctx.relayPortSource = relayPick.source;
   ctx.relay = new m.RelayServer({
-    port: 24420,
+    port: relayPort,
     apiKey: relayApiKey,
     dashboard: {
       projectRoot: process.cwd(),
@@ -38171,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 {
@@ -38237,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: existsSync41, readFileSync: readFileSync40 } = require("fs");
-    const { join: join48 } = require("path");
-    const instructionsPath = join48(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
-    const baseInstructions = existsSync41(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;
@@ -38298,8 +38576,13 @@ async function doBoot() {
     if (!mainKey) {
       mainProvider = "none";
       config2.main_agent.provider = "none";
-      process.stderr.write(`[gossipcat] \u274C No API keys available \u2014 orchestrator LLM disabled, features degrade to profile-based
+      if (env.host === "claude-code") {
+        process.stderr.write(`[gossipcat] \u2705 Native Claude Code orchestration enabled (no API LLM needed \u2014 host classifies via natural language)
+`);
+      } else {
+        process.stderr.write(`[gossipcat] \u274C No API keys available \u2014 orchestrator LLM disabled, features degrade to profile-based
 `);
+      }
     }
   }
   ctx.mainProvider = mainProvider;
@@ -38572,7 +38855,7 @@ ctx.getModules = getModules;
 var server = new import_mcp.McpServer(
   {
     name: "gossipcat",
-    version: "0.1.0"
+    version: getGossipcatVersion()
   },
   {
     instructions: "gossipcat \u2014 multi-agent orchestration. ALWAYS call gossip_status() first when starting work in this project. The gossip_status response loads the orchestrator role, dispatch rules, consensus workflow, native agent relay rule, sandbox enforcement, and other operating rules from .gossip/rules.md. These rules are not in this instruction text \u2014 they live in the gossip_status output to keep the instruction surface small and to allow per-project customization."
@@ -38796,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_path51.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();
@@ -38821,16 +39107,16 @@ server.tool(
     } catch {
     }
     try {
-      const { readFileSync: readFileSync40, readdirSync: readdirSync13, statSync: statSync9 } = await import("fs");
-      const reportsDir = (0, import_path51.join)(process.cwd(), ".gossip", "consensus-reports");
-      const perfPath = (0, import_path51.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_path51.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 });
@@ -38840,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 {
@@ -38972,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(
@@ -39079,8 +39431,8 @@ server.tool(
       }
       return { content: [{ type: "text", text: results.join("\n") }] };
     }
-    const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync41 } = 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" },
@@ -39094,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 {
       }
@@ -39127,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,
@@ -39147,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 || existsSync41(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;
@@ -39162,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");
         }
       }
     }
@@ -39178,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}):`);
@@ -39890,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();
@@ -39948,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));
@@ -39991,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: existsSync41, 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 (existsSync41(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") {
@@ -40017,7 +40463,7 @@ ${preview}` }]
             }
           }
         }
-        writeFileSync17(filePath, sk.content);
+        writeFileSync18(filePath, sk.content);
         tracker.recordResolution(name);
         results.push(`Created .gossip/skills/${name}.md`);
       }
@@ -40061,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);
@@ -40164,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");
@@ -40533,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." }
@@ -40685,14 +41175,8 @@ ${match.url}` }] };
       }
       return { content: [{ type: "text", text: `Dedup check failed (${err.message ?? "unknown error"}). Not filing to avoid duplicates. Run \`gh auth status\` and retry.` }] };
     }
-    let version2 = "unknown";
-    try {
-      const { readFileSync: readFileSync40 } = await import("fs");
-      const { join: join48 } = await import("path");
-      const pkgRaw = readFileSync40(join48(process.cwd(), "package.json"), "utf-8");
-      version2 = JSON.parse(pkgRaw).version ?? "unknown";
-    } catch {
-    }
+    const { getGossipcatVersion: getGossipcatVersion2 } = await Promise.resolve().then(() => (init_version(), version_exports));
+    const version2 = getGossipcatVersion2();
     let gitHead = "unknown";
     try {
       const result = await execFile4("git", ["rev-parse", "--short", "HEAD"]);
@@ -40750,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;
@@ -40774,10 +41260,10 @@ function startHttpMcpTransport() {
     }
     let body;
     if (req.method === "POST") {
-      const raw = await new Promise((resolve17, reject) => {
+      const raw = await new Promise((resolve18, reject) => {
         const chunks = [];
         req.on("data", (c) => chunks.push(c));
-        req.on("end", () => resolve17(Buffer.concat(chunks).toString("utf-8")));
+        req.on("end", () => resolve18(Buffer.concat(chunks).toString("utf-8")));
         req.on("error", reject);
       });
       try {
@@ -40845,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) => {