gossipcat 0.1.0 → 0.1.2

package/dist-mcp/mcp-server.js

@@ -69,6 +69,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 +148,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 +168,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 +176,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 +190,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 +3118,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 +3151,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 +3177,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 +3188,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 +3227,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 +3672,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 +3683,7 @@ ${context}` : ""}
           this.pendingToolCalls.set(requestId, {
             resolve: (r) => {
               clearTimeout(timer);
-              resolve17(r);
+              resolve18(r);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -3708,12 +3748,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 +3778,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 +3823,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 +3835,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 +3852,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 +3865,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 +3889,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 +4094,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 +4118,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 +4137,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 +4158,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 +8383,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 +8425,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 +8439,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 +8495,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 +8560,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 +8601,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 +8643,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 +8837,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 +8846,7 @@ ${truncateAtLine(fullDiff, 3e3)}`;
           this.pendingReviews.set(requestId, {
             resolve: (r) => {
               clearTimeout(timer);
-              resolve17(r);
+              resolve18(r);
             },
             reject: (e) => {
               clearTimeout(timer);
@@ -8832,7 +8872,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 +8880,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 +8900,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],
@@ -9247,16 +9287,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 +9311,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 +9515,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 +9547,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 +9561,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 +9587,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 +9642,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 +9653,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 +9677,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 +9719,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 +9727,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 +9761,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 +9778,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 +9824,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 +9842,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 +9865,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 +9874,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 +9924,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 +9965,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 +9988,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 +10100,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 +10153,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 +10182,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 +10193,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 +10211,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 +10236,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 +10258,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 +10269,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 +10283,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 +10303,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 +10489,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 +10519,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 +10542,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 +10566,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 +10581,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 +10595,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 +10622,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 +10639,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 +10661,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 +10677,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 +10687,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 +10772,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 +10855,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 +10873,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 +10887,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 +10932,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 +10941,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 +10971,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 +10999,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 +11013,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 +11042,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 +11053,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 +11083,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 +11099,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 +11112,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 +11127,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 +11151,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 +11167,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 +11213,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 +11229,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 +11304,12 @@ 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");
     CIRCUIT_BREAKER_THRESHOLD = 3;
     NEGATIVE_SIGNALS = /* @__PURE__ */ new Set(["hallucination_caught", "disagreement", "unique_unconfirmed"]);
     SIGNAL_EXPIRY_DAYS = 30;
@@ -11290,13 +11338,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) {
@@ -11372,9 +11420,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 +11455,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);
@@ -11675,11 +11723,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 +11766,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 +11780,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 +11855,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 +11890,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 +11933,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 +12761,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 +12773,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 +12782,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 +12792,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 +12802,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 +12828,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 +12839,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 +13333,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 +13410,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 +13441,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 +13652,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 +13671,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 +13723,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 +13746,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 +13768,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 +13863,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 +13935,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 +13947,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 +14007,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 +14031,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 +14958,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 +15370,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 +15489,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 +15549,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 {
         }
@@ -15541,7 +15589,7 @@ 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 });
+          mkdirSync21((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 +15627,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 +15648,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 +15703,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 +15767,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 +15844,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 +15882,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 +15901,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 +15930,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 +15943,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 +15997,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 +16048,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 +16065,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 +16088,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 +16149,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 +16184,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 +16200,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,7 +16424,7 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync41, readFileSync: readFileSync40 } = await import("fs");
+        const { existsSync: existsSync43, readFileSync: readFileSync40 } = await import("fs");
         const { join: join48 } = await import("path");
         for (const config2 of this.registry.getAll()) {
           if (config2.native) continue;
@@ -16366,7 +16435,7 @@ message: Your question?
           }
           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 instructions = existsSync43(instructionsPath) ? readFileSync40(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,7 +16617,7 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync41, readFileSync: readFileSync40 } = await import("fs");
+        const { existsSync: existsSync43, readFileSync: readFileSync40 } = await import("fs");
         const { join: join48 } = await import("path");
         let added = 0;
         for (const ac of this.registry.getAll()) {
@@ -16557,7 +16626,7 @@ message: Your question?
           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 instructions = existsSync43(instructionsPath) ? readFileSync40(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 +17147,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 +17161,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 +17353,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 +17375,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 +17392,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 +17407,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 +17530,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 +17679,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 +17756,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 +17793,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 +17809,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 +18044,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 +18075,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 +18095,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 +18312,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}$/;
@@ -18350,9 +18419,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();
@@ -18434,10 +18503,10 @@ Requirements:
         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);
+        const skillDir = (0, import_path31.join)(this.projectRoot, ".gossip", "agents", agentId, "skills");
+        (0, import_fs29.mkdirSync)(skillDir, { recursive: true });
+        const skillPath = (0, import_path31.join)(skillDir, `${skillName}.md`);
+        (0, import_fs29.writeFileSync)(skillPath, cleaned);
         return { path: skillPath, content: cleaned };
       }
       /**
@@ -18481,24 +18550,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 +18583,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 +18605,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 +18632,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 +18665,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 +18746,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 +18834,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 +18849,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 +18869,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 +18898,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 +19189,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 +19201,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 +19243,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 +19319,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 +19331,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 = [
@@ -19405,6 +19474,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 +19487,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 +19540,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}`
       }]
     };
   }
@@ -19545,10 +19655,10 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync41, readFileSync: readFileSync40, unlinkSync: unlinkSync4 } = require("fs");
+    const { existsSync: existsSync43, readFileSync: readFileSync40, unlinkSync: unlinkSync4 } = require("fs");
     const { join: join48 } = require("path");
     const filePath = join48(projectRoot, ".gossip", CONSENSUS_FILE);
-    if (!existsSync41(filePath)) return;
+    if (!existsSync43(filePath)) return;
     const raw = JSON.parse(readFileSync40(filePath, "utf-8"));
     const now = Date.now();
     for (const [id, data] of Object.entries(raw)) {
@@ -19592,15 +19702,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 +19731,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 +20419,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_path36.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if ((0, import_fs34.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_fs34.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const ev = JSON.parse(line);
@@ -20365,10 +20475,10 @@ async function overviewHandler(projectRoot, ctx2) {
   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 perfPath = (0, import_path36.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if ((0, import_fs34.existsSync)(perfPath)) {
     try {
-      const lines = (0, import_fs33.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
+      const lines = (0, import_fs34.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const entry = JSON.parse(line);
@@ -20401,23 +20511,23 @@ async function overviewHandler(projectRoot, ctx2) {
   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_fs34, import_path36;
 var init_api_overview = __esm({
   "packages/relay/src/dashboard/api-overview.ts"() {
     "use strict";
-    import_fs33 = require("fs");
-    import_path35 = require("path");
+    import_fs34 = require("fs");
+    import_path36 = 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_path37.join)(projectRoot, ".gossip", "task-graph.jsonl");
   const result = /* @__PURE__ */ new Map();
-  if (!(0, import_fs34.existsSync)(taskGraphPath)) return result;
+  if (!(0, import_fs35.existsSync)(taskGraphPath)) return result;
   let lines;
   try {
-    lines = (0, import_fs34.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
+    lines = (0, import_fs35.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
   } catch {
     return result;
   }
@@ -20514,14 +20624,14 @@ async function agentsHandler(projectRoot, configs, onlineAgents = []) {
     };
   });
 }
-var import_fs34, import_path36, DEFAULT_SCORE;
+var import_fs35, import_path37, 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_fs35 = require("fs");
+    import_path37 = require("path");
     DEFAULT_SCORE = {
       agentId: "",
       accuracy: 0.5,
@@ -20545,7 +20655,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_fs36.existsSync)((0, import_path38.join)(projectRoot, ".gossip", "skill-index.json")) && !index.exists();
 }
 async function skillsGetHandler(projectRoot) {
   try {
@@ -20574,13 +20684,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_fs36, import_path38, 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_fs36 = require("fs");
+    import_path38 = require("path");
     AGENT_ID_RE2 = /^[a-zA-Z0-9_-]{1,64}$/;
   }
 });
@@ -20588,25 +20698,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_path39.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_path39.join)(memDir, "MEMORY.md");
+  if ((0, import_fs37.existsSync)(indexPath)) {
     try {
-      index = (0, import_fs36.readFileSync)(indexPath, "utf-8");
+      index = (0, import_fs37.readFileSync)(indexPath, "utf-8");
     } catch {
     }
   }
   const knowledge = [];
-  const knowledgeDir = (0, import_path38.join)(memDir, "knowledge");
+  const knowledgeDir = (0, import_path39.join)(memDir, "knowledge");
   const knowledgeDirs = [knowledgeDir, memDir];
   for (const dir of knowledgeDirs) {
-    if (!(0, import_fs36.existsSync)(dir)) continue;
+    if (!(0, import_fs37.existsSync)(dir)) continue;
     try {
-      const files = (0, import_fs36.readdirSync)(dir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md");
+      const files = (0, import_fs37.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_fs37.readFileSync)((0, import_path39.join)(dir, filename), "utf-8");
           const { frontmatter, content } = parseFrontmatter(raw);
           knowledge.push({ filename, frontmatter, content });
         } catch {
@@ -20616,10 +20726,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_path39.join)(memDir, "tasks.jsonl");
+  if ((0, import_fs37.existsSync)(tasksPath)) {
     try {
-      const lines = (0, import_fs36.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
+      const lines = (0, import_fs37.readFileSync)(tasksPath, "utf-8").trim().split("\n").filter(Boolean).slice(-200);
       for (const line of lines) {
         try {
           tasks.push(JSON.parse(line));
@@ -20647,12 +20757,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_fs37, import_path39, 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_fs37 = require("fs");
+    import_path39 = require("path");
     AGENT_ID_RE3 = /^[a-zA-Z0-9_-]{1,64}$/;
     DANGEROUS_IDS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
   }
@@ -20664,11 +20774,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_path40.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs38.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_fs38.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const parsed = JSON.parse(line);
@@ -20739,12 +20849,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_fs38, import_path40, 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_fs38 = require("fs");
+    import_path40 = require("path");
     RESOLUTION_SIGNALS = /* @__PURE__ */ new Set(["agreement", "unique_confirmed", "consensus_verified"]);
     DEFAULT_PAGE_SIZE = 10;
     MAX_PAGE_SIZE = 50;
@@ -20756,11 +20866,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_path41.join)(projectRoot, ".gossip", "agent-performance.jsonl");
+  if (!(0, import_fs39.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_fs39.readFileSync)(perfPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -20776,12 +20886,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_fs39, import_path41, 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_fs39 = require("fs");
+    import_path41 = require("path");
     MAX_LIMIT = 200;
     DEFAULT_LIMIT = 50;
   }
@@ -20789,29 +20899,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_path42.join)(projectRoot, ".gossip", "agents");
+  if (!(0, import_fs40.existsSync)(agentsDir)) return { learnings: [] };
   const all = [];
   let agentIds;
   try {
-    agentIds = (0, import_fs39.readdirSync)(agentsDir).filter((f) => !f.startsWith("."));
+    agentIds = (0, import_fs40.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_path42.join)(agentsDir, agentId, "memory", "knowledge");
+    if (!(0, import_fs40.existsSync)(knowledgeDir)) continue;
     let files;
     try {
-      files = (0, import_fs39.readdirSync)(knowledgeDir).filter((f) => f.endsWith(".md"));
+      files = (0, import_fs40.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_path42.join)(knowledgeDir, filename);
       try {
-        const stat3 = (0, import_fs39.statSync)(filepath);
-        const raw = (0, import_fs39.readFileSync)(filepath, "utf-8");
+        const stat3 = (0, import_fs40.statSync)(filepath);
+        const raw = (0, import_fs40.readFileSync)(filepath, "utf-8");
         const fm = parseFrontmatter2(raw);
         all.push({
           agentId,
@@ -20838,12 +20948,12 @@ function parseFrontmatter2(raw) {
   }
   return fm;
 }
-var import_fs39, import_path41, MAX_LEARNINGS;
+var import_fs40, import_path42, 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_fs40 = require("fs");
+    import_path42 = require("path");
     MAX_LEARNINGS = 10;
   }
 });
@@ -20854,12 +20964,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_path43.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs41.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_fs41.readFileSync)(graphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const entry = JSON.parse(line);
@@ -20914,23 +21024,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_fs41, import_path43;
 var init_api_tasks = __esm({
   "packages/relay/src/dashboard/api-tasks.ts"() {
     "use strict";
-    import_fs40 = require("fs");
-    import_path42 = require("path");
+    import_fs41 = require("fs");
+    import_path43 = 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_path44.join)(projectRoot, ".gossip", "task-graph.jsonl");
+  if (!(0, import_fs42.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_fs42.readFileSync)(taskGraphPath, "utf-8").trim().split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const ev = JSON.parse(line);
@@ -20957,12 +21067,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_fs42, import_path44;
 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_fs42 = require("fs");
+    import_path44 = require("path");
   }
 });
 
@@ -20975,25 +21085,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_path45.join)(projectRoot, ".gossip", "mcp.log");
+  if (!(0, import_fs43.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_fs43.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_fs43.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_fs43.readSync)(fd, buf, 0, readLen, readFrom);
     buf = buf.subarray(0, bytesRead);
   } finally {
-    (0, import_fs42.closeSync)(fd);
+    (0, import_fs43.closeSync)(fd);
   }
   let raw = buf.toString("utf-8");
   let lineOffset = 0;
@@ -21001,13 +21111,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_fs43.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_fs43.readSync)(scanFd, chunk, 0, len, pos);
         if (n === 0) break;
         for (let j = 0; j < n; j++) {
           if (chunk[j] === 10) lineOffset++;
@@ -21015,7 +21125,7 @@ function logsHandler(projectRoot, query) {
         pos += n;
       }
     } finally {
-      (0, import_fs42.closeSync)(scanFd);
+      (0, import_fs43.closeSync)(scanFd);
     }
   }
   const allLines = raw.split("\n").filter(Boolean);
@@ -21033,12 +21143,12 @@ function logsHandler(projectRoot, query) {
   entries = entries.slice(-clampedTail);
   return { entries, totalLines, fileSize, filter };
 }
-var import_fs42, import_path44, CATEGORY_PATTERNS2;
+var import_fs43, import_path45, 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_fs43 = require("fs");
+    import_path45 = require("path");
     CATEGORY_PATTERNS2 = [
       [/^\[worker:/, "worker"],
       [/^\[Gemini\]/, "gemini"],
@@ -21066,8 +21176,22 @@ var init_api_logs = __esm({
 });
 
 // packages/relay/src/dashboard/routes.ts
+function resolveDashboardRoot(projectRoot) {
+  const candidates = [
+    (0, import_path46.resolve)(__dirname, "..", "dist-dashboard"),
+    // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
+    (0, import_path46.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    // tsc dev: packages/relay/dist/dashboard → repo-root
+    (0, import_path46.join)(projectRoot, "dist-dashboard")
+    // legacy dev fallback (git-clone running from repo root)
+  ];
+  for (const p of candidates) {
+    if ((0, import_fs44.existsSync)(p)) return p;
+  }
+  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 +21206,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_fs44, import_path46, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, DashboardRouter, MAX_BODY_SIZE;
 var init_routes = __esm({
   "packages/relay/src/dashboard/routes.ts"() {
     "use strict";
@@ -21103,8 +21227,8 @@ var init_routes = __esm({
     init_api_tasks();
     init_api_active_tasks();
     init_api_logs();
-    import_fs43 = require("fs");
-    import_path45 = require("path");
+    import_fs44 = require("fs");
+    import_path46 = require("path");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
     DashboardRouter = class {
@@ -21112,8 +21236,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 +21405,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 assets not found. Reinstall gossipcat or rebuild from source.");
+          return true;
+        }
+        const htmlPath = (0, import_path46.join)(this.dashboardRoot, "index.html");
+        if (!(0, import_fs44.existsSync)(htmlPath)) {
           res.writeHead(503, { "Content-Type": "text/plain" });
-          res.end("Dashboard not built. Run: npm run build:dashboard");
+          res.end(`Dashboard index.html missing at ${this.dashboardRoot}. Reinstall gossipcat.`);
           return true;
         }
-        const html = (0, import_fs43.readFileSync)(htmlPath, "utf-8");
+        const html = (0, import_fs44.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 +21442,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_path46.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_fs44.realpathSync)(filePath);
+          const realBase = (0, import_fs44.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_fs44.readFileSync)(realFile);
           res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=86400" });
           res.end(data);
           return true;
@@ -21334,15 +21466,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: readFileSync40, existsSync: existsSync43 } = require("fs");
+        const reportsDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports");
+        if (!existsSync43(reportsDir)) return { reports: [], totalReports: 0, page, pageSize };
         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_path46.join)(reportsDir, a)).mtimeMs;
+              const bTime = statSync9((0, import_path46.join)(reportsDir, b)).mtimeMs;
               return bTime - aTime;
             } catch {
               return 0;
@@ -21353,11 +21485,11 @@ 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_fs44.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_path46.join)(reportsDir, f);
+              const realFile = (0, import_fs44.realpathSync)(filePath);
               if (!realFile.startsWith(realReportsDir + "/")) return null;
               return JSON.parse(readFileSync40(realFile, "utf-8"));
             } catch {
@@ -21370,27 +21502,27 @@ 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: readFileSync40, renameSync: renameSync2, writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43 } = require("fs");
+        const reportsDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const archiveDir = (0, import_path46.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
         let archived = 0;
-        if (existsSync41(reportsDir)) {
+        if (existsSync43(reportsDir)) {
           const files = readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).sort().reverse();
           if (files.length > 5) {
             mkdirSync21(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_path46.join)(reportsDir, f), (0, import_path46.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path45.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path46.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
-        if (existsSync41(findingsPath)) {
+        if (existsSync43(findingsPath)) {
           try {
             const lines = readFileSync40(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
             const kept = lines.filter((line) => {
@@ -21409,7 +21541,7 @@ var init_routes = __esm({
           } catch {
           }
         }
-        const remaining = existsSync41(reportsDir) ? readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
+        const remaining = existsSync43(reportsDir) ? readdirSync13(reportsDir).filter((f) => f.endsWith(".json")).length : 0;
         return { archived, remaining, findingsCleared };
       }
       json(res, status, data) {
@@ -21422,14 +21554,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_fs45, import_fs46, import_path47, 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_path47 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -21454,15 +21586,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_path47.join)(projectRoot, ".gossip", "mcp.log");
+        if (!(0, import_fs45.existsSync)(this.logPath)) return;
         try {
-          this.logOffset = (0, import_fs44.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs45.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs45.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs46.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -21479,7 +21611,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_fs45.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -21492,7 +21624,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_fs45.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
           } catch {
             this.logReading = false;
             return;
@@ -21586,7 +21718,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 +21763,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 +21782,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 +21980,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_path48.resolve)(root, ".gossip", "config.json"),
+    (0, import_path48.resolve)(root, "gossip.agents.json"),
+    (0, import_path48.resolve)(root, "gossip.agents.yaml"),
+    (0, import_path48.resolve)(root, "gossip.agents.yml")
   ];
   for (const p of candidates) {
-    if ((0, import_fs46.existsSync)(p)) return p;
+    if ((0, import_fs47.existsSync)(p)) return p;
   }
   return null;
 }
 function loadConfig(configPath) {
-  const raw = (0, import_fs46.readFileSync)(configPath, "utf-8");
+  const raw = (0, import_fs47.readFileSync)(configPath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -21938,19 +22070,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_path48.join)(root, ".claude", "agents");
+  if (!(0, import_fs47.existsSync)(agentsDir)) return [];
   let files;
   try {
-    files = (0, import_fs46.readdirSync)(agentsDir).filter((f) => f.endsWith(".md"));
+    files = (0, import_fs47.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_path48.join)(agentsDir, file2);
     try {
-      const content = (0, import_fs46.readFileSync)(filePath, "utf-8");
+      const content = (0, import_fs47.readFileSync)(filePath, "utf-8");
       const frontmatter = content.match(/^---\n([\s\S]*?)\n---/);
       if (!frontmatter) continue;
       const fm = frontmatter[1];
@@ -22005,12 +22137,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_fs47, import_path48, 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_fs47 = require("fs");
+    import_path48 = require("path");
     VALID_PROVIDERS = ["anthropic", "openai", "openclaw", "google", "local", "native"];
     CLAUDE_MODEL_MAP = {
       opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -22025,14 +22157,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_fs48, import_path49, 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_fs48 = require("fs");
+    import_path49 = require("path");
     import_crypto15 = require("crypto");
     SERVICE_NAME = "gossip-mesh";
     VALID_PROVIDERS2 = /^[a-zA-Z0-9_-]{1,32}$/;
@@ -22074,10 +22206,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_path49.join)(process.cwd(), ENCRYPTED_FILE);
+        if (!(0, import_fs48.existsSync)(filePath)) return;
         try {
-          const raw = (0, import_fs47.readFileSync)(filePath);
+          const raw = (0, import_fs48.readFileSync)(filePath);
           if (raw.length < 61) return;
           const salt = raw.subarray(0, 32);
           const iv = raw.subarray(32, 44);
@@ -22095,9 +22227,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_path49.join)(process.cwd(), ENCRYPTED_FILE);
+        const dir = (0, import_path49.join)(process.cwd(), ".gossip");
+        if (!(0, import_fs48.existsSync)(dir)) (0, import_fs48.mkdirSync)(dir, { recursive: true });
         const data = JSON.stringify(Object.fromEntries(this.inMemoryStore));
         const salt = (0, import_crypto15.randomBytes)(32);
         const iv = (0, import_crypto15.randomBytes)(12);
@@ -22105,7 +22237,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_fs48.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
       }
       isKeychainAvailable() {
         if ((0, import_os2.platform)() === "darwin") {
@@ -22205,17 +22337,17 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path49.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path50.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs48.readFileSync)(saltPath, "utf-8").trim();
+    return (0, import_fs49.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_fs49.mkdirSync)((0, import_path50.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs48.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs49.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs48.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs49.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
@@ -22265,12 +22397,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_fs49, import_path50, 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_fs49 = require("fs");
+    import_path50 = require("path");
     import_crypto16 = require("crypto");
     import_child_process6 = require("child_process");
   }
@@ -22282,14 +22414,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 +22424,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path50.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path51.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_fs50.existsSync)((0, import_path51.join)(packageRoot, ".git"))) return "git-clone";
   return "local";
 }
 function updateCommand(method, version2) {
@@ -22351,7 +22477,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_path51.resolve)(__dirname, "..", "..", "..", "..") : process.cwd()
     });
   } catch (err) {
     return {
@@ -22373,13 +22499,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_fs50, import_path51;
 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_fs50 = require("fs");
+    import_path51 = require("path");
+    init_version();
   }
 });
 
@@ -22542,8 +22669,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_fs51 = require("fs");
+var import_path52 = 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 +36447,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 +36852,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 +36970,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 +37316,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 +37533,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 +38030,12 @@ ${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");
+var gossipDir = (0, import_path52.join)(process.cwd(), ".gossip");
 try {
-  (0, import_fs50.mkdirSync)(gossipDir, { recursive: true });
+  (0, import_fs51.mkdirSync)(gossipDir, { recursive: true });
 } catch {
 }
-var logStream = (0, import_fs50.createWriteStream)((0, import_path51.join)(gossipDir, "mcp.log"), { flags: "a" });
+var logStream = (0, import_fs51.createWriteStream)((0, import_path52.join)(gossipDir, "mcp.log"), { flags: "a" });
 process.stderr.write = ((chunk, ...args) => {
   return logStream.write(chunk, ...args);
 });
@@ -38074,10 +38202,10 @@ var _pendingSessionData = /* @__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 { existsSync: existsSync43, readdirSync: readdirSync13, readFileSync: readFileSync40 } = require("fs");
   const { join: join48 } = require("path");
   const reportsDir = join48(projectRoot, ".gossip", "consensus-reports");
-  if (!existsSync41(reportsDir)) return null;
+  if (!existsSync43(reportsDir)) return null;
   try {
     const files = readdirSync13(reportsDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
@@ -38144,12 +38272,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_path52.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 +38299,10 @@ async function doBoot() {
     }
   }
   const relayApiKey = (0, import_crypto17.randomBytes)(32).toString("hex");
+  const envPort = process.env.GOSSIPCAT_PORT ? parseInt(process.env.GOSSIPCAT_PORT, 10) : NaN;
+  const relayPort = Number.isFinite(envPort) && envPort >= 0 && envPort <= 65535 ? envPort : 0;
   ctx.relay = new m.RelayServer({
-    port: 24420,
+    port: relayPort,
     apiKey: relayApiKey,
     dashboard: {
       projectRoot: process.cwd(),
@@ -38237,10 +38376,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 { existsSync: existsSync43, 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 baseInstructions = existsSync43(instructionsPath) ? readFileSync40(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 +38437,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 +38716,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."
@@ -38806,7 +38950,7 @@ server.tool(
     }
     try {
       const { readFileSync: readFileSync40 } = await import("fs");
-      const quotaPath = (0, import_path51.join)(process.cwd(), ".gossip", "quota-state.json");
+      const quotaPath = (0, import_path52.join)(process.cwd(), ".gossip", "quota-state.json");
       const quotaRaw = readFileSync40(quotaPath, "utf8");
       const quotaState = JSON.parse(quotaRaw);
       for (const [provider, state] of Object.entries(quotaState)) {
@@ -38822,15 +38966,15 @@ server.tool(
     }
     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 reportsDir = (0, import_path52.join)(process.cwd(), ".gossip", "consensus-reports");
+      const perfPath = (0, import_path52.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_path52.join)(reportsDir, fname);
           const st = statSync9(fpath);
           if (now - st.mtimeMs > WINDOW_MS) continue;
           recentReports.push({ id: fname.replace(/\.json$/, ""), mtimeMs: st.mtimeMs });
@@ -39079,7 +39223,7 @@ server.tool(
       }
       return { content: [{ type: "text", text: results.join("\n") }] };
     }
-    const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync41 } = require("fs");
+    const { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43 } = require("fs");
     const { join: join48 } = require("path");
     const root = process.cwd();
     const CLAUDE_MODEL_MAP2 = {
@@ -39148,7 +39292,7 @@ server.tool(
           continue;
         }
         const nativeFile = join48(root, ".claude", "agents", `${agent.id}.md`);
-        const wasNative = existingAgents[agent.id]?.native || existsSync41(nativeFile);
+        const wasNative = existingAgents[agent.id]?.native || existsSync43(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;
@@ -39991,7 +40135,7 @@ ${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 { writeFileSync: writeFileSync17, mkdirSync: mkdirSync21, existsSync: existsSync43, readFileSync: readFileSync40 } = require("fs");
       const { join: join48 } = require("path");
       const dir = join48(process.cwd(), ".gossip", "skills");
       mkdirSync21(dir, { recursive: true });
@@ -39999,7 +40143,7 @@ ${preview}` }]
       for (const sk of skills) {
         const name = normalizeSkillName2(sk.name);
         const filePath = join48(dir, `${name}.md`);
-        if (existsSync41(filePath)) {
+        if (existsSync43(filePath)) {
           const existing = readFileSync40(filePath, "utf-8");
           const fm = parseSkillFrontmatter2(existing);
           if (fm) {
@@ -40685,14 +40829,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"]);
@@ -40774,10 +40912,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 {