gossipcat 0.4.0 → 0.4.1

package/dist-mcp/mcp-server.js

@@ -52,9 +52,13 @@ var init_mcp_context = __esm({
       nativeTaskMap: /* @__PURE__ */ new Map(),
       nativeResultMap: /* @__PURE__ */ new Map(),
       nativeAgentConfigs: /* @__PURE__ */ new Map(),
+      identityRegistry: /* @__PURE__ */ new Map(),
       pendingConsensusRounds: /* @__PURE__ */ new Map(),
       nativeUtilityConfig: null,
       mainProvider: "google",
+      mainModel: "gemini-2.5-pro",
+      mainProviderConfig: "google",
+      mainModelConfig: "gemini-2.5-pro",
       httpMcpPort: null,
       relayPortSource: null,
       httpMcpPortSource: null,
@@ -795,10 +799,15 @@ var init_task_dispatcher = __esm({
        * Decompose a task into a DispatchPlan using the LLM.
        * On parse failure, falls back to a single sub-task.
        */
-      async decompose(task) {
+      /**
+       * Build the LLM messages used by decompose(). Exposed so native-utility
+       * orchestrators (Claude Code) can dispatch the decomposition as an Agent()
+       * call and feed the raw result back through decomposeFromRaw().
+       */
+      buildDecomposeMessages(task) {
         const availableSkills = this.getAvailableSkills();
         const skillList = availableSkills.length > 0 ? availableSkills.join(", ") : "general";
-        const messages = [
+        return [
           {
             role: "system",
             content: `You are a task decomposition engine. Break work into tasks that use the FULL team.
@@ -834,36 +843,55 @@ Use "sequential" ONLY when a later task genuinely needs output from an earlier o
           },
           { role: "user", content: task }
         ];
-        const response = await this.llm.generate(messages, { temperature: 0 });
+      }
+      /**
+       * Parse a raw LLM response into a DispatchPlan. Used by both the in-process
+       * decompose() path and the native-utility re-entry path — same fallback
+       * logic, one place to keep it honest.
+       *
+       * Strategy/subtask shape validation was previously implicit (trusted-LLM
+       * output). The native-utility path feeds raw subagent output through here
+       * untrusted, so we validate explicitly: unknown strategies fall back to
+       * 'single', non-string descriptions or missing description fields skip the
+       * subtask, and if nothing survives we fall through to the single-task
+       * default. This is F17 hardening from consensus 0a7c34cb-91624bd4.
+       */
+      decomposeFromRaw(task, rawText) {
+        const VALID_STRATEGIES = /* @__PURE__ */ new Set(["single", "parallel", "sequential"]);
+        const singleTaskFallback = () => ({
+          originalTask: task,
+          strategy: "single",
+          subTasks: [{
+            id: (0, import_crypto2.randomUUID)(),
+            description: task,
+            requiredSkills: [],
+            status: "pending"
+          }],
+          warnings: []
+        });
         try {
-          const jsonMatch = response.text.match(/\{[\s\S]*\}/);
+          const jsonMatch = rawText.match(/\{[\s\S]*\}/);
           if (!jsonMatch) throw new Error("No JSON in response");
           const plan = JSON.parse(jsonMatch[0]);
-          return {
-            originalTask: task,
-            strategy: plan.strategy || "single",
-            subTasks: (plan.subTasks || []).map((st) => ({
-              id: (0, import_crypto2.randomUUID)(),
-              description: st.description,
-              requiredSkills: st.requiredSkills || [],
-              status: "pending"
-            })),
-            warnings: []
-          };
+          const strategy = VALID_STRATEGIES.has(plan.strategy) ? plan.strategy : "single";
+          const rawSubTasks = Array.isArray(plan.subTasks) ? plan.subTasks : [];
+          const subTasks = rawSubTasks.filter((st) => st && typeof st.description === "string" && st.description.trim().length > 0).map((st) => ({
+            id: (0, import_crypto2.randomUUID)(),
+            description: st.description,
+            requiredSkills: Array.isArray(st.requiredSkills) ? st.requiredSkills.filter((s) => typeof s === "string") : [],
+            status: "pending"
+          }));
+          if (subTasks.length === 0) return singleTaskFallback();
+          return { originalTask: task, strategy, subTasks, warnings: [] };
         } catch {
-          return {
-            originalTask: task,
-            strategy: "single",
-            subTasks: [{
-              id: (0, import_crypto2.randomUUID)(),
-              description: task,
-              requiredSkills: [],
-              status: "pending"
-            }],
-            warnings: []
-          };
+          return singleTaskFallback();
         }
       }
+      async decompose(task) {
+        const messages = this.buildDecomposeMessages(task);
+        const response = await this.llm.generate(messages, { temperature: 0 });
+        return this.decomposeFromRaw(task, response.text);
+      }
       /**
        * Assign agents to each sub-task by skill match.
        * Modifies the plan in-place and returns it.
@@ -935,13 +963,22 @@ ${subTaskList}` }
             };
           });
         } catch {
-          return plan.subTasks.map((st) => ({
-            agentId: st.assignedAgent || "",
-            task: st.description,
-            access: "read"
-          }));
+          return this.classifyWriteModesFallback(plan);
         }
       }
+      /**
+       * All-read fallback mapping used when no LLM is available (e.g. pure-native
+       * teams using the native-utility path for decomposition but lacking a
+       * second round-trip budget for classification). Also used internally by
+       * classifyWriteModes() on LLM failure.
+       */
+      classifyWriteModesFallback(plan) {
+        return plan.subTasks.map((st) => ({
+          agentId: st.assignedAgent || "",
+          task: st.description,
+          access: "read"
+        }));
+      }
       /** Collect all unique skills from registered agents */
       getAvailableSkills() {
         const skills = /* @__PURE__ */ new Set();
@@ -9537,57 +9574,66 @@ Before completing:
 3. Confirm referenced functions/methods exist${fileList}`;
 }
 function assemblePrompt(parts) {
-  const blocks = [];
+  const prefix = [];
+  const suffix = [];
+  if (parts.identity) {
+    prefix.push(parts.identity);
+  }
   if (parts.projectStructure) {
-    blocks.push(`
+    prefix.push(`
 
 --- PROJECT ---
 ${parts.projectStructure}
 --- END PROJECT ---`);
   }
   if (parts.chainContext) {
-    blocks.push(`
+    prefix.push(`
 
 ${parts.chainContext}`);
+  }
+  if (parts.instructions) {
+    prefix.push(`
+
+${parts.instructions}`);
   }
   if (parts.skills) {
-    blocks.push(`
+    prefix.push(`
 
 --- SKILLS ---
 ${parts.skills}
 --- END SKILLS ---`);
   }
   if (parts.consensusSummary) {
-    blocks.push(`
+    suffix.push({ priority: 0, text: `
 
 --- CONSENSUS OUTPUT FORMAT ---
 ${CONSENSUS_OUTPUT_FORMAT}
 
 This section will be used for cross-review with peer agents.
---- END CONSENSUS OUTPUT FORMAT ---`);
+--- END CONSENSUS OUTPUT FORMAT ---` });
   } else {
-    const hasAnyMeaningfulPart = !!(parts.memory || parts.memoryDir || parts.lens || parts.skills || parts.context || parts.sessionContext || parts.chainContext || parts.specReviewContext || parts.projectStructure || parts.consensusFindings && parts.consensusFindings.length > 0);
+    const hasAnyMeaningfulPart = !!(parts.identity || parts.instructions || parts.memory || parts.memoryDir || parts.lens || parts.skills || parts.context || parts.sessionContext || parts.chainContext || parts.specReviewContext || parts.projectStructure || parts.task || parts.consensusFindings && parts.consensusFindings.length > 0);
     if (hasAnyMeaningfulPart) {
-      blocks.push(`
+      suffix.push({ priority: 0, text: `
 
 --- FINDING TAG SCHEMA ---
 ${FINDING_TAG_SCHEMA}
---- END FINDING TAG SCHEMA ---`);
+--- END FINDING TAG SCHEMA ---` });
     }
   }
   if (parts.lens) {
-    blocks.push(`
+    suffix.push({ priority: 1, text: `
 
 --- LENS ---
 ${parts.lens}
---- END LENS ---`);
+--- END LENS ---` });
   }
   if (parts.specReviewContext) {
-    blocks.push(`
+    suffix.push({ priority: 2, text: `
 
 --- SPEC REVIEW ---
 ${parts.specReviewContext}
---- END SPEC REVIEW ---`);
+--- END SPEC REVIEW ---` });
   }
   if (parts.memory || parts.consensusFindings && parts.consensusFindings.length > 0) {
     const memParts = [];
@@ -9596,14 +9642,14 @@ ${parts.specReviewContext}
       const findingsBlock = "### Recent Consensus Findings\n" + parts.consensusFindings.map((f, i) => `${i + 1}. ${f}`).join("\n");
       memParts.push(findingsBlock);
     }
-    blocks.push(`
+    suffix.push({ priority: 3, text: `
 
 --- MEMORY ---
 ${memParts.join("\n\n")}
---- END MEMORY ---`);
+--- END MEMORY ---` });
   }
   if (parts.memoryDir) {
-    blocks.push(`
+    suffix.push({ priority: 4, text: `
 
 --- AGENT MEMORY ---
 Your persistent memory directory: ${parts.memoryDir}
@@ -9611,27 +9657,69 @@ Save important learnings using file_write to this directory.
 What to save: technology choices, file structure, key patterns, architectural decisions, gotchas.
 Use descriptive filenames like: tech-stack.md, project-structure.md, patterns.md
 Keep entries concise (5-10 lines each). Update existing files rather than creating new ones.
---- END AGENT MEMORY ---`);
+--- END AGENT MEMORY ---` });
   }
   if (parts.sessionContext) {
-    blocks.push(`
+    suffix.push({ priority: 5, text: `
 
-${parts.sessionContext}`);
+${parts.sessionContext}` });
   }
   if (parts.context) {
-    blocks.push(`
+    suffix.push({ priority: 6, text: `
 
 Context:
-${parts.context}`);
+${parts.context}` });
   }
-  let assembled = blocks.join("");
-  const MAX_PROMPT_CHARS = 3e4;
-  if (assembled.length > MAX_PROMPT_CHARS) {
-    assembled = assembled.slice(0, MAX_PROMPT_CHARS) + "\n\n[Context truncated to fit budget]";
-  }
-  return assembled;
+  if (parts.task) {
+    suffix.push({ priority: 0, text: `
+
+---
+
+Task: ${parts.task}` });
+  }
+  const SUFFIX_RESERVE = Math.floor(MAX_ASSEMBLED_PROMPT_CHARS * 0.6);
+  const dropOrderDesc = [...suffix].sort((a, b) => b.priority - a.priority);
+  const dropped = /* @__PURE__ */ new Set();
+  const suffixLen = () => suffix.filter((_, i) => !dropped.has(i)).reduce((acc, seg) => acc + seg.text.length, 0);
+  for (const seg of dropOrderDesc) {
+    if (seg.priority === 0) break;
+    if (suffixLen() <= SUFFIX_RESERVE) break;
+    const idx = suffix.indexOf(seg);
+    if (idx >= 0) dropped.add(idx);
+  }
+  const suffixStr = suffix.filter((_, i) => !dropped.has(i)).map((seg) => seg.text).join("");
+  let prefixStr = prefix.join("");
+  const budget = Math.max(0, MAX_ASSEMBLED_PROMPT_CHARS - suffixStr.length);
+  if (prefixStr.length > budget) {
+    prefixStr = prefixStr.slice(0, budget) + "\n\n[Context truncated to fit budget]";
+  }
+  return prefixStr + suffixStr;
+}
+function assembleUtilityPrompt(args) {
+  const { taskId, modelShort, system, user, intro, reentrantCall, relayToken } = args;
+  const relayArgs = relayToken ? `task_id: "${taskId}", relay_token: "${relayToken}", result: "<full agent output>"` : `task_id: "${taskId}", result: "<full agent output>"`;
+  return [
+    {
+      type: "text",
+      text: `${intro}
+
+\u26A0\uFE0F EXECUTE NOW \u2014 launch this Agent and re-call the tool:
+
+1. Agent(model: "${modelShort}", prompt: <AGENT_PROMPT:${taskId} below>, run_in_background: true) \u2014 pass the AGENT_PROMPT:${taskId} content item verbatim
+2. When agent completes \u2192 gossip_relay(${relayArgs})
+3. Then re-call: ${reentrantCall}
+
+Do ALL steps in order. Do not wait for user input between them.`
+    },
+    { type: "text", text: `AGENT_PROMPT:${taskId} (_utility)
+${system}
+
+---
+
+${user}` }
+  ];
 }
-var path, DOC_EXTENSIONS, SPEC_PATH_PATTERN, FILE_REF_PATTERN;
+var path, DOC_EXTENSIONS, SPEC_PATH_PATTERN, FILE_REF_PATTERN, MAX_ASSEMBLED_PROMPT_CHARS;
 var init_prompt_assembler = __esm({
   "packages/orchestrator/src/prompt-assembler.ts"() {
     "use strict";
@@ -9640,6 +9728,7 @@ var init_prompt_assembler = __esm({
     DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt", ".rst"]);
     SPEC_PATH_PATTERN = /(?:docs\/|specs\/|[\w-]+-(?:design|spec)\.md)/;
     FILE_REF_PATTERN = /(?:`([^`]+\.[a-z]{1,6})`|([a-zA-Z][\w/.@-]+\.[a-z]{1,6})(?::\d+)?)/g;
+    MAX_ASSEMBLED_PROMPT_CHARS = 3e4;
   }
 });
 
@@ -12787,6 +12876,20 @@ Return ONLY a JSON array. Use findingId to reference findings:
 [
   { "action": "agree"|"disagree"|"unverified"|"new", "findingId": "agent:f1", "finding": "brief summary", "evidence": "your reasoning", "confidence": 1-5 }
 ]`;
+        let skillsBlock = "";
+        if (this.config.getAgentSkillsContent) {
+          try {
+            const skills = this.config.getAgentSkillsContent(agent.agentId, agent.task);
+            if (skills && skills.trim().length > 0) {
+              skillsBlock = `
+
+--- SKILLS ---
+${skills}
+--- END SKILLS ---`;
+            }
+          } catch {
+          }
+        }
         const system = `You are a code reviewer performing cross-review. Your job is to verify peer findings against actual code \u2014 catch errors, but also confirm good work.
 
 SOURCE FILES: Always cite original source files, not compiled/bundled build output (dist/, build/, out/). Build artifacts have different line numbers \u2014 citing them causes false verification failures.
@@ -12801,7 +12904,7 @@ VERIFICATION RULES:
 - Do NOT agree with a finding just because it sounds plausible \u2014 verify it
 - Agreeing without verification is WORSE than disagreeing \u2014 a false confirmation poisons the system
 
-Return only valid JSON.`;
+Return only valid JSON.${skillsBlock}`;
         return { system, user };
       }
       /**
@@ -14244,6 +14347,7 @@ var init_consensus_coordinator = __esm({
       registryGet;
       projectRoot;
       keyProvider;
+      getAgentSkillsContent;
       gossipPublisher = null;
       memWriter;
       currentPhase = "idle";
@@ -14253,6 +14357,7 @@ var init_consensus_coordinator = __esm({
         this.registryGet = config2.registryGet;
         this.projectRoot = config2.projectRoot;
         this.keyProvider = config2.keyProvider;
+        this.getAgentSkillsContent = config2.getAgentSkillsContent;
         this.memWriter = new MemoryWriter(config2.projectRoot);
       }
       setGossipPublisher(publisher) {
@@ -14288,7 +14393,13 @@ var init_consensus_coordinator = __esm({
             }
             agentLlm = (agentId) => agentLlmCache.get(agentId) ?? void 0;
           }
-          const engine = new ConsensusEngine({ llm: this.llm, registryGet: this.registryGet, projectRoot: this.projectRoot, agentLlm });
+          const engine = new ConsensusEngine({
+            llm: this.llm,
+            registryGet: this.registryGet,
+            projectRoot: this.projectRoot,
+            agentLlm,
+            getAgentSkillsContent: this.getAgentSkillsContent
+          });
           const consensusReport = await engine.run(results);
           const perfWriter = new PerformanceWriter(this.projectRoot);
           this.currentPhase = "cross_review";
@@ -14587,6 +14698,16 @@ var init_dispatch_pipeline = __esm({
         this.projectStructureCache = parts.length > 0 ? parts.join("\n") : "";
         return this.projectStructureCache || void 0;
       }
+      /**
+       * Invalidate the cached project structure so the next prompt regenerates it.
+       * Call this when the project layout has changed mid-session (e.g. new
+       * top-level packages, agent scaffold, gossip_setup adding agent dirs).
+       * Without this, every prompt sees the boot-time-cached layout and agents
+       * reason against stale structure. Drift audit haiku #8.
+       */
+      invalidateProjectStructureCache() {
+        this.projectStructureCache = null;
+      }
       constructor(config2) {
         this.projectRoot = config2.projectRoot;
         this.workers = config2.workers;
@@ -14607,7 +14728,16 @@ var init_dispatch_pipeline = __esm({
           llm: config2.llm ?? null,
           registryGet: config2.registryGet,
           projectRoot: config2.projectRoot,
-          keyProvider: config2.keyProvider ?? null
+          keyProvider: config2.keyProvider ?? null,
+          getAgentSkillsContent: (agentId, task) => {
+            const agentSkills = this.registryGet(agentId)?.skills || [];
+            try {
+              const res = loadSkills(agentId, agentSkills, this.projectRoot, this.skillIndex ?? void 0, task);
+              return res.content || void 0;
+            } catch {
+              return void 0;
+            }
+          }
         });
         try {
           this.catalog = new SkillCatalog(config2.projectRoot);
@@ -17290,6 +17420,9 @@ message: Your question?
       setSkillIndex(index) {
         this.pipeline.setSkillIndex(index);
       }
+      invalidateProjectStructureCache() {
+        this.pipeline.invalidateProjectStructureCache();
+      }
       setSummaryLlm(llm) {
         this.pipeline.setSummaryLlm(llm);
       }
@@ -20554,6 +20687,7 @@ __export(src_exports3, {
   GeminiProvider: () => GeminiProvider,
   GossipPublisher: () => GossipPublisher,
   LensGenerator: () => LensGenerator,
+  MAX_ASSEMBLED_PROMPT_CHARS: () => MAX_ASSEMBLED_PROMPT_CHARS,
   MIN_AGENTS_FOR_CONSENSUS: () => MIN_AGENTS_FOR_CONSENSUS,
   MIN_EVIDENCE: () => MIN_EVIDENCE,
   MainAgent: () => MainAgent,
@@ -20590,10 +20724,12 @@ __export(src_exports3, {
   WorktreeManager: () => WorktreeManager,
   Z_CRITICAL: () => Z_CRITICAL,
   assemblePrompt: () => assemblePrompt,
+  assembleUtilityPrompt: () => assembleUtilityPrompt,
   buildSpecReviewEnrichment: () => buildSpecReviewEnrichment,
   buildToolSystemPrompt: () => buildToolSystemPrompt,
   createHttpBridgeServer: () => createHttpBridgeServer,
   createProvider: () => createProvider,
+  detectFormatCompliance: () => detectFormatCompliance,
   ensureRulesFile: () => ensureRulesFile,
   extractCategories: () => extractCategories,
   extractSpecReferences: () => extractSpecReferences,
@@ -20614,6 +20750,7 @@ var init_src4 = __esm({
   "packages/orchestrator/src/index.ts"() {
     "use strict";
     init_main_agent();
+    init_dispatch_pipeline();
     init_skill_loader();
     init_skill_counters();
     init_worker_agent();
@@ -23500,6 +23637,16 @@ var init_server = __esm({
           connectedAgentIds: this.connectionManager.getAll().map((c) => c.agentId)
         });
       }
+      /**
+       * Update the dashboard's cached agent configs. Call from the MCP server
+       * after gossip_setup writes config.json so the Team page reflects the new
+       * team without requiring /mcp reconnect. The boot-time snapshot
+       * (mcp-server-sdk.ts:365) still wins on initial boot — this method is a
+       * post-setup override, not a replacement.
+       */
+      setAgentConfigs(configs) {
+        this.dashboardRouter?.updateContext({ agentConfigs: configs });
+      }
     };
   }
 });
@@ -38303,6 +38450,36 @@ async function handleNativeRelay(task_id, result, error48, agentStartedAt, relay
     } catch {
     }
   }
+  if (!error48 && !taskInfo.utilityType && agentId !== "_utility") {
+    try {
+      const { PerformanceWriter: PerformanceWriter2, detectFormatCompliance: detectFormatCompliance2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
+      const compliance = detectFormatCompliance2(result ?? "");
+      const metaWriter = new PerformanceWriter2(process.cwd());
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      metaWriter.appendSignals([
+        { type: "meta", signal: "task_completed", agentId, taskId: task_id, value: elapsed, timestamp: now },
+        {
+          type: "meta",
+          signal: "format_compliance",
+          agentId,
+          taskId: task_id,
+          value: compliance.formatCompliant ? 1 : 0,
+          metadata: {
+            findingCount: compliance.findingCount,
+            citationCount: compliance.citationCount,
+            tags_total: compliance.tags_total,
+            tags_accepted: compliance.tags_accepted,
+            tags_dropped_unknown_type: compliance.tags_dropped_unknown_type,
+            tags_dropped_short_content: compliance.tags_dropped_short_content
+          },
+          timestamp: now
+        }
+      ]);
+    } catch (err) {
+      process.stderr.write(`[gossipcat] native meta signals: ${err.message}
+`);
+    }
+  }
   if (taskInfo.planId && taskInfo.step && !error48) {
     try {
       ctx.mainAgent.recordPlanStepResult(taskInfo.planId, taskInfo.step, result);
@@ -38666,23 +38843,13 @@ async function handleDispatchSingle(agent_id, task, write_mode, scope, timeout_m
       singleSkillIndex,
       task
     );
-    const identityBlock = buildNativeIdentity(agent_id, nativeConfig.model);
-    let agentPrompt = [
-      identityBlock,
-      nativeConfig.instructions || "",
-      skillResult.content,
-      chainContext ? `
-${chainContext}
-` : "",
-      `
----
-
-Task: ${task}`
-    ].filter(Boolean).join("").trim();
-    const MAX_AGENT_PROMPT_CHARS = 3e4;
-    if (agentPrompt.length > MAX_AGENT_PROMPT_CHARS) {
-      agentPrompt = agentPrompt.slice(0, MAX_AGENT_PROMPT_CHARS) + "\n\n[Context truncated to fit budget]";
-    }
+    let agentPrompt = assemblePrompt({
+      identity: buildNativeIdentity(agent_id, nativeConfig.model),
+      instructions: nativeConfig.instructions || void 0,
+      skills: skillResult.content || void 0,
+      chainContext: chainContext || void 0,
+      task
+    });
     if (sanitizeResult.sanitized) agentPrompt = prependScopeNote(agentPrompt);
     recordDispatchMetadata(process.cwd(), {
       taskId,
@@ -38834,20 +39001,13 @@ async function handleDispatchParallel(taskDefs, consensus) {
       parallelSkillIndex,
       def.task
     );
-    const parallelIdentityBlock = buildNativeIdentity(def.agent_id, nativeConfig.model);
-    let agentPrompt = [
-      parallelIdentityBlock,
-      nativeConfig.instructions || "",
-      skillResult.content,
-      `
----
-
-Task: ${def.task}`
-    ].filter(Boolean).join("").trim();
-    const MAX_AGENT_PROMPT_CHARS = 3e4;
-    if (agentPrompt.length > MAX_AGENT_PROMPT_CHARS) {
-      agentPrompt = agentPrompt.slice(0, MAX_AGENT_PROMPT_CHARS) + "\n\n[Context truncated to fit budget]";
-    }
+    let agentPrompt = assemblePrompt({
+      identity: buildNativeIdentity(def.agent_id, nativeConfig.model),
+      instructions: nativeConfig.instructions || void 0,
+      skills: skillResult.content || void 0,
+      consensusSummary: consensus || void 0,
+      task: def.task
+    });
     if (def._sandboxSanitized) agentPrompt = prependScopeNote(agentPrompt);
     recordDispatchMetadata(process.cwd(), {
       taskId,
@@ -38965,11 +39125,6 @@ async function handleDispatchConsensus(taskDefs, _utility_task_id) {
     }
     if (errors.length) lines.push(`Relay errors: ${errors.join(", ")}`);
   }
-  const consensusInstruction = `
-
---- CONSENSUS OUTPUT FORMAT ---
-${CONSENSUS_OUTPUT_FORMAT}
---- END CONSENSUS OUTPUT FORMAT ---`;
   const nativeInstructions = [];
   const nativePrompts = [];
   for (const def of nativeTasks) {
@@ -38987,11 +39142,7 @@ ${CONSENSUS_OUTPUT_FORMAT}
     process.stderr.write(`[gossipcat] dispatch \u2192 ${def.agent_id} (${nativeConfig.model}) [${taskId}]
 `);
     const rawLens = precomputedLenses?.get(def.agent_id);
-    const lensSection = rawLens ? `
-
---- LENS ---
-${rawLens.replace(/---\s*(END )?LENS\s*---/gi, "")}
---- END LENS ---` : "";
+    const lensContent = rawLens ? rawLens.replace(/---\s*(END )?LENS\s*---/gi, "").trim() : void 0;
     let consensusSkillIndex;
     try {
       consensusSkillIndex = ctx.mainAgent.getSkillIndex() ?? void 0;
@@ -39004,23 +39155,14 @@ ${rawLens.replace(/---\s*(END )?LENS\s*---/gi, "")}
       consensusSkillIndex,
       def.task
     );
-    const MAX_AGENT_PROMPT_CHARS = 3e4;
-    const suffix = consensusInstruction + lensSection + `
-
----
-
-Task: ${def.task}`;
-    const prefixBudget = Math.max(0, MAX_AGENT_PROMPT_CHARS - suffix.length);
-    const consensusIdentityBlock = buildNativeIdentity(def.agent_id, nativeConfig.model);
-    let prefix = [
-      consensusIdentityBlock,
-      nativeConfig.instructions || "",
-      skillResultC.content
-    ].filter(Boolean).join("").trim();
-    if (prefix.length > prefixBudget) {
-      prefix = prefix.slice(0, prefixBudget) + "\n\n[Context truncated to fit budget]";
-    }
-    let agentPrompt = prefix + suffix;
+    let agentPrompt = assemblePrompt({
+      identity: buildNativeIdentity(def.agent_id, nativeConfig.model),
+      instructions: nativeConfig.instructions || void 0,
+      skills: skillResultC.content || void 0,
+      consensusSummary: true,
+      lens: lensContent || void 0,
+      task: def.task
+    });
     lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via Agent tool)`);
     nativeInstructions.push(
       `[${taskId}] Agent(model: "${nativeConfig.model}", prompt: <AGENT_PROMPT:${taskId} below>, run_in_background: true)
@@ -39073,6 +39215,15 @@ init_mcp_context();
 init_relay_cross_review();
 init_src3();
 init_src4();
+var CONSENSUS_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{8}$/;
+function isValidConsensusId(id) {
+  return typeof id === "string" && CONSENSUS_ID_RE.test(id);
+}
+function extractConsensusIdFromFindingId(findingId) {
+  if (typeof findingId !== "string") return void 0;
+  const first = findingId.split(":")[0];
+  return isValidConsensusId(first) ? first : void 0;
+}
 async function handleCollect(task_ids, timeout_ms, consensus) {
   await ctx.boot();
   if (consensus && (!task_ids || task_ids.length === 0)) {
@@ -39579,10 +39730,11 @@ ${np.user}
         ...consensusReport.unverified || [],
         ...consensusReport.unique || []
       ];
-      const provisionalConsensusId = allFindings.length > 0 && typeof allFindings[0].id === "string" ? allFindings[0].id.split(":")[0] : void 0;
+      const authoritativeId = consensusReport?.signals?.[0]?.consensusId;
+      const provisionalConsensusId = (isValidConsensusId(authoritativeId) ? authoritativeId : void 0) ?? (allFindings.length > 0 ? extractConsensusIdFromFindingId(allFindings[0].id) : void 0);
       const provisionalSignals = allFindings.filter((f) => !alreadySignaled.has(f.originalAgentId)).map((f) => ({
         type: "consensus",
-        taskId: f.id || "",
+        taskId: provisionalConsensusId || "",
         consensusId: provisionalConsensusId,
         findingId: typeof f.id === "string" ? f.id : void 0,
         signal: tagToSignal[f.tag] || "unique_unconfirmed",
@@ -39958,6 +40110,7 @@ var planExecutionDepth = 0;
 var _pendingSessionData = /* @__PURE__ */ new Map();
 var _pendingSkillData = /* @__PURE__ */ new Map();
 var _pendingVerifyData = /* @__PURE__ */ new Map();
+var _pendingPlanData = /* @__PURE__ */ new Map();
 var _modules = null;
 function lookupFindingSeverity(findingId, projectRoot) {
   const { existsSync: existsSync44, readdirSync: readdirSync13, readFileSync: readFileSync41 } = require("fs");
@@ -40098,16 +40251,16 @@ async function doBoot() {
   }
   const perfWriter = new m.PerformanceWriter(process.cwd());
   const memorySearcher = new m.MemorySearcher(process.cwd());
-  const identityRegistry = /* @__PURE__ */ new Map();
+  ctx.identityRegistry.clear();
   for (const a of agentConfigs) {
-    identityRegistry.set(a.id, {
+    ctx.identityRegistry.set(a.id, {
       agent_id: a.id,
       runtime: a.native ? "native" : "relay",
       provider: a.provider,
       model: a.model
     });
   }
-  const agentLookup = (id) => identityRegistry.get(id);
+  const agentLookup = (id) => ctx.identityRegistry.get(id);
   ctx.toolServer = new m.ToolServer({
     relayUrl: ctx.relay.url,
     projectRoot: process.cwd(),
@@ -40142,7 +40295,7 @@ async function doBoot() {
     const { join: join51 } = require("path");
     const instructionsPath = join51(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
     const baseInstructions = existsSync44(instructionsPath) ? readFileSync41(instructionsPath, "utf-8") : "";
-    const identity = identityRegistry.get(ac.id);
+    const identity = ctx.identityRegistry.get(ac.id);
     const identityBlock = identity ? m.formatIdentityBlock(identity) + "\n" : "";
     const instructions = (identityBlock + baseInstructions).trim() || void 0;
     const enableWebSearch = ac.preset === "researcher" || (ac.skills ?? []).includes("research");
@@ -40171,10 +40324,13 @@ async function doBoot() {
       agentConfigs.push(ac);
       const modelTier = sa.model.includes("opus") ? "opus" : sa.model.includes("haiku") ? "haiku" : "sonnet";
       ctx.nativeAgentConfigs.set(ac.id, { model: modelTier, instructions: sa.instructions, description: sa.description, skills: ac.skills || [] });
+      ctx.identityRegistry.set(ac.id, { agent_id: ac.id, runtime: "native", provider: ac.provider, model: ac.model });
       process.stderr.write(`[gossipcat] \u{1F916} Registered native agent: ${sa.id} (${modelTier})
 `);
     }
   }
+  ctx.mainProviderConfig = config2.main_agent.provider;
+  ctx.mainModelConfig = config2.main_agent.model;
   let mainProvider = config2.main_agent.provider;
   let mainModel = config2.main_agent.model;
   let mainKey = null;
@@ -40209,6 +40365,7 @@ async function doBoot() {
     }
   }
   ctx.mainProvider = mainProvider;
+  ctx.mainModel = mainModel;
   const supaKey = await ctx.keychain.getKey("supabase");
   const supaTeamSalt = await ctx.keychain.getKey("supabase-team-salt");
   ctx.mainAgent = new m.MainAgent({
@@ -40426,8 +40583,23 @@ async function doSyncWorkers() {
     if (!configPath) return;
     const config2 = m.loadConfig(configPath);
     const agentConfigs = m.configToAgentConfigs(config2);
+    if (config2.main_agent && (config2.main_agent.provider !== ctx.mainProviderConfig || config2.main_agent.model !== ctx.mainModelConfig)) {
+      process.stderr.write(
+        `[gossipcat] \u26A0 main_agent changed in config: ${ctx.mainProviderConfig}/${ctx.mainModelConfig} \u2192 ${config2.main_agent.provider}/${config2.main_agent.model}. Restart Claude Code (/mcp reconnect) for the new orchestrator LLM to take effect.
+`
+      );
+      ctx.mainProviderConfig = config2.main_agent.provider;
+      ctx.mainModelConfig = config2.main_agent.model;
+    }
+    ctx.identityRegistry.clear();
     for (const ac of agentConfigs) {
       ctx.mainAgent.registerAgent(ac);
+      ctx.identityRegistry.set(ac.id, {
+        agent_id: ac.id,
+        runtime: ac.native ? "native" : "relay",
+        provider: ac.provider,
+        model: ac.model
+      });
       if (ac.native && !ctx.nativeAgentConfigs.has(ac.id)) {
         const { existsSync: ex, readFileSync: rf } = require("fs");
         const { join: j } = require("path");
@@ -40453,6 +40625,7 @@ async function doSyncWorkers() {
         ctx.mainAgent.registerAgent(ac);
         const modelTier = sa.model.includes("opus") ? "opus" : sa.model.includes("haiku") ? "haiku" : "sonnet";
         ctx.nativeAgentConfigs.set(ac.id, { model: modelTier, instructions: sa.instructions, description: sa.description, skills: ac.skills || [] });
+        ctx.identityRegistry.set(ac.id, { agent_id: ac.id, runtime: "native", provider: ac.provider, model: ac.model });
       }
     }
     const added = await ctx.mainAgent.syncWorkers((provider) => ctx.keychain.getKey(provider));
@@ -40467,6 +40640,25 @@ async function doSyncWorkers() {
       process.stderr.write(`[gossipcat] \u{1F504} Synced: ${ctx.workers.size} relay workers + ${ctx.nativeAgentConfigs.size} native agents
 `);
     }
+    try {
+      const skillIndex = ctx.mainAgent.getSkillIndex?.();
+      if (skillIndex) {
+        const merged = [...agentConfigs, ...claudeSubagentsToConfigs2(claudeSubagents)];
+        skillIndex.seedFromConfigs(merged.map((ac) => ({ id: ac.id, skills: ac.skills || [] })));
+        const allIds = merged.map((ac) => ac.id).filter((id) => typeof id === "string" && id.length > 0);
+        if (allIds.length > 0) skillIndex.ensureBoundWithMode(["memory-retrieval"], allIds, "permanent");
+      }
+    } catch {
+    }
+    try {
+      ctx.mainAgent.invalidateProjectStructureCache?.();
+    } catch {
+    }
+    try {
+      const merged = [...agentConfigs, ...claudeSubagentsToConfigs2(claudeSubagents)];
+      ctx.relay?.setAgentConfigs(merged);
+    } catch {
+    }
   } catch (err) {
     process.stderr.write(`[gossipcat] \u274C syncWorkers failed: ${err.message}
 `);
@@ -40484,17 +40676,83 @@ var server = new import_mcp.McpServer(
     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."
   }
 );
+function buildPlanResponseText(args) {
+  const { task, plan, planned, planId } = args;
+  const taskLines = planned.map((t, i) => {
+    const tag = t.access === "write" ? "[WRITE]" : "[READ]";
+    let line = `  ${i + 1}. ${tag} ${t.agentId || "unassigned"} \u2192 "${t.task}"`;
+    if (t.writeMode) {
+      line += `
+     write_mode: ${t.writeMode}`;
+      if (t.scope) line += ` | scope: ${t.scope}`;
+    }
+    return line;
+  }).join("\n");
+  const assignedTasks = planned.filter((t) => t.agentId);
+  const unassignedTasks = planned.filter((t) => !t.agentId);
+  const planJson = {
+    strategy: plan.strategy,
+    tasks: assignedTasks.map((t, i) => {
+      const entry = { agent_id: t.agentId, task: t.task };
+      if (t.writeMode) entry.write_mode = t.writeMode;
+      if (t.scope) entry.scope = t.scope;
+      entry.plan_id = planId;
+      entry.step = i + 1;
+      return entry;
+    })
+  };
+  let warnings = "";
+  if (plan.warnings?.length) {
+    warnings = `
+Warnings:
+${plan.warnings.map((w) => `  - ${w}`).join("\n")}
+`;
+  }
+  if (unassignedTasks.length) {
+    warnings += `
+Unassigned (excluded from PLAN_JSON \u2014 no matching agent):
+${unassignedTasks.map((t) => `  - "${t.task}"`).join("\n")}
+`;
+  }
+  let dispatchBlock;
+  if (plan.strategy === "sequential" || plan.strategy === "single") {
+    const steps = planJson.tasks.map((t, i) => {
+      const args2 = [`agent_id: "${t.agent_id}"`, `task: "${t.task}"`];
+      if (t.write_mode) args2.push(`write_mode: "${t.write_mode}"`);
+      if (t.scope) args2.push(`scope: "${t.scope}"`);
+      args2.push(`plan_id: "${planId}"`, `step: ${i + 1}`);
+      return `Step ${i + 1}: gossip_dispatch(${args2.join(", ")})
+         then: gossip_collect()`;
+    });
+    dispatchBlock = `Execute sequentially:
+${steps.join("\n\n")}`;
+  } else {
+    dispatchBlock = `PLAN_JSON (pass to gossip_dispatch with mode:"parallel"):
+${JSON.stringify(planJson)}`;
+  }
+  return `Plan: "${task}"
+Plan ID: ${planId}
+
+Strategy: ${plan.strategy}
+
+Tasks:
+${taskLines}
+${warnings}
+---
+${dispatchBlock}`;
+}
 server.tool(
   "gossip_plan",
   'Plan a task with write-mode suggestions. Decomposes into sub-tasks, assigns agents, and classifies each as read or write with suggested write mode. Returns dispatch-ready JSON for approval before execution. Use this before gossip_dispatch(mode:"parallel") for implementation tasks.',
   {
     task: external_exports.string().describe('Task description (e.g. "fix the scope validation bug in packages/tools/")'),
-    strategy: external_exports.enum(["parallel", "sequential", "single"]).optional().describe("Override decomposition strategy. Omit to let the orchestrator decide.")
+    strategy: external_exports.enum(["parallel", "sequential", "single"]).optional().describe("Override decomposition strategy. Omit to let the orchestrator decide."),
+    _utility_task_id: external_exports.string().optional().describe("Internal: utility task ID for re-entry after native decomposition")
   },
-  async ({ task, strategy }) => {
+  async ({ task, strategy, _utility_task_id }) => {
     await boot();
     await syncWorkersViaKeychain();
-    if (planExecutionDepth > 0) {
+    if (planExecutionDepth > 0 && !_utility_task_id) {
       return { content: [{ type: "text", text: "Skipped: already inside a plan step. Execute the task directly instead of re-planning." }] };
     }
     try {
@@ -40507,6 +40765,46 @@ server.tool(
       const registry2 = new AgentRegistry2();
       for (const ac of agentConfigs) registry2.register(ac);
       const { createProvider: createProvider2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
+      if (_utility_task_id) {
+        const stashed = _pendingPlanData.get(_utility_task_id);
+        if (!stashed) {
+          return { content: [{ type: "text", text: `Plan error: no stashed data for utility task ${_utility_task_id}. Re-run gossip_plan.` }] };
+        }
+        const utilityResult = ctx.nativeResultMap.get(_utility_task_id);
+        _pendingPlanData.delete(_utility_task_id);
+        ctx.nativeResultMap.delete(_utility_task_id);
+        ctx.nativeTaskMap.delete(_utility_task_id);
+        if (!utilityResult || utilityResult.status !== "completed" || !utilityResult.result) {
+          process.stderr.write(`[gossipcat] gossip_plan native utility ${_utility_task_id} failed/timed out
+`);
+          return { content: [{ type: "text", text: `Plan error: native decomposition failed or timed out. Configure an API key (gossipcat setup) and retry.` }] };
+        }
+        const dispatcher2 = new TaskDispatcher2(null, registry2);
+        const plan2 = dispatcher2.decomposeFromRaw(stashed.task, utilityResult.result);
+        if (stashed.strategy) plan2.strategy = stashed.strategy;
+        dispatcher2.assignAgents(plan2);
+        const planned2 = dispatcher2.classifyWriteModesFallback(plan2);
+        const planId2 = (0, import_crypto20.randomUUID)().slice(0, 8);
+        const assignedTasks2 = planned2.filter((t) => t.agentId);
+        const planState2 = {
+          id: planId2,
+          task: stashed.task,
+          strategy: plan2.strategy,
+          steps: assignedTasks2.map((t, i) => ({
+            step: i + 1,
+            agentId: t.agentId,
+            task: t.task,
+            writeMode: t.writeMode,
+            scope: t.scope
+          })),
+          createdAt: Date.now()
+        };
+        ctx.mainAgent.registerPlan(planState2);
+        const text2 = buildPlanResponseText({ task: stashed.task, plan: plan2, planned: planned2, planId: planId2 });
+        return { content: [{ type: "text", text: `${text2}
+
+Note: write-mode classification unavailable on this native-only install \u2014 all tasks default to read. Configure a relay API key to enable full classification.` }] };
+      }
       let llm;
       const mainKey = await ctx.keychain.getKey(config2.main_agent.provider);
       if (mainKey) {
@@ -40521,26 +40819,55 @@ server.tool(
             break;
           }
         }
-        if (!llm) return { content: [{ type: "text", text: "No API keys available. Run gossipcat setup to configure keys." }] };
+        if (!llm) {
+          if (ctx.nativeUtilityConfig) {
+            const utilityTaskId = (0, import_crypto20.randomUUID)().slice(0, 8);
+            const relayToken = (0, import_crypto20.randomUUID)().slice(0, 12);
+            const dispatcher2 = new TaskDispatcher2(null, registry2);
+            const messages = dispatcher2.buildDecomposeMessages(task);
+            const asString = (c) => typeof c === "string" ? c : Array.isArray(c) ? c.map((x) => typeof x === "string" ? x : x?.text ?? "").join("") : "";
+            const system = asString(messages.find((m) => m.role === "system")?.content);
+            const user = asString(messages.find((m) => m.role === "user")?.content);
+            _pendingPlanData.set(utilityTaskId, { task, strategy });
+            const UTILITY_TTL_MS = 12e4;
+            ctx.nativeTaskMap.set(utilityTaskId, {
+              agentId: "_utility",
+              task: `plan:${task.slice(0, 120)}`,
+              startedAt: Date.now(),
+              timeoutMs: UTILITY_TTL_MS,
+              utilityType: "plan",
+              relayToken
+            });
+            spawnTimeoutWatcher(utilityTaskId, ctx.nativeTaskMap.get(utilityTaskId));
+            const STASH_TTL_MS = UTILITY_TTL_MS + 3e4;
+            setTimeout(() => {
+              _pendingPlanData.delete(utilityTaskId);
+            }, STASH_TTL_MS).unref();
+            const { assembleUtilityPrompt: assembleUtilityPrompt2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
+            const modelShort = ctx.nativeUtilityConfig.model;
+            return {
+              content: assembleUtilityPrompt2({
+                taskId: utilityTaskId,
+                modelShort,
+                system,
+                user,
+                relayToken,
+                intro: "No API keys available. Dispatching native utility for decomposition.",
+                // F19: JSON.stringify handles backslashes + newlines + quotes correctly.
+                reentrantCall: `gossip_plan(task: ${JSON.stringify(task)}, _utility_task_id: "${utilityTaskId}")`
+              })
+            };
+          }
+          return { content: [{ type: "text", text: "No API keys available. Run gossipcat setup to configure keys." }] };
+        }
       }
       const dispatcher = new TaskDispatcher2(llm, registry2);
       const plan = await dispatcher.decompose(task);
       if (strategy) plan.strategy = strategy;
       dispatcher.assignAgents(plan);
       const planned = await dispatcher.classifyWriteModes(plan);
-      const taskLines = planned.map((t, i) => {
-        const tag = t.access === "write" ? "[WRITE]" : "[READ]";
-        let line = `  ${i + 1}. ${tag} ${t.agentId || "unassigned"} \u2192 "${t.task}"`;
-        if (t.writeMode) {
-          line += `
-     write_mode: ${t.writeMode}`;
-          if (t.scope) line += ` | scope: ${t.scope}`;
-        }
-        return line;
-      }).join("\n");
-      const assignedTasks = planned.filter((t) => t.agentId);
-      const unassignedTasks = planned.filter((t) => !t.agentId);
       const planId = (0, import_crypto20.randomUUID)().slice(0, 8);
+      const assignedTasks = planned.filter((t) => t.agentId);
       const planState = {
         id: planId,
         task,
@@ -40555,56 +40882,7 @@ server.tool(
         createdAt: Date.now()
       };
       ctx.mainAgent.registerPlan(planState);
-      const planJson = {
-        strategy: plan.strategy,
-        tasks: assignedTasks.map((t, i) => {
-          const entry = { agent_id: t.agentId, task: t.task };
-          if (t.writeMode) entry.write_mode = t.writeMode;
-          if (t.scope) entry.scope = t.scope;
-          entry.plan_id = planId;
-          entry.step = i + 1;
-          return entry;
-        })
-      };
-      let warnings = "";
-      if (plan.warnings?.length) {
-        warnings = `
-Warnings:
-${plan.warnings.map((w) => `  - ${w}`).join("\n")}
-`;
-      }
-      if (unassignedTasks.length) {
-        warnings += `
-Unassigned (excluded from PLAN_JSON \u2014 no matching agent):
-${unassignedTasks.map((t) => `  - "${t.task}"`).join("\n")}
-`;
-      }
-      let dispatchBlock;
-      if (plan.strategy === "sequential" || plan.strategy === "single") {
-        const steps = planJson.tasks.map((t, i) => {
-          const args = [`agent_id: "${t.agent_id}"`, `task: "${t.task}"`];
-          if (t.write_mode) args.push(`write_mode: "${t.write_mode}"`);
-          if (t.scope) args.push(`scope: "${t.scope}"`);
-          args.push(`plan_id: "${planId}"`, `step: ${i + 1}`);
-          return `Step ${i + 1}: gossip_dispatch(${args.join(", ")})
-         then: gossip_collect()`;
-        });
-        dispatchBlock = `Execute sequentially:
-${steps.join("\n\n")}`;
-      } else {
-        dispatchBlock = `PLAN_JSON (pass to gossip_dispatch with mode:"parallel"):
-${JSON.stringify(planJson)}`;
-      }
-      const text = `Plan: "${task}"
-Plan ID: ${planId}
-
-Strategy: ${plan.strategy}
-
-Tasks:
-${taskLines}
-${warnings}
----
-${dispatchBlock}`;
+      const text = buildPlanResponseText({ task, plan, planned, planId });
       return { content: [{ type: "text", text }] };
     } catch (err) {
       return { content: [{ type: "text", text: `Plan error: ${err.message}` }] };
@@ -41155,6 +41433,12 @@ server.tool(
     }
     mkdirSync22(join51(root, ".gossip"), { recursive: true });
     writeFileSync18(join51(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
+    try {
+      await syncWorkersViaKeychain();
+    } catch (e) {
+      process.stderr.write(`[gossipcat] gossip_setup: failed to refresh agent state: ${e}
+`);
+    }
     const agentList = Object.entries(config2.agents).map(([id, a]) => `- ${id}: ${a.provider}/${a.model} (${a.preset || "custom"})${a.native ? " \u2014 native" : ""}`).join("\n");
     const rulesDir = join51(root, env.rulesDir);
     const rulesFile = join51(root, env.rulesFile);
@@ -41266,102 +41550,12 @@ Then review the plan and dispatch with gossip_dispatch(mode: "parallel", tasks:
       }
     }
     const isNative = ctx.nativeAgentConfigs.has(agent_id);
-    let _runSanitized = false;
-    try {
-      const { relativizeProjectPaths: relativizeProjectPaths2, readSandboxMode: readSandboxMode2, shouldSanitize: shouldSanitize2 } = (init_sandbox2(), __toCommonJS(sandbox_exports));
-      if (readSandboxMode2(process.cwd()) !== "off") {
-        const preset = (() => {
-          try {
-            return ctx.mainAgent.getAgentList?.().find((a) => a.id === agent_id)?.preset;
-          } catch {
-            return void 0;
-          }
-        })();
-        if (shouldSanitize2(write_mode, preset)) {
-          const { sanitized, replacements } = relativizeProjectPaths2(task, process.cwd());
-          if (replacements > 0) {
-            process.stderr.write(`[gossipcat] \u{1F9F9} sanitized ${replacements} project path(s) in task for ${agent_id}
-`);
-          }
-          task = sanitized;
-          _runSanitized = true;
-        }
-      }
-    } catch {
+    if (isNative) {
+      return handleDispatchSingle(agent_id, task, write_mode, scope);
     }
     const options = {};
     if (write_mode) options.writeMode = write_mode;
     if (scope) options.scope = scope;
-    if (isNative) {
-      if (write_mode === "scoped") {
-        if (!scope) {
-          return { content: [{ type: "text", text: "Error: scoped write mode requires a scope path" }] };
-        }
-        const overlap = ctx.mainAgent.scopeTracker.hasOverlap(scope);
-        if (overlap.overlaps) {
-          return { content: [{ type: "text", text: `Error: Scope "${scope}" conflicts with running task ${overlap.conflictTaskId} at "${overlap.conflictScope}"` }] };
-        }
-      }
-      evictStaleNativeTasks();
-      const taskId = require("crypto").randomUUID().slice(0, 8);
-      const relayToken = require("crypto").randomUUID().slice(0, 12);
-      ctx.nativeTaskMap.set(taskId, { agentId: agent_id, task, startedAt: Date.now(), timeoutMs: NATIVE_TASK_TTL_MS, relayToken });
-      spawnTimeoutWatcher(taskId, ctx.nativeTaskMap.get(taskId));
-      persistNativeTaskMap();
-      try {
-        ctx.mainAgent.recordNativeTask(taskId, agent_id, task);
-      } catch {
-      }
-      if (write_mode === "scoped" && scope) {
-        ctx.mainAgent.scopeTracker.register(scope, taskId);
-      }
-      const config2 = ctx.nativeAgentConfigs.get(agent_id);
-      const basePrompt = config2.instructions || `You are a skilled ${config2.description || "agent"}. Complete the task thoroughly.`;
-      const scopePrefix = write_mode === "scoped" && scope ? `SCOPE RESTRICTION: Only modify files within ${scope}. Do not edit files outside this directory.
-
-` : "";
-      let agentPrompt = `${scopePrefix}${basePrompt}
-
----
-
-Task: ${task}`;
-      if (_runSanitized) {
-        try {
-          const { prependScopeNote: prependScopeNote2 } = (init_sandbox2(), __toCommonJS(sandbox_exports));
-          agentPrompt = prependScopeNote2(agentPrompt);
-        } catch {
-        }
-      }
-      try {
-        const { recordDispatchMetadata: recordDispatchMetadata2 } = (init_sandbox2(), __toCommonJS(sandbox_exports));
-        recordDispatchMetadata2(process.cwd(), {
-          taskId,
-          agentId: agent_id,
-          writeMode: write_mode,
-          scope,
-          timestamp: Date.now()
-        });
-      } catch {
-      }
-      const modelShort = config2.model || "sonnet";
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Dispatched to ${agent_id} (native). Task ID: ${taskId}
-
-\u26A0\uFE0F EXECUTE NOW \u2014 launch this Agent and relay the result:
-
-1. Agent(model: "${modelShort}", prompt: <AGENT_PROMPT:${taskId} below>, run_in_background: true) \u2014 pass the AGENT_PROMPT:${taskId} content item verbatim
-2. When agent completes \u2192 gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<full agent output>")
-
-Do BOTH steps in your next response. Do not wait for user input between them.`
-          },
-          { type: "text", text: `AGENT_PROMPT:${taskId} (${agent_id})
-${agentPrompt}` }
-        ]
-      };
-    }
     if (!ctx.workers.has(agent_id)) {
       await syncWorkersViaKeychain();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gossipcat",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Multi-agent orchestration for Claude Code — parallel review, consensus, adaptive dispatch",
   "mcpName": "io.github.ataberk-xyz/gossipcat",
   "repository": {