gossipcat 0.6.4 → 0.6.6

package/dist-mcp/mcp-server.js

@@ -34010,8 +34010,8 @@ Keep it SHORT \u2014 under 30 lines. This is a working document, not a design do
         ]);
         const specContent = response.text || "";
         try {
-          const { mkdirSync: mkdirSync44, writeFileSync: writeFS } = require("fs");
-          mkdirSync44((0, import_path35.join)(this.projectRoot, ".gossip"), { recursive: true });
+          const { mkdirSync: mkdirSync45, writeFileSync: writeFS } = require("fs");
+          mkdirSync45((0, import_path35.join)(this.projectRoot, ".gossip"), { recursive: true });
           writeFS(specPath, specContent, "utf-8");
         } catch (err) {
           return { text: `Spec generated but failed to save: ${err.message}
@@ -35274,8 +35274,8 @@ message: Your question?
       }
       /** Start all worker agents (connect to relay) */
       async start() {
-        const { existsSync: existsSync73, readFileSync: readFileSync68 } = await import("fs");
-        const { join: join90 } = await import("path");
+        const { existsSync: existsSync73, readFileSync: readFileSync69 } = await import("fs");
+        const { join: join91 } = await import("path");
         for (const config2 of this.registry.getAll()) {
           if (config2.native) continue;
           if (this.workers.has(config2.id)) continue;
@@ -35293,8 +35293,8 @@ message: Your question?
             void 0,
             config2.key_ref
           );
-          const instructionsPath = join90(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
-          const instructions = existsSync73(instructionsPath) ? readFileSync68(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join91(this.projectRoot, ".gossip", "agents", config2.id, "instructions.md");
+          const instructions = existsSync73(instructionsPath) ? readFileSync69(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, config2.maxToolTurns);
           await worker.start();
@@ -35491,8 +35491,8 @@ message: Your question?
         this.registry.register(config2);
       }
       async syncWorkers(keyProvider) {
-        const { existsSync: existsSync73, readFileSync: readFileSync68 } = await import("fs");
-        const { join: join90 } = await import("path");
+        const { existsSync: existsSync73, readFileSync: readFileSync69 } = await import("fs");
+        const { join: join91 } = await import("path");
         let added = 0;
         for (const ac of this.registry.getAll()) {
           if (ac.native) continue;
@@ -35509,8 +35509,8 @@ message: Your question?
             this.workers.delete(ac.id);
           }
           const llm = createProviderForAgent(ac.id, ac.provider, ac.model, key ?? void 0, ac.base_url, void 0, ac.key_ref);
-          const instructionsPath = join90(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
-          const instructions = existsSync73(instructionsPath) ? readFileSync68(instructionsPath, "utf-8") : void 0;
+          const instructionsPath = join91(this.projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+          const instructions = existsSync73(instructionsPath) ? readFileSync69(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, ac.maxToolTurns);
           await worker.start();
@@ -44211,18 +44211,163 @@ var init_api_chat = __esm({
   }
 });
 
+// packages/relay/src/dashboard/chat-store.ts
+function isMirrorFrameShaped(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const f = obj;
+  return f.type === "mirror" && typeof f.chat_id === "string" && typeof f.role === "string" && typeof f.text === "string" && typeof f.ts === "string" && typeof f.id === "number";
+}
+var import_fs70, import_path78, CHAT_ID_RE, PERSIST_CAP, MAX_LINE_BYTES, NullChatStore, FileChatStore;
+var init_chat_store = __esm({
+  "packages/relay/src/dashboard/chat-store.ts"() {
+    "use strict";
+    import_fs70 = require("fs");
+    import_path78 = require("path");
+    CHAT_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+    PERSIST_CAP = 1e3;
+    MAX_LINE_BYTES = 256 * 1024;
+    NullChatStore = class {
+      append(_chatId, _frame) {
+      }
+      load(_chatId, _max) {
+        return [];
+      }
+      drop(_chatId) {
+      }
+      dispose() {
+      }
+    };
+    FileChatStore = class {
+      constructor(chatDir) {
+        this.chatDir = chatDir;
+      }
+      chatDir;
+      /**
+       * Per-chat append counter. Used to gate maybeRetain() calls so we do not
+       * read the file on every append (O(1) amortized instead of O(N)):
+       *   - First append for a chatId in this process: one-time retention check
+       *     (bounds a large pre-existing file from a prior run).
+       *   - Subsequent appends: only call maybeRetain every PERSIST_CAP writes.
+       */
+      appendCounters = /* @__PURE__ */ new Map();
+      isValidChatId(chatId) {
+        return CHAT_ID_RE.test(chatId);
+      }
+      filePath(chatId) {
+        return (0, import_path78.join)(this.chatDir, `${chatId}.jsonl`);
+      }
+      append(chatId, frame) {
+        if (!this.isValidChatId(chatId)) return;
+        if (chatId.startsWith("_")) return;
+        try {
+          (0, import_fs70.mkdirSync)(this.chatDir, { recursive: true });
+          const line = JSON.stringify(frame) + "\n";
+          (0, import_fs70.appendFileSync)(this.filePath(chatId), line, "utf8");
+          const prev = this.appendCounters.get(chatId);
+          const count = (prev ?? 0) + 1;
+          this.appendCounters.set(chatId, count);
+          const isFirst = prev === void 0;
+          if (isFirst || count % PERSIST_CAP === 0) {
+            this.maybeRetain(chatId);
+          }
+        } catch (err) {
+          console.warn(`[chat-store] append failed for chatId=${chatId}:`, err);
+        }
+      }
+      maybeRetain(chatId) {
+        if (chatId.startsWith("_")) return;
+        try {
+          const fp = this.filePath(chatId);
+          const content = (0, import_fs70.readFileSync)(fp, "utf8");
+          const lines = content.split("\n").filter((l) => l.length > 0);
+          if (lines.length < 2 * PERSIST_CAP) return;
+          const kept = lines.slice(lines.length - PERSIST_CAP);
+          const tmp = fp + ".tmp";
+          (0, import_fs70.writeFileSync)(tmp, kept.join("\n") + "\n", "utf8");
+          (0, import_fs70.renameSync)(tmp, fp);
+        } catch (err) {
+          this.cleanupStaleTmp(chatId);
+          console.warn(`[chat-store] retain failed for chatId=${chatId}`, err);
+        }
+      }
+      /**
+       * Best-effort removal of a stale `<chatId>.jsonl.tmp` left by a crash between
+       * maybeRetain's writeFileSync and renameSync (the live .jsonl is always
+       * intact; only the tmp orphans). Called on cold load() so orphans from a
+       * prior process run are reclaimed when the chat is next hydrated, and from
+       * maybeRetain's catch. ENOENT (the normal case) is silent.
+       */
+      cleanupStaleTmp(chatId) {
+        try {
+          (0, import_fs70.unlinkSync)(this.filePath(chatId) + ".tmp");
+        } catch (err) {
+          if (err?.code !== "ENOENT") {
+            console.warn(`[chat-store] stale .tmp cleanup failed for chatId=${chatId}:`, err);
+          }
+        }
+      }
+      load(chatId, max) {
+        if (!this.isValidChatId(chatId)) return [];
+        this.cleanupStaleTmp(chatId);
+        let content;
+        try {
+          content = (0, import_fs70.readFileSync)(this.filePath(chatId), "utf8");
+        } catch (err) {
+          if (err?.code === "ENOENT") return [];
+          console.warn(`[chat-store] load failed for chatId=${chatId}:`, err);
+          return [];
+        }
+        const lines = content.split("\n").filter((l) => l.length > 0);
+        const frames = [];
+        for (const line of lines) {
+          if (line.length > MAX_LINE_BYTES) {
+            console.warn(`[chat-store] skipping oversized line (${line.length} bytes) for chatId=${chatId}`);
+            continue;
+          }
+          try {
+            const parsed = JSON.parse(line);
+            if (isMirrorFrameShaped(parsed)) {
+              frames.push(parsed);
+            } else {
+              console.warn(`[chat-store] skipping line with valid JSON but wrong MirrorFrame shape for chatId=${chatId}`);
+            }
+          } catch {
+            console.warn(`[chat-store] skipping unparseable line for chatId=${chatId}`);
+          }
+        }
+        if (frames.length <= max) return frames;
+        return frames.slice(frames.length - max);
+      }
+      drop(chatId) {
+        if (!this.isValidChatId(chatId)) return;
+        try {
+          (0, import_fs70.unlinkSync)(this.filePath(chatId));
+        } catch (err) {
+          if (err?.code !== "ENOENT") {
+            console.warn(`[chat-store] drop failed for chatId=${chatId}:`, err);
+          }
+        }
+      }
+      dispose() {
+      }
+    };
+  }
+});
+
 // packages/relay/src/dashboard/api-mirror-events.ts
 var MIRROR_RING_MAX, MIRROR_RING_TTL_MS, MIRROR_SWEEP_INTERVAL_MS, MirrorEventStore;
 var init_api_mirror_events = __esm({
   "packages/relay/src/dashboard/api-mirror-events.ts"() {
     "use strict";
+    init_chat_store();
     MIRROR_RING_MAX = 100;
     MIRROR_RING_TTL_MS = 2 * 60 * 60 * 1e3;
     MIRROR_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
     MirrorEventStore = class {
-      constructor(ringMax = MIRROR_RING_MAX, ttlMs = MIRROR_RING_TTL_MS, sweepIntervalMs = MIRROR_SWEEP_INTERVAL_MS) {
+      constructor(ringMax = MIRROR_RING_MAX, ttlMs = MIRROR_RING_TTL_MS, sweepIntervalMs = MIRROR_SWEEP_INTERVAL_MS, store = new NullChatStore()) {
         this.ringMax = ringMax;
         this.ttlMs = ttlMs;
+        this.store = store;
         if (sweepIntervalMs > 0) {
           this.sweepTimer = setInterval(() => this.sweep(Date.now()), sweepIntervalMs);
           this.sweepTimer.unref?.();
@@ -44232,18 +44377,44 @@ var init_api_mirror_events = __esm({
       ttlMs;
       rings = /* @__PURE__ */ new Map();
       sweepTimer = null;
+      store;
       /**
-       * Allocate the next id for a chat_id WITHOUT pushing a frame. The hub stamps
-       * id + ts server-side, so it asks the store to mint the id, builds the frame,
-       * then pushes it. Keeping mint+push as one call (push) avoids a torn counter,
-       * so this is internal — callers use push().
+       * Allocate or hydrate a ring for a chat_id. On first access when the ring is
+       * not in memory, loads persisted frames from the ChatStore so post-restart
+       * reads see durable history and the id sequence continues (preventing false
+       * restart-sentinels). Returns null when neither an in-memory ring exists NOR
+       * any persisted frames were found — callers treat null as "no data."
+       *
+       * Renamed from `ensureRing` to `getOrHydrate` to reflect the new semantics.
+       * push() uses a variant that always creates the ring (even if empty), since a
+       * push always establishes a new ring. replaySlice/highestId use this
+       * conditional form so they don't pollute ringCount() with empty rings on miss.
+       */
+      getOrHydrate(chatId, now) {
+        const existing = this.rings.get(chatId);
+        if (existing) return existing;
+        const persisted = this.store.load(chatId, this.ringMax);
+        if (persisted.length === 0) return null;
+        const ring2 = {
+          frames: persisted.slice(),
+          // Continue the id sequence from the highest persisted id so push() does
+          // not reset to 1 after a restart (preventing the false restart-sentinel).
+          nextId: persisted[persisted.length - 1].id,
+          touchedAt: now
+        };
+        this.rings.set(chatId, ring2);
+        return ring2;
+      }
+      /**
+       * Ensure a ring exists for a chat_id, creating it from persisted data or
+       * fresh. Always returns a ring (never null). Used only by push() since a
+       * push always establishes a ring.
        */
       ensureRing(chatId, now) {
-        let ring2 = this.rings.get(chatId);
-        if (!ring2) {
-          ring2 = { frames: [], nextId: 0, touchedAt: now };
-          this.rings.set(chatId, ring2);
-        }
+        const hydrated = this.getOrHydrate(chatId, now);
+        if (hydrated) return hydrated;
+        const ring2 = { frames: [], nextId: 0, touchedAt: now };
+        this.rings.set(chatId, ring2);
         return ring2;
       }
       /**
@@ -44266,6 +44437,7 @@ var init_api_mirror_events = __esm({
         ring2.frames.push(frame);
         while (ring2.frames.length > this.ringMax) ring2.frames.shift();
         ring2.touchedAt = now;
+        this.store.append(chatId, frame);
         return frame;
       }
       /**
@@ -44275,7 +44447,7 @@ var init_api_mirror_events = __esm({
        * actively-observed stream isn't swept out from under a reconnecting client.
        */
       replaySlice(chatId, lastId, now = Date.now()) {
-        const ring2 = this.rings.get(chatId);
+        const ring2 = this.getOrHydrate(chatId, now);
         if (!ring2) return [];
         ring2.touchedAt = now;
         if (lastId <= 0) return ring2.frames.slice();
@@ -44307,6 +44479,7 @@ var init_api_mirror_events = __esm({
         }
         const carried = src.frames.slice();
         this.rings.delete(fromChatId);
+        this.store.drop(fromChatId);
         const transferred = [];
         for (const f of carried) {
           transferred.push(this.push(toChatId, f.role, f.text, now));
@@ -44321,7 +44494,7 @@ var init_api_mirror_events = __esm({
        * sentinel in api-bridge.handleStream).
        */
       highestId(chatId) {
-        const ring2 = this.rings.get(chatId);
+        const ring2 = this.getOrHydrate(chatId, Date.now());
         if (!ring2 || ring2.frames.length === 0) return 0;
         return ring2.frames[ring2.frames.length - 1].id;
       }
@@ -44350,25 +44523,110 @@ var init_api_mirror_events = __esm({
 });
 
 // packages/relay/src/dashboard/api-bridge.ts
+function validateAskQuestions(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return { error: "questions must be a non-empty array" };
+  }
+  if (raw.length > ASK_MAX_QUESTIONS) {
+    return { error: `too many questions (max ${ASK_MAX_QUESTIONS})` };
+  }
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    const q = raw[i];
+    if (!q || typeof q !== "object") {
+      return { error: `question ${i} must be an object` };
+    }
+    if (typeof q.header !== "string" || q.header.trim().length === 0) {
+      return { error: `question ${i} header must be a non-empty string` };
+    }
+    if (q.header.length > ASK_MAX_HEADER) {
+      return { error: `question ${i} header too long (max ${ASK_MAX_HEADER})` };
+    }
+    if (typeof q.question !== "string" || q.question.trim().length === 0) {
+      return { error: `question ${i} question must be a non-empty string` };
+    }
+    if (q.question.length > ASK_MAX_QUESTION) {
+      return { error: `question ${i} question too long (max ${ASK_MAX_QUESTION})` };
+    }
+    if (q.multiSelect !== void 0 && typeof q.multiSelect !== "boolean") {
+      return { error: `question ${i} multiSelect must be a boolean` };
+    }
+    if (q.allowOther !== void 0 && typeof q.allowOther !== "boolean") {
+      return { error: `question ${i} allowOther must be a boolean` };
+    }
+    if (!Array.isArray(q.options) || q.options.length === 0) {
+      return { error: `question ${i} options must be a non-empty array` };
+    }
+    if (q.options.length > ASK_MAX_OPTIONS) {
+      return { error: `question ${i} has too many options (max ${ASK_MAX_OPTIONS})` };
+    }
+    const options = [];
+    const labels = /* @__PURE__ */ new Set();
+    for (let j = 0; j < q.options.length; j++) {
+      const o = q.options[j];
+      if (!o || typeof o !== "object") {
+        return { error: `question ${i} option ${j} must be an object` };
+      }
+      if (typeof o.label !== "string" || o.label.trim().length === 0) {
+        return { error: `question ${i} option ${j} label must be a non-empty string` };
+      }
+      if (o.label.length > ASK_MAX_LABEL) {
+        return { error: `question ${i} option ${j} label too long (max ${ASK_MAX_LABEL})` };
+      }
+      if (labels.has(o.label)) {
+        return { error: `question ${i} has a duplicate option label` };
+      }
+      labels.add(o.label);
+      const opt = { label: o.label };
+      if (o.description !== void 0 && o.description !== null) {
+        if (typeof o.description !== "string") {
+          return { error: `question ${i} option ${j} description must be a string` };
+        }
+        if (o.description.length > ASK_MAX_DESCRIPTION) {
+          return { error: `question ${i} option ${j} description too long (max ${ASK_MAX_DESCRIPTION})` };
+        }
+        opt.description = o.description;
+      }
+      options.push(opt);
+    }
+    out.push({
+      questionId: `q${i}`,
+      header: q.header,
+      question: q.question,
+      ...q.multiSelect === true ? { multiSelect: true } : {},
+      options,
+      ...q.allowOther === true ? { allowOther: true } : {}
+    });
+  }
+  return { questions: out };
+}
 function isMirrorRole(v) {
   return typeof v === "string" && MIRROR_ROLES.includes(v);
 }
 function validateChatId(raw) {
   if (typeof raw !== "string") return null;
   const v = raw.trim();
-  if (!CHAT_ID_RE.test(v)) return null;
+  if (!CHAT_ID_RE2.test(v)) return null;
   return v;
 }
-var import_crypto26, MIRROR_ROLES, MIRROR_MAX_TEXT, MIRROR_MAX_FRAMES, CHAT_ID_RE, MAX_MESSAGE_LENGTH, MAX_BRIDGE_CLIENTS, KEEPALIVE_MS2, BACKPRESSURE_EVICT_THRESHOLD2, BridgeHub;
+var import_crypto26, ASK_MAX_QUESTIONS, ASK_MAX_OPTIONS, ASK_MAX_HEADER, ASK_MAX_QUESTION, ASK_MAX_LABEL, ASK_MAX_DESCRIPTION, ASK_MAX_OTHER, MIRROR_ROLES, MIRROR_MAX_TEXT, MIRROR_MAX_FRAMES, CHAT_ID_RE2, MAX_MESSAGE_LENGTH, MAX_BRIDGE_CLIENTS, KEEPALIVE_MS2, BACKPRESSURE_EVICT_THRESHOLD2, BridgeHub;
 var init_api_bridge = __esm({
   "packages/relay/src/dashboard/api-bridge.ts"() {
     "use strict";
     import_crypto26 = require("crypto");
     init_api_mirror_events();
+    init_chat_store();
+    ASK_MAX_QUESTIONS = 4;
+    ASK_MAX_OPTIONS = 8;
+    ASK_MAX_HEADER = 120;
+    ASK_MAX_QUESTION = 600;
+    ASK_MAX_LABEL = 120;
+    ASK_MAX_DESCRIPTION = 240;
+    ASK_MAX_OTHER = 400;
     MIRROR_ROLES = ["user", "assistant", "activity"];
     MIRROR_MAX_TEXT = 2 * 1024;
     MIRROR_MAX_FRAMES = 64;
-    CHAT_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+    CHAT_ID_RE2 = /^[a-zA-Z0-9_-]{1,128}$/;
     MAX_MESSAGE_LENGTH = 32 * 1024;
     MAX_BRIDGE_CLIENTS = 20;
     KEEPALIVE_MS2 = 25e3;
@@ -44381,6 +44639,13 @@ var init_api_bridge = __esm({
       // eviction can clearInterval too — the req 'close' handler may never fire on
       // an abrupt res.destroy(), which would otherwise leak the timer.
       keepalives = /* @__PURE__ */ new Map();
+      // Per-client subscribed chat_id (null = no ?chat_id supplied = live-only legacy
+      // consumer). Set when the client is added to this.clients in handleStream.
+      // Server-side filtering in broadcast() uses this: each frame is only delivered
+      // to the client(s) whose subscribed chat_id matches frame.chat_id. A null-
+      // subscribed client receives nothing — the old "shared broadcast to all"
+      // behaviour is intentionally replaced with per-client routing.
+      clientChatId = /* @__PURE__ */ new Map();
       // chat_ids we have seen on an INBOUND POST. Outbound replies bind against this
       // set (consensus f5): the live session can only address a stream the dashboard
       // actually opened, never an arbitrary/forged id. Bounded + TTL'd so a long
@@ -44389,6 +44654,16 @@ var init_api_bridge = __esm({
       static MAX_KNOWN_CHAT_IDS = 64;
       static CHAT_ID_TTL_MS = 2 * 60 * 60 * 1e3;
       // 2h, mirror chat-session-store
+      // ── Outstanding-question registry (gossip_ask round-trip) ───────────────────
+      // qid → {chatId, questions, at}. An inbound answer is validated against the
+      // EXACT set that was asked: the questionId must exist, each selected label must
+      // be one of that question's option labels, `other` only when allowOther. The
+      // registry is bounded + TTL'd (fail-closed eviction) so a long-running session
+      // can't grow it unbounded and a stale qid can never be answered.
+      outstandingQuestions = /* @__PURE__ */ new Map();
+      static MAX_OUTSTANDING_QUESTIONS = 64;
+      static QUESTION_TTL_MS = 2 * 60 * 60 * 1e3;
+      // 2h, mirror knownChatIds
       // ── Mirror state (spec v2 §3) ──────────────────────────────────────────────
       // chat_ids eligible to RECEIVE mirror frames. SEPARATE from knownChatIds
       // (sonnet:f7/f12). P1#1: this set is seeded ONLY from the relay's validated
@@ -44398,19 +44673,6 @@ var init_api_bridge = __esm({
       // emitReply STILL gates on knownChatIds, so mirroring never widens the
       // outbound reply boundary (api-bridge.ts emitReply isKnownChatId check).
       mirrorChatIds = /* @__PURE__ */ new Map();
-      // The most-recently-registered active mirror chat_id (set in
-      // registerMirrorChatId, cleared/recomputed when that id is TTL-evicted).
-      // Used by emitMirror to route unresolved terminal frames to a live observer
-      // instead of the provisional buffer when one exists (fix: mirror frames
-      // previously fell into _provisional and were dropped by the dashboard client
-      // because bindSession never ran — the browser cannot send a session_id it
-      // doesn't know). SECURITY: only ever a chat_id already in mirrorChatIds.
-      // KNOWN LIMITATION (consensus 96350953-8ce94428): single-pointer, so with
-      // multiple concurrent dashboard tabs only the most-recently-registered one
-      // receives unresolved terminal frames; earlier tabs see no live activity until
-      // they send again. Accepted tradeoff — a strict improvement over the prior
-      // behaviour where the frames went to _provisional and EVERY tab saw nothing.
-      latestMirrorChatId = null;
       // Session→chat_id map (P1#5). The relay has no native "active session
       // chat_id" notion — a no-chat_id inbound POST mints a fresh UUID. We learn the
       // mapping from the dashboard turn: a turn carries BOTH a chat_id (validated)
@@ -44419,7 +44681,8 @@ var init_api_bridge = __esm({
       // through here. Established only from a validated dashboard inbound POST.
       sessionToChatId = /* @__PURE__ */ new Map();
       // Per-chat_id mirror rings (bounded FIFO + TTL + proactive sweep).
-      mirror = new MirrorEventStore();
+      // Constructed with a FileChatStore when chatDir is provided, else NullChatStore.
+      mirror;
       // PROVISIONAL buffer (P1#5 fallback): a purely-terminal mirror POST with no
       // resolvable chat_id (no body chat_id, no known session mapping) is buffered
       // under a provisional id so a later observer can backfill it — OR dropped,
@@ -44434,6 +44697,10 @@ var init_api_bridge = __esm({
       dropUnresolvedMirror = false;
       // session→chat_id entries share the same 2h TTL ceiling as knownChatIds.
       static MAX_SESSION_MAPPINGS = 64;
+      constructor(opts = {}) {
+        const store = opts.chatDir ? new FileChatStore(opts.chatDir) : new NullChatStore();
+        this.mirror = new MirrorEventStore(MIRROR_RING_MAX, MIRROR_RING_TTL_MS, void 0, store);
+      }
       /** Register (or clear) the in-process inbound sink. Called by RelayServer. */
       registerSink(fn) {
         this.sink = fn;
@@ -44523,6 +44790,165 @@ var init_api_bridge = __esm({
         this.broadcast({ type: "ack", chat_id: chatId, ts: (/* @__PURE__ */ new Date()).toISOString() });
         return true;
       }
+      /**
+       * OUTBOUND: the MCP `gossip_ask` tool asks the dashboard a selection question.
+       * Gates on knownChatIds EXACTLY like emitReply — a question may only target a
+       * stream the dashboard actually opened, never an arbitrary/forged id. On
+       * success the validated question set is registered under `qid` (so a later
+       * inbound answer can be validated against what was asked) and a `question`
+       * frame is fanned out over SSE.
+       *
+       * LIVE-ONLY: like reply/ack, a `question` frame has NO per-chat_id ring — an
+       * unanswered question is LOST on a dashboard reload (acceptable v1). The
+       * registry entry survives a reload (so an answer typed after reconnect would
+       * still validate), but the rendered card does not.
+       *
+       * Returns false (no registration, no broadcast) when the chat_id is
+       * malformed/unbound or no SSE client is connected, so the MCP tool can no-op
+       * honestly — same posture as emitReply.
+       */
+      emitQuestion(rawChatId, qid, questions) {
+        const chatId = validateChatId(rawChatId);
+        if (chatId === null) return false;
+        if (!this.isKnownChatId(chatId)) return false;
+        if (this.clients.size === 0) return false;
+        if (typeof qid !== "string" || qid.length === 0) return false;
+        if (!Array.isArray(questions) || questions.length === 0) return false;
+        this.registerOutstandingQuestion(qid, chatId, questions);
+        this.broadcast({ type: "question", chat_id: chatId, qid, questions, ts: (/* @__PURE__ */ new Date()).toISOString() });
+        return true;
+      }
+      /**
+       * INBOUND ANSWER (UNTRUSTED — this is the security boundary). The dashboard
+       * POSTs `{chat_id, answer:{qid, responses:[{questionId, selected[], other?}]}}`.
+       * VALIDATES fail-closed against the registered question set:
+       *   - chat_id is known (bound to an opened stream);
+       *   - qid is an outstanding question FOR THAT chat_id (cross-chat reuse → 400);
+       *   - each questionId exists in the asked set, with no duplicates / no missing;
+       *   - each `selected` label is one of THAT question's option labels (an unknown
+       *     label → 400; a single-select question accepts at most one label);
+       *   - `other` is only allowed when that question had allowOther, and is trimmed
+       *     + length-capped.
+       * On VALID: a concise channel turn is formatted and delivered to the live CC
+       * session via the SAME sink path inbound chat messages use (so it arrives as a
+       * normal turn), then the qid is deleted (single-use). Returns a route-shaped
+       * {status,payload}: 202 on accept, 400 on any validation failure, 503 when no
+       * sink is wired.
+       */
+      handleAnswer(body) {
+        const b = body ?? {};
+        const chatId = validateChatId(b.chat_id);
+        if (chatId === null) {
+          return { status: 400, payload: { error: "invalid chat_id" } };
+        }
+        if (!this.isKnownChatId(chatId)) {
+          return { status: 400, payload: { error: "unknown chat_id (not an open dashboard stream)" } };
+        }
+        const answer = b.answer;
+        if (!answer || typeof answer !== "object") {
+          return { status: 400, payload: { error: "answer must be an object" } };
+        }
+        const qid = answer.qid;
+        if (typeof qid !== "string" || qid.length === 0) {
+          return { status: 400, payload: { error: "answer.qid must be a non-empty string" } };
+        }
+        this.evictOutstandingQuestions(Date.now());
+        const outstanding = this.outstandingQuestions.get(qid);
+        if (!outstanding) {
+          return { status: 400, payload: { error: "unknown or expired qid" } };
+        }
+        if (outstanding.chatId !== chatId) {
+          return { status: 400, payload: { error: "qid does not belong to this chat_id" } };
+        }
+        const responses = answer.responses;
+        if (!Array.isArray(responses) || responses.length === 0) {
+          return { status: 400, payload: { error: "answer.responses must be a non-empty array" } };
+        }
+        if (responses.length > outstanding.questions.length) {
+          return { status: 400, payload: { error: "too many responses" } };
+        }
+        const seen = /* @__PURE__ */ new Set();
+        const parts = [];
+        for (const r of responses) {
+          if (!r || typeof r !== "object") {
+            return { status: 400, payload: { error: "each response must be an object" } };
+          }
+          const rr = r;
+          if (typeof rr.questionId !== "string") {
+            return { status: 400, payload: { error: "response.questionId must be a string" } };
+          }
+          const questionId = rr.questionId;
+          if (seen.has(questionId)) {
+            return { status: 400, payload: { error: "duplicate questionId in responses" } };
+          }
+          const q = outstanding.questions.find((x) => x.questionId === questionId);
+          if (!q) {
+            return { status: 400, payload: { error: `unknown questionId "${questionId}"` } };
+          }
+          seen.add(questionId);
+          if (!Array.isArray(rr.selected)) {
+            return { status: 400, payload: { error: "response.selected must be an array" } };
+          }
+          const selected = rr.selected;
+          if (!q.multiSelect && selected.length > 1) {
+            return { status: 400, payload: { error: `question "${questionId}" is single-select` } };
+          }
+          if (selected.length > q.options.length) {
+            return { status: 400, payload: { error: "too many selected labels" } };
+          }
+          const labels = new Set(q.options.map((o) => o.label));
+          const chosen = [];
+          const seenLabels = /* @__PURE__ */ new Set();
+          for (const s of selected) {
+            if (typeof s !== "string" || !labels.has(s)) {
+              return { status: 400, payload: { error: `unknown option label for question "${questionId}"` } };
+            }
+            if (seenLabels.has(s)) {
+              return { status: 400, payload: { error: "duplicate selected label" } };
+            }
+            seenLabels.add(s);
+            chosen.push(s);
+          }
+          let otherText = null;
+          if (rr.other !== void 0 && rr.other !== null) {
+            if (!q.allowOther) {
+              return { status: 400, payload: { error: `question "${questionId}" does not allow other` } };
+            }
+            if (typeof rr.other !== "string") {
+              return { status: 400, payload: { error: "response.other must be a string" } };
+            }
+            const sanitized = rr.other.replace(/[\x00-\x1F\x7F]/g, " ").replace(/\s+/g, " ").replace(/\[answer/gi, "(answer").trim();
+            if (sanitized.length > ASK_MAX_OTHER) {
+              return { status: 400, payload: { error: "other text too long" } };
+            }
+            if (sanitized.length > 0) {
+              otherText = sanitized.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            }
+          }
+          if (chosen.length === 0 && otherText === null) {
+            return { status: 400, payload: { error: `question "${questionId}" has no selection` } };
+          }
+          const segs = [];
+          if (chosen.length > 0) segs.push(chosen.join(", "));
+          if (otherText !== null) segs.push(`other: "${otherText}"`);
+          parts.push(`${q.header}: ${segs.join(" \xB7 ")}`);
+        }
+        if (!this.sink) {
+          return { status: 503, payload: { error: "No live Claude Code bridge session is active" } };
+        }
+        const turn = `[answer qid=${qid}] ${parts.join(" \xB7 ")}`;
+        let delivered;
+        try {
+          delivered = this.sink(chatId, turn);
+        } catch {
+          delivered = false;
+        }
+        if (!delivered) {
+          return { status: 503, payload: { error: "Bridge sink rejected the answer" } };
+        }
+        this.outstandingQuestions.delete(qid);
+        return { status: 202, payload: { ok: true, qid, chat_id: chatId } };
+      }
       /**
        * MIRROR ingress (spec v2 §3). Validates the (already body-capped + role-
        * checked-at-route) batch a SECOND time at the trust boundary, resolves the
@@ -44594,10 +45020,25 @@ var init_api_bridge = __esm({
             chatId = resolved;
           } else if (this.dropUnresolvedMirror) {
             return { status: 202, payload: { ok: true, chat_id: null, dropped: validated.length } };
-          } else if (this.latestMirrorChatId !== null && this.isMirrorChatId(this.latestMirrorChatId)) {
-            chatId = this.latestMirrorChatId;
           } else {
-            chatId = _BridgeHub.PROVISIONAL_CHAT_ID;
+            this.evictMirrorChatIds(Date.now());
+            const liveIds = Array.from(this.mirrorChatIds.keys());
+            if (liveIds.length > 0) {
+              let totalFrames = 0;
+              for (const id of liveIds) {
+                for (const { role, text } of validated) {
+                  const frame = this.mirror.push(id, role, text);
+                  this.broadcast(frame);
+                  totalFrames++;
+                }
+              }
+              return {
+                status: 202,
+                payload: { ok: true, chat_id: null, fanout: liveIds.length, frames: totalFrames }
+              };
+            } else {
+              chatId = _BridgeHub.PROVISIONAL_CHAT_ID;
+            }
           }
         }
         const stamped = [];
@@ -44667,6 +45108,7 @@ var init_api_bridge = __esm({
         }
         this.backpressure.set(res, 0);
         this.clients.add(res);
+        this.clientChatId.set(res, chatId);
         const keepalive = setInterval(() => {
           if (chatId !== null) this.touchMirrorChatId(chatId);
           try {
@@ -44680,6 +45122,7 @@ var init_api_bridge = __esm({
         req.on("close", () => {
           this.clearKeepalive(res);
           this.clients.delete(res);
+          this.clientChatId.delete(res);
         });
       }
       /**
@@ -44718,7 +45161,16 @@ var init_api_bridge = __esm({
           return false;
         }
       }
-      /** Fan out one frame to every connected SSE client, with backpressure eviction. */
+      /**
+       * Fan out one frame to matching connected SSE clients (server-side filter),
+       * with backpressure eviction.
+       *
+       * Each frame carries a chat_id. Only the client(s) subscribed to that
+       * chat_id receive the write — clients subscribed to a different chat_id or
+       * with a null subscription (legacy live-only consumer) are skipped. This
+       * eliminates the prior behaviour of broadcasting EVERY frame to ALL clients
+       * (the bandwidth/confidentiality gap noted in the multi-tab fix spec).
+       */
       broadcast(frame) {
         const idLine = "id" in frame && typeof frame.id === "number" ? `id: ${frame.id}
 ` : "";
@@ -44726,6 +45178,8 @@ var init_api_bridge = __esm({
 
 `;
         for (const res of this.clients) {
+          const subscribedChatId = this.clientChatId.get(res) ?? null;
+          if (subscribedChatId === null || subscribedChatId !== frame.chat_id) continue;
           try {
             const ok = res.write(data);
             if (ok) {
@@ -44737,11 +45191,13 @@ var init_api_bridge = __esm({
                 this.clearKeepalive(res);
                 res.destroy();
                 this.clients.delete(res);
+                this.clientChatId.delete(res);
               }
             }
           } catch {
             this.clearKeepalive(res);
             this.clients.delete(res);
+            this.clientChatId.delete(res);
           }
         }
       }
@@ -44790,6 +45246,34 @@ var init_api_bridge = __esm({
           if (now - v > _BridgeHub.CHAT_ID_TTL_MS) this.knownChatIds.delete(k);
         }
       }
+      // ── Outstanding-question registry helpers (gossip_ask) ──────────────────────
+      /**
+       * Register a validated question set under `qid`. Bounded + TTL'd: a stale
+       * entry is reaped before insert, and at capacity the oldest entry is dropped
+       * to make room (fail-closed — an unanswered old question is forgotten rather
+       * than letting the map grow unbounded).
+       */
+      registerOutstandingQuestion(qid, chatId, questions) {
+        const now = Date.now();
+        this.evictOutstandingQuestions(now);
+        if (!this.outstandingQuestions.has(qid) && this.outstandingQuestions.size >= _BridgeHub.MAX_OUTSTANDING_QUESTIONS) {
+          let oldestKey = null;
+          let oldest = Infinity;
+          for (const [k, v] of this.outstandingQuestions) {
+            if (v.at < oldest) {
+              oldest = v.at;
+              oldestKey = k;
+            }
+          }
+          if (oldestKey !== null) this.outstandingQuestions.delete(oldestKey);
+        }
+        this.outstandingQuestions.set(qid, { chatId, questions, at: now });
+      }
+      evictOutstandingQuestions(now) {
+        for (const [k, v] of this.outstandingQuestions) {
+          if (now - v.at > _BridgeHub.QUESTION_TTL_MS) this.outstandingQuestions.delete(k);
+        }
+      }
       // ── Mirror chat-id registry (SEPARATE from knownChatIds — P1#1/sonnet:f7) ──
       // Same bounded + TTL eviction discipline as knownChatIds, but a DISTINCT map:
       // mirrorChatIds gates emitMirror; knownChatIds gates emitReply. Keeping them
@@ -44816,7 +45300,6 @@ var init_api_bridge = __esm({
           if (oldestKey !== null) this.mirrorChatIds.delete(oldestKey);
         }
         this.mirrorChatIds.set(chatId, now);
-        this.latestMirrorChatId = chatId;
         if (isNew) this.backfillProvisional(chatId, now);
       }
       /**
@@ -44837,23 +45320,10 @@ var init_api_bridge = __esm({
         return this.mirrorChatIds.has(chatId);
       }
       evictMirrorChatIds(now) {
-        let evictedLatest = false;
         for (const [k, v] of this.mirrorChatIds) {
           if (now - v > _BridgeHub.CHAT_ID_TTL_MS) {
             this.mirrorChatIds.delete(k);
-            if (k === this.latestMirrorChatId) evictedLatest = true;
-          }
-        }
-        if (evictedLatest) {
-          let newestKey = null;
-          let newest = -Infinity;
-          for (const [k, v] of this.mirrorChatIds) {
-            if (v > newest) {
-              newest = v;
-              newestKey = k;
-            }
           }
-          this.latestMirrorChatId = newestKey;
         }
       }
       /**
@@ -45082,15 +45552,15 @@ function normalizeLegacyDegradedFields(report) {
 }
 function resolveDashboardRoot(projectRoot) {
   const candidates = [
-    (0, import_path78.resolve)(__dirname, "..", "dist-dashboard"),
+    (0, import_path79.resolve)(__dirname, "..", "dist-dashboard"),
     // bundled: dist-mcp/mcp-server.js → ../dist-dashboard
-    (0, import_path78.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
+    (0, import_path79.resolve)(__dirname, "..", "..", "..", "..", "dist-dashboard"),
     // tsc dev: packages/relay/dist/dashboard → repo-root
-    (0, import_path78.join)(projectRoot, "dist-dashboard")
+    (0, import_path79.join)(projectRoot, "dist-dashboard")
     // legacy dev fallback (git-clone running from repo root)
   ];
   for (const p of candidates) {
-    if ((0, import_fs70.existsSync)(p)) return p;
+    if ((0, import_fs71.existsSync)(p)) return p;
   }
   return null;
 }
@@ -45117,7 +45587,7 @@ function readBody(req, maxBytes = MAX_BODY_SIZE) {
     });
   });
 }
-var import_fs70, import_path78, import_crypto28, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, AUTH_ATTEMPT_TTL_MS, AUTH_ATTEMPTS_HARD_CAP, CHAT_MAX_BODY, BRIDGE_MAX_BODY, MIRROR_MAX_BODY, MIRROR_MIN_INTERVAL_MS, MIRROR_LAST_TURN_HARD_CAP, CHAT_MIN_INTERVAL_MS, DashboardRouter, MAX_BODY_SIZE;
+var import_fs71, import_path79, import_crypto28, AUTH_MAX_ATTEMPTS, AUTH_LOCKOUT_MS, AUTH_ATTEMPT_TTL_MS, AUTH_ATTEMPTS_HARD_CAP, CHAT_MAX_BODY, BRIDGE_MAX_BODY, MIRROR_MAX_BODY, MIRROR_MIN_INTERVAL_MS, MIRROR_LAST_TURN_HARD_CAP, CHAT_MIN_INTERVAL_MS, DashboardRouter, MAX_BODY_SIZE;
 var init_routes = __esm({
   "packages/relay/src/dashboard/routes.ts"() {
     "use strict";
@@ -45145,8 +45615,8 @@ var init_routes = __esm({
     init_api_bridge();
     init_chat_session_store();
     init_src4();
-    import_fs70 = require("fs");
-    import_path78 = require("path");
+    import_fs71 = require("fs");
+    import_path79 = require("path");
     import_crypto28 = require("crypto");
     AUTH_MAX_ATTEMPTS = 10;
     AUTH_LOCKOUT_MS = 6e4;
@@ -45164,6 +45634,7 @@ var init_routes = __esm({
         this.projectRoot = projectRoot;
         this.ctx = ctx2;
         this.dashboardRoot = resolveDashboardRoot(projectRoot);
+        this.bridge = new BridgeHub({ chatDir: (0, import_path79.join)(projectRoot, ".gossip", "chat") });
       }
       auth;
       projectRoot;
@@ -45185,7 +45656,9 @@ var init_routes = __esm({
       // Dashboard ⇄ live-CC bridge transport (P1). Owns the outbound SSE client set
       // and the in-process inbound sink the MCP server registers. Distinct from the
       // dormant chatbot (consensus f14 — no dual-brain; /api/chat stays dormant).
-      bridge = new BridgeHub();
+      // Constructed in the constructor body (not as a field initializer) so it can
+      // receive the chatDir option derived from projectRoot.
+      bridge;
       /**
        * Inject (or clear) the read-only chatbot agent. Called by the app layer
        * after boot via RelayServer.setChatbot. Passing null disables chat with a
@@ -45213,6 +45686,16 @@ var init_routes = __esm({
       emitBridgeReply(chatId, text) {
         return this.bridge.emitReply(chatId, text);
       }
+      /**
+       * Ask the dashboard a structured selection question (MCP `gossip_ask` tool).
+       * The hub gates chat_id on knownChatIds exactly like emitReply, registers the
+       * validated question set under `qid`, and fans out a `question` frame. Returns
+       * false when the id was unbound/malformed or no SSE client is connected so the
+       * caller can no-op honestly.
+       */
+      emitBridgeQuestion(chatId, qid, questions) {
+        return this.bridge.emitQuestion(chatId, qid, questions);
+      }
       /** Update live context (call when agents connect/disconnect) */
       updateContext(ctx2) {
         if (ctx2.agentConfigs !== void 0) this.ctx.agentConfigs = ctx2.agentConfigs;
@@ -45609,7 +46092,8 @@ var init_routes = __esm({
               this.json(res, 400, { error: "Invalid JSON body" });
               return true;
             }
-            const { status, payload } = this.bridge.handlePost(body);
+            const hasAnswer = body !== null && typeof body === "object" && "answer" in body;
+            const { status, payload } = hasAnswer ? this.bridge.handleAnswer(body) : this.bridge.handlePost(body);
             this.json(res, status, payload);
             return true;
           }
@@ -45663,14 +46147,17 @@ var init_routes = __esm({
           res.end("Dashboard assets not found. Reinstall gossipcat or rebuild from source.");
           return true;
         }
-        const htmlPath = (0, import_path78.join)(this.dashboardRoot, "index.html");
-        if (!(0, import_fs70.existsSync)(htmlPath)) {
+        const htmlPath = (0, import_path79.join)(this.dashboardRoot, "index.html");
+        if (!(0, import_fs71.existsSync)(htmlPath)) {
           res.writeHead(503, { "Content-Type": "text/plain" });
           res.end(`Dashboard index.html missing at ${this.dashboardRoot}. Reinstall gossipcat.`);
           return true;
         }
-        const html = (0, import_fs70.readFileSync)(htmlPath, "utf-8");
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        const html = (0, import_fs71.readFileSync)(htmlPath, "utf-8");
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-cache"
+        });
         res.end(html);
         return true;
       }
@@ -45695,16 +46182,16 @@ var init_routes = __esm({
         const ext = "." + (relativePath.split(".").pop() || "");
         const mime = MIME[ext];
         if (!mime) return false;
-        const filePath = (0, import_path78.join)(this.dashboardRoot, relativePath);
+        const filePath = (0, import_path79.join)(this.dashboardRoot, relativePath);
         try {
-          const realFile = (0, import_fs70.realpathSync)(filePath);
-          const realBase = (0, import_fs70.realpathSync)(this.dashboardRoot);
+          const realFile = (0, import_fs71.realpathSync)(filePath);
+          const realBase = (0, import_fs71.realpathSync)(this.dashboardRoot);
           if (!realFile.startsWith(realBase + "/")) {
             res.writeHead(404);
             res.end();
             return true;
           }
-          const data = (0, import_fs70.readFileSync)(realFile);
+          const data = (0, import_fs71.readFileSync)(realFile);
           res.writeHead(200, { "Content-Type": mime, "Cache-Control": "public, max-age=86400" });
           res.end(data);
           return true;
@@ -45719,8 +46206,8 @@ var init_routes = __esm({
         return match ? match[1] : null;
       }
       getConsensusReports(page = 1, pageSize = 5) {
-        const { readdirSync: readdirSync22, readFileSync: readFileSync68, existsSync: existsSync73 } = require("fs");
-        const reportsDir = (0, import_path78.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const { readdirSync: readdirSync22, readFileSync: readFileSync69, existsSync: existsSync73 } = require("fs");
+        const reportsDir = (0, import_path79.join)(this.projectRoot, ".gossip", "consensus-reports");
         let retractedConsensusIds = [];
         let roundRetractions = [];
         try {
@@ -45735,8 +46222,8 @@ var init_routes = __esm({
           const { statSync: statSync36 } = require("fs");
           const allFiles = readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).sort((a, b) => {
             try {
-              const aTime = statSync36((0, import_path78.join)(reportsDir, a)).mtimeMs;
-              const bTime = statSync36((0, import_path78.join)(reportsDir, b)).mtimeMs;
+              const aTime = statSync36((0, import_path79.join)(reportsDir, a)).mtimeMs;
+              const bTime = statSync36((0, import_path79.join)(reportsDir, b)).mtimeMs;
               return bTime - aTime;
             } catch {
               return 0;
@@ -45747,13 +46234,13 @@ var init_routes = __esm({
           const clampedPage = Math.max(page, 1);
           const start = (clampedPage - 1) * clampedPageSize;
           const files = allFiles.slice(start, start + clampedPageSize);
-          const realReportsDir = (0, import_fs70.realpathSync)(reportsDir);
+          const realReportsDir = (0, import_fs71.realpathSync)(reportsDir);
           const reports = files.map((f) => {
             try {
-              const filePath = (0, import_path78.join)(reportsDir, f);
-              const realFile = (0, import_fs70.realpathSync)(filePath);
+              const filePath = (0, import_path79.join)(reportsDir, f);
+              const realFile = (0, import_fs71.realpathSync)(filePath);
               if (!realFile.startsWith(realReportsDir + "/")) return null;
-              return normalizeLegacyDegradedFields(JSON.parse(readFileSync68(realFile, "utf-8")));
+              return normalizeLegacyDegradedFields(JSON.parse(readFileSync69(realFile, "utf-8")));
             } catch {
               return null;
             }
@@ -45764,29 +46251,29 @@ var init_routes = __esm({
         }
       }
       archiveFindings() {
-        const { readdirSync: readdirSync22, readFileSync: readFileSync68, renameSync: renameSync17, writeFileSync: writeFileSync37, mkdirSync: mkdirSync44, existsSync: existsSync73 } = require("fs");
-        const reportsDir = (0, import_path78.join)(this.projectRoot, ".gossip", "consensus-reports");
-        const archiveDir = (0, import_path78.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
+        const { readdirSync: readdirSync22, readFileSync: readFileSync69, renameSync: renameSync18, writeFileSync: writeFileSync38, mkdirSync: mkdirSync45, existsSync: existsSync73 } = require("fs");
+        const reportsDir = (0, import_path79.join)(this.projectRoot, ".gossip", "consensus-reports");
+        const archiveDir = (0, import_path79.join)(this.projectRoot, ".gossip", "consensus-reports-archive");
         let archived = 0;
         if (existsSync73(reportsDir)) {
           const files = readdirSync22(reportsDir).filter((f) => f.endsWith(".json")).sort().reverse();
           if (files.length > 5) {
-            mkdirSync44(archiveDir, { recursive: true });
+            mkdirSync45(archiveDir, { recursive: true });
             const toArchive = files.slice(5);
             for (const f of toArchive) {
               try {
-                renameSync17((0, import_path78.join)(reportsDir, f), (0, import_path78.join)(archiveDir, f));
+                renameSync18((0, import_path79.join)(reportsDir, f), (0, import_path79.join)(archiveDir, f));
                 archived++;
               } catch {
               }
             }
           }
         }
-        const findingsPath = (0, import_path78.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
+        const findingsPath = (0, import_path79.join)(this.projectRoot, ".gossip", "implementation-findings.jsonl");
         let findingsCleared = 0;
         if (existsSync73(findingsPath)) {
           try {
-            const lines = readFileSync68(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
+            const lines = readFileSync69(findingsPath, "utf-8").trim().split("\n").filter(Boolean);
             const kept = lines.filter((line) => {
               try {
                 const entry = JSON.parse(line);
@@ -45799,7 +46286,7 @@ var init_routes = __esm({
                 return true;
               }
             });
-            writeFileSync37(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
+            writeFileSync38(findingsPath, kept.join("\n") + (kept.length > 0 ? "\n" : ""));
           } catch {
           }
         }
@@ -45816,14 +46303,14 @@ var init_routes = __esm({
 });
 
 // packages/relay/src/dashboard/ws.ts
-var import_fs71, import_fs72, import_path79, DashboardWs;
+var import_fs72, import_fs73, import_path80, DashboardWs;
 var init_ws = __esm({
   "packages/relay/src/dashboard/ws.ts"() {
     "use strict";
     init_wrapper();
-    import_fs71 = require("fs");
     import_fs72 = require("fs");
-    import_path79 = require("path");
+    import_fs73 = require("fs");
+    import_path80 = require("path");
     DashboardWs = class {
       clients = /* @__PURE__ */ new Set();
       logWatcher = null;
@@ -45848,15 +46335,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_path79.join)(projectRoot, ".gossip", "mcp.log");
-        if (!(0, import_fs71.existsSync)(this.logPath)) return;
+        this.logPath = (0, import_path80.join)(projectRoot, ".gossip", "mcp.log");
+        if (!(0, import_fs72.existsSync)(this.logPath)) return;
         try {
-          this.logOffset = (0, import_fs71.statSync)(this.logPath).size;
+          this.logOffset = (0, import_fs72.statSync)(this.logPath).size;
         } catch {
           this.logOffset = 0;
         }
         try {
-          this.logWatcher = (0, import_fs72.watch)(this.logPath, () => {
+          this.logWatcher = (0, import_fs73.watch)(this.logPath, () => {
             if (this.clients.size === 0) return;
             this.readNewLines();
           });
@@ -45873,7 +46360,7 @@ var init_ws = __esm({
         if (this.logReading) return;
         this.logReading = true;
         try {
-          const currentSize = (0, import_fs71.statSync)(this.logPath).size;
+          const currentSize = (0, import_fs72.statSync)(this.logPath).size;
           if (currentSize < this.logOffset) {
             this.logOffset = 0;
             this.logCarry = "";
@@ -45886,7 +46373,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_fs71.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
+            stream = (0, import_fs72.createReadStream)(this.logPath, { start: readFrom, end: currentSize - 1 });
           } catch {
             this.logReading = false;
             return;
@@ -46346,6 +46833,19 @@ var init_server = __esm({
       emitBridgeReply(chatId, text) {
         return this.dashboardRouter?.emitBridgeReply(chatId, text) ?? false;
       }
+      /**
+       * Ask the dashboard a structured selection question (MCP `gossip_ask` tool).
+       * Mirrors emitBridgeReply: chat_id is re-validated + bound to a stream the
+       * dashboard actually opened (the same knownChatIds gate as emitReply), the
+       * validated question set is registered under `qid` so a later inbound answer
+       * can be validated against what was asked, and a `question` frame fans out
+       * over SSE. Returns false (no registration, no broadcast) when the dashboard
+       * is disabled, the chat_id is unbound/malformed, or no SSE client is connected
+       * — so the caller can no-op honestly rather than claim a delivery.
+       */
+      emitBridgeQuestion(chatId, qid, questions) {
+        return this.dashboardRouter?.emitBridgeQuestion(chatId, qid, questions) ?? false;
+      }
     };
   }
 });
@@ -46381,7 +46881,8 @@ __export(src_exports4, {
   emitDashboardEvent: () => emitDashboardEvent,
   hasMemoryQuery: () => hasMemoryQuery,
   recordMemoryQueryAttribution: () => recordMemoryQueryAttribution,
-  sweepExpiredAgents: () => sweepExpiredAgents
+  sweepExpiredAgents: () => sweepExpiredAgents,
+  validateAskQuestions: () => validateAskQuestions
 });
 var init_src5 = __esm({
   "packages/relay/src/index.ts"() {
@@ -46720,14 +47221,14 @@ __export(sandbox_exports, {
 });
 function rotateIfNeeded2(filePath, maxBytes) {
   try {
-    const st = (0, import_fs73.statSync)(filePath);
+    const st = (0, import_fs74.statSync)(filePath);
     if (st.size < maxBytes) return;
     const rotated = filePath + ".1";
     try {
-      if ((0, import_fs73.existsSync)(rotated)) (0, import_fs73.unlinkSync)(rotated);
+      if ((0, import_fs74.existsSync)(rotated)) (0, import_fs74.unlinkSync)(rotated);
     } catch {
     }
-    (0, import_fs73.renameSync)(filePath, rotated);
+    (0, import_fs74.renameSync)(filePath, rotated);
   } catch {
   }
 }
@@ -46800,9 +47301,9 @@ Tests passing is NOT sufficient verification \u2014 the 2026-04-22 incident had
 }
 function readSandboxMode(projectRoot) {
   try {
-    const p = (0, import_path80.join)(projectRoot, ".gossip", "config.json");
-    if (!(0, import_fs73.existsSync)(p)) return "warn";
-    const raw = JSON.parse((0, import_fs73.readFileSync)(p, "utf-8"));
+    const p = (0, import_path81.join)(projectRoot, ".gossip", "config.json");
+    if (!(0, import_fs74.existsSync)(p)) return "warn";
+    const raw = JSON.parse((0, import_fs74.readFileSync)(p, "utf-8"));
     const mode = raw?.sandboxEnforcement;
     if (mode === "off" || mode === "warn" || mode === "block") return mode;
     return "warn";
@@ -46812,8 +47313,8 @@ function readSandboxMode(projectRoot) {
 }
 function recordDispatchMetadata(projectRoot, meta3) {
   try {
-    const dir = (0, import_path80.join)(projectRoot, ".gossip");
-    (0, import_fs73.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path81.join)(projectRoot, ".gossip");
+    (0, import_fs74.mkdirSync)(dir, { recursive: true });
     const snapshotted = { ...meta3 };
     if (meta3.writeMode === "scoped" || meta3.writeMode === "worktree") {
       try {
@@ -46831,15 +47332,15 @@ function recordDispatchMetadata(projectRoot, meta3) {
       } catch {
       }
     }
-    (0, import_fs73.appendFileSync)((0, import_path80.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
+    (0, import_fs74.appendFileSync)((0, import_path81.join)(dir, METADATA_FILE), JSON.stringify(snapshotted) + "\n");
   } catch {
   }
 }
 function updateDispatchMetadata(projectRoot, taskId, patch) {
   try {
-    const p = (0, import_path80.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs73.existsSync)(p)) return false;
-    const raw = (0, import_fs73.readFileSync)(p, "utf-8");
+    const p = (0, import_path81.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs74.existsSync)(p)) return false;
+    const raw = (0, import_fs74.readFileSync)(p, "utf-8");
     const lines = raw.split("\n");
     let patched = false;
     for (let i = lines.length - 1; i >= 0; i--) {
@@ -46857,7 +47358,7 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
       }
     }
     if (!patched) return false;
-    (0, import_fs73.writeFileSync)(p, lines.join("\n"));
+    (0, import_fs74.writeFileSync)(p, lines.join("\n"));
     return true;
   } catch {
     return false;
@@ -46866,14 +47367,14 @@ function updateDispatchMetadata(projectRoot, taskId, patch) {
 function stampTaskSentinel(projectRoot, taskId) {
   if (!taskId) return null;
   try {
-    const dir = (0, import_path80.join)(projectRoot, ".gossip", SENTINEL_DIR);
-    (0, import_fs73.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path81.join)(projectRoot, ".gossip", SENTINEL_DIR);
+    (0, import_fs74.mkdirSync)(dir, { recursive: true });
     const slug = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const path7 = (0, import_path80.join)(dir, `${slug}.sentinel`);
-    const fd = (0, import_fs73.openSync)(path7, "w");
-    (0, import_fs73.closeSync)(fd);
+    const path7 = (0, import_path81.join)(dir, `${slug}.sentinel`);
+    const fd = (0, import_fs74.openSync)(path7, "w");
+    (0, import_fs74.closeSync)(fd);
     const stampTime = new Date(Date.now() - 2e3);
-    (0, import_fs73.utimesSync)(path7, stampTime, stampTime);
+    (0, import_fs74.utimesSync)(path7, stampTime, stampTime);
     return path7;
   } catch {
     return null;
@@ -46882,15 +47383,15 @@ function stampTaskSentinel(projectRoot, taskId) {
 function cleanupTaskSentinel(sentinelPath) {
   if (!sentinelPath) return;
   try {
-    (0, import_fs73.unlinkSync)(sentinelPath);
+    (0, import_fs74.unlinkSync)(sentinelPath);
   } catch {
   }
 }
 function lookupDispatchMetadata(projectRoot, taskId) {
   try {
-    const p = (0, import_path80.join)(projectRoot, ".gossip", METADATA_FILE);
-    if (!(0, import_fs73.existsSync)(p)) return null;
-    const raw = (0, import_fs73.readFileSync)(p, "utf-8");
+    const p = (0, import_path81.join)(projectRoot, ".gossip", METADATA_FILE);
+    if (!(0, import_fs74.existsSync)(p)) return null;
+    const raw = (0, import_fs74.readFileSync)(p, "utf-8");
     const lines = raw.split("\n").filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i--) {
       try {
@@ -46922,21 +47423,21 @@ function parseGitStatus(porcelain) {
 function normalizeScope(scope, projectRoot) {
   let s = scope.trim();
   if (!s) return "";
-  if ((0, import_path80.isAbsolute)(s)) {
-    s = (0, import_path80.relative)(projectRoot, s);
+  if ((0, import_path81.isAbsolute)(s)) {
+    s = (0, import_path81.relative)(projectRoot, s);
   } else if (s.startsWith("./")) {
     s = s.slice(2);
   }
-  s = (0, import_path80.normalize)(s).replace(/\/+$/, "");
+  s = (0, import_path81.normalize)(s).replace(/\/+$/, "");
   if (s === "." || s === "") return "";
   return s;
 }
 function isInsideScope(filePath, scope) {
   if (!scope) return true;
-  const f = (0, import_path80.normalize)(filePath).replace(/^\.\//, "");
+  const f = (0, import_path81.normalize)(filePath).replace(/^\.\//, "");
   const s = scope.replace(/^\.\//, "").replace(/\/+$/, "");
   if (f === s) return true;
-  return f.startsWith(s + "/") || f.startsWith(s + import_path80.sep);
+  return f.startsWith(s + "/") || f.startsWith(s + import_path81.sep);
 }
 function detectBoundaryEscapes(meta3, modifiedFiles, projectRoot) {
   const mode = meta3.writeMode;
@@ -46997,8 +47498,8 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
   } catch {
   }
   try {
-    const dir = (0, import_path80.join)(projectRoot, ".gossip");
-    (0, import_fs73.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path81.join)(projectRoot, ".gossip");
+    (0, import_fs74.mkdirSync)(dir, { recursive: true });
     const line = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       taskId: meta3.taskId,
@@ -47009,15 +47510,15 @@ function recordBoundaryEscape(projectRoot, meta3, violations, mode) {
       action: mode
       // "warn" or "block"
     };
-    const escapeFile = (0, import_path80.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path81.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs73.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
+    (0, import_fs74.appendFileSync)(escapeFile, JSON.stringify(line) + "\n");
   } catch {
   }
 }
 function canonicalize(p) {
   try {
-    return (0, import_path80.resolve)(p).replace(/\/+$/, "") || "/";
+    return (0, import_path81.resolve)(p).replace(/\/+$/, "") || "/";
   } catch {
     return p.replace(/\/+$/, "") || "/";
   }
@@ -47128,7 +47629,7 @@ function buildAuditExclusions(projectRoot, ownWorktree, scope) {
     for (const v of expandTmpVariants(wt)) excl.add(v);
   }
   if (scope) {
-    const s = canonicalize((0, import_path80.join)(projectRoot, scope));
+    const s = canonicalize((0, import_path81.join)(projectRoot, scope));
     for (const v of expandTmpVariants(s)) excl.add(v);
   }
   return Array.from(excl);
@@ -47217,12 +47718,12 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
     return { violations: [], skipped: "win32" };
   }
   const sentinel = meta3.sentinelPath;
-  if (!sentinel || !(0, import_fs73.existsSync)(sentinel)) {
+  if (!sentinel || !(0, import_fs74.existsSync)(sentinel)) {
     return { violations: [], skipped: "sentinel missing" };
   }
   let sentinelMtimeMs = 0;
   try {
-    sentinelMtimeMs = (0, import_fs73.statSync)(sentinel).mtimeMs;
+    sentinelMtimeMs = (0, import_fs74.statSync)(sentinel).mtimeMs;
   } catch {
   }
   if (sentinelMtimeMs === 0) {
@@ -47234,11 +47735,11 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   );
   const exclusions = buildAuditExclusions(projectRoot, meta3.worktreePath, options.scope);
   const findBin = options.findBinary ?? "find";
-  const sentinelDir = canonicalize((0, import_path80.join)(projectRoot, ".gossip", SENTINEL_DIR));
+  const sentinelDir = canonicalize((0, import_path81.join)(projectRoot, ".gossip", SENTINEL_DIR));
   const mainSet = /* @__PURE__ */ new Set();
   const sensitiveSet = /* @__PURE__ */ new Set();
   for (const root of scanRoots) {
-    if (!(0, import_fs73.existsSync)(root)) continue;
+    if (!(0, import_fs74.existsSync)(root)) continue;
     const canonRoot = canonicalize(root);
     const allExcl = [...exclusions, ...expandTmpVariants(sentinelDir)];
     const args = buildFindPruneArgs(canonRoot, allExcl, sentinel);
@@ -47274,7 +47775,7 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
   }
   const sensitiveTargets = buildSensitiveTargets(platform2);
   for (const target of sensitiveTargets) {
-    if (!(0, import_fs73.existsSync)(target.path)) continue;
+    if (!(0, import_fs74.existsSync)(target.path)) continue;
     const canonTarget = canonicalize(target.path);
     const args = buildSensitiveFindArgs(
       canonTarget,
@@ -47348,8 +47849,8 @@ function auditFilesystemSinceSentinel(projectRoot, meta3, options = {}) {
 }
 function recordLayer3Violations(projectRoot, meta3, violations, source) {
   try {
-    const dir = (0, import_path80.join)(projectRoot, ".gossip");
-    (0, import_fs73.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_path81.join)(projectRoot, ".gossip");
+    (0, import_fs74.mkdirSync)(dir, { recursive: true });
     const ts2 = (/* @__PURE__ */ new Date()).toISOString();
     const lines = violations.map(
       (path7) => JSON.stringify({
@@ -47360,9 +47861,9 @@ function recordLayer3Violations(projectRoot, meta3, violations, source) {
         source
       })
     );
-    const escapeFile = (0, import_path80.join)(dir, BOUNDARY_ESCAPE_FILE);
+    const escapeFile = (0, import_path81.join)(dir, BOUNDARY_ESCAPE_FILE);
     rotateIfNeeded2(escapeFile, MAX_BOUNDARY_ESCAPE_BYTES);
-    (0, import_fs73.appendFileSync)(escapeFile, lines.join("\n") + "\n");
+    (0, import_fs74.appendFileSync)(escapeFile, lines.join("\n") + "\n");
   } catch {
   }
   if (source === "layer3-sensitive" && violations.length > 0) {
@@ -47419,14 +47920,14 @@ function runLayer3Audit(projectRoot, taskId) {
   }
   return { blockError, warnPrefix };
 }
-var import_child_process12, import_fs73, import_os5, import_path80, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SENTINEL_DIR, MAX_BOUNDARY_ESCAPE_BYTES, MAX_PREMISE_VERIFICATION_BYTES, BOUNDARY_ALLOWLIST, SYSTEM_PREFIXES, SCOPE_NOTE, NUMERAL, TARGETS, MODIFIER, CLAIM_PATTERNS, UNVERIFIED_NOTE_SENTINEL, LAYER3_KEEP_TMPDIR_PREFIXES, __test__;
+var import_child_process12, import_fs74, import_os5, import_path81, METADATA_FILE, BOUNDARY_ESCAPE_FILE, SENTINEL_DIR, MAX_BOUNDARY_ESCAPE_BYTES, MAX_PREMISE_VERIFICATION_BYTES, BOUNDARY_ALLOWLIST, SYSTEM_PREFIXES, SCOPE_NOTE, NUMERAL, TARGETS, MODIFIER, CLAIM_PATTERNS, UNVERIFIED_NOTE_SENTINEL, LAYER3_KEEP_TMPDIR_PREFIXES, __test__;
 var init_sandbox2 = __esm({
   "apps/cli/src/sandbox.ts"() {
     "use strict";
     import_child_process12 = require("child_process");
-    import_fs73 = require("fs");
+    import_fs74 = require("fs");
     import_os5 = require("os");
-    import_path80 = require("path");
+    import_path81 = require("path");
     METADATA_FILE = "dispatch-metadata.jsonl";
     BOUNDARY_ESCAPE_FILE = "boundary-escapes.jsonl";
     SENTINEL_DIR = "sentinels";
@@ -47498,7 +47999,7 @@ __export(dispatch_prompt_storage_exports, {
   writeDispatchPrompt: () => writeDispatchPrompt
 });
 function dispatchPromptsDir(projectRoot) {
-  return (0, import_path81.join)(projectRoot, ".gossip", DISPATCH_PROMPTS_SUBDIR);
+  return (0, import_path82.join)(projectRoot, ".gossip", DISPATCH_PROMPTS_SUBDIR);
 }
 function assertSafeTaskId(taskId) {
   if (typeof taskId !== "string" || taskId.length === 0) {
@@ -47511,35 +48012,35 @@ function assertSafeTaskId(taskId) {
 function writeDispatchPrompt(projectRoot, taskId, body) {
   assertSafeTaskId(taskId);
   const dir = dispatchPromptsDir(projectRoot);
-  (0, import_fs74.mkdirSync)(dir, { recursive: true });
-  const finalPath = (0, import_path81.join)(dir, `${taskId}.txt`);
-  const tmpPath = (0, import_path81.join)(dir, `${taskId}.txt.${(0, import_crypto30.randomUUID)().slice(0, 8)}.tmp`);
+  (0, import_fs75.mkdirSync)(dir, { recursive: true });
+  const finalPath = (0, import_path82.join)(dir, `${taskId}.txt`);
+  const tmpPath = (0, import_path82.join)(dir, `${taskId}.txt.${(0, import_crypto30.randomUUID)().slice(0, 8)}.tmp`);
   try {
-    (0, import_fs74.writeFileSync)(tmpPath, body, "utf8");
-    (0, import_fs74.renameSync)(tmpPath, finalPath);
+    (0, import_fs75.writeFileSync)(tmpPath, body, "utf8");
+    (0, import_fs75.renameSync)(tmpPath, finalPath);
   } catch (err) {
     try {
-      (0, import_fs74.unlinkSync)(tmpPath);
+      (0, import_fs75.unlinkSync)(tmpPath);
     } catch {
     }
     throw err;
   }
-  return (0, import_path81.resolve)(finalPath);
+  return (0, import_path82.resolve)(finalPath);
 }
 function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TTL_MS, capBytes = DISPATCH_PROMPT_CAP_BYTES) {
   const dir = dispatchPromptsDir(projectRoot);
-  if (!(0, import_fs74.existsSync)(dir)) return { evictedAge: 0, evictedCap: 0 };
+  if (!(0, import_fs75.existsSync)(dir)) return { evictedAge: 0, evictedCap: 0 };
   const now = Date.now();
   let entries = [];
   try {
-    for (const name of (0, import_fs74.readdirSync)(dir)) {
-      const path7 = (0, import_path81.join)(dir, name);
+    for (const name of (0, import_fs75.readdirSync)(dir)) {
+      const path7 = (0, import_path82.join)(dir, name);
       try {
-        const st = (0, import_fs74.statSync)(path7);
+        const st = (0, import_fs75.statSync)(path7);
         if (!st.isFile()) continue;
         entries.push({ name, path: path7, mtimeMs: st.mtimeMs, size: st.size });
       } catch (err) {
-        process.stderr.write(`[gossipcat] dispatch-prompt stat failed for ${(0, import_path81.basename)(path7)}: ${err.message}
+        process.stderr.write(`[gossipcat] dispatch-prompt stat failed for ${(0, import_path82.basename)(path7)}: ${err.message}
 `);
       }
     }
@@ -47553,7 +48054,7 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
   for (const e of entries) {
     if (now - e.mtimeMs > maxAgeMs) {
       try {
-        (0, import_fs74.unlinkSync)(e.path);
+        (0, import_fs75.unlinkSync)(e.path);
         evictedAge++;
       } catch (err) {
         process.stderr.write(`[gossipcat] dispatch-prompt unlink failed for ${e.name}: ${err.message}
@@ -47570,7 +48071,7 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
     for (const e of survivors) {
       if (totalBytes <= capBytes) break;
       try {
-        (0, import_fs74.unlinkSync)(e.path);
+        (0, import_fs75.unlinkSync)(e.path);
         totalBytes -= e.size;
         evictedCap++;
       } catch (err) {
@@ -47583,18 +48084,18 @@ function cleanupExpiredDispatchPrompts(projectRoot, maxAgeMs = DEFAULT_PROMPT_TT
 }
 function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAULT_PROMPT_TTL_MS) {
   const dir = dispatchPromptsDir(projectRoot);
-  if (!(0, import_fs74.existsSync)(dir)) return { orphans: 0, aged: 0 };
+  if (!(0, import_fs75.existsSync)(dir)) return { orphans: 0, aged: 0 };
   const now = Date.now();
   let orphans = 0;
   let aged = 0;
   try {
-    for (const name of (0, import_fs74.readdirSync)(dir)) {
+    for (const name of (0, import_fs75.readdirSync)(dir)) {
       if (!name.endsWith(".txt")) continue;
       const taskId = name.slice(0, -4);
-      const path7 = (0, import_path81.join)(dir, name);
+      const path7 = (0, import_path82.join)(dir, name);
       let mtimeMs = 0;
       try {
-        mtimeMs = (0, import_fs74.statSync)(path7).mtimeMs;
+        mtimeMs = (0, import_fs75.statSync)(path7).mtimeMs;
       } catch {
         continue;
       }
@@ -47602,7 +48103,7 @@ function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAUL
       const orphaned = !knownTaskIds.has(taskId);
       if (tooOld || orphaned) {
         try {
-          (0, import_fs74.unlinkSync)(path7);
+          (0, import_fs75.unlinkSync)(path7);
           if (orphaned) orphans++;
           if (tooOld) aged++;
         } catch (err) {
@@ -47619,14 +48120,14 @@ function pruneOrphanDispatchPrompts(projectRoot, knownTaskIds, maxAgeMs = DEFAUL
 }
 function dispatchPromptPath(projectRoot, taskId) {
   assertSafeTaskId(taskId);
-  return (0, import_path81.resolve)((0, import_path81.join)(dispatchPromptsDir(projectRoot), `${taskId}.txt`));
+  return (0, import_path82.resolve)((0, import_path82.join)(dispatchPromptsDir(projectRoot), `${taskId}.txt`));
 }
-var import_fs74, import_path81, import_crypto30, SAFE_TASK_ID2, DISPATCH_PROMPT_CAP_BYTES, DEFAULT_PROMPT_TTL_MS, DISPATCH_PROMPTS_SUBDIR;
+var import_fs75, import_path82, import_crypto30, SAFE_TASK_ID2, DISPATCH_PROMPT_CAP_BYTES, DEFAULT_PROMPT_TTL_MS, DISPATCH_PROMPTS_SUBDIR;
 var init_dispatch_prompt_storage = __esm({
   "apps/cli/src/handlers/dispatch-prompt-storage.ts"() {
     "use strict";
-    import_fs74 = require("fs");
-    import_path81 = require("path");
+    import_fs75 = require("fs");
+    import_path82 = require("path");
     import_crypto30 = require("crypto");
     SAFE_TASK_ID2 = /^(?!.*\.\.)[A-Za-z0-9._-]{1,64}$/;
     DISPATCH_PROMPT_CAP_BYTES = 100 * 1024 * 1024;
@@ -47680,9 +48181,9 @@ function getCommitRange(preSha, postSha) {
 function appendViolationRecord(record2) {
   try {
     const projectRoot = process.cwd();
-    (0, import_fs75.mkdirSync)((0, import_path82.join)(projectRoot, ".gossip"), { recursive: true });
-    const logPath = (0, import_path82.join)(projectRoot, PROCESS_VIOLATIONS_FILE);
-    (0, import_fs75.appendFileSync)(logPath, JSON.stringify(record2) + "\n", "utf8");
+    (0, import_fs76.mkdirSync)((0, import_path83.join)(projectRoot, ".gossip"), { recursive: true });
+    const logPath = (0, import_path83.join)(projectRoot, PROCESS_VIOLATIONS_FILE);
+    (0, import_fs76.appendFileSync)(logPath, JSON.stringify(record2) + "\n", "utf8");
   } catch (err) {
     process.stderr.write(`[gossipcat] ref-allowlist: failed to append violation record: ${err.message}
 `);
@@ -47732,12 +48233,12 @@ Full audit trail at .gossip/process-violations.jsonl
 `
   );
 }
-var import_fs75, import_path82, import_child_process13, PROCESS_VIOLATIONS_FILE;
+var import_fs76, import_path83, import_child_process13, PROCESS_VIOLATIONS_FILE;
 var init_ref_allowlist_detection = __esm({
   "apps/cli/src/handlers/ref-allowlist-detection.ts"() {
     "use strict";
-    import_fs75 = require("fs");
-    import_path82 = require("path");
+    import_fs76 = require("fs");
+    import_path83 = require("path");
     import_child_process13 = require("child_process");
     PROCESS_VIOLATIONS_FILE = ".gossip/process-violations.jsonl";
   }
@@ -47772,12 +48273,12 @@ async function synthesizeTimeoutRound(snapshot, consensusId, missingAgents, llm,
     snapshot.relayCrossReviewSkipped
   );
   try {
-    const { writeFileSync: writeFileSync37, mkdirSync: mkdirSync44 } = require("fs");
-    const { join: join90 } = require("path");
-    const reportsDir = join90(projectRoot, ".gossip", "consensus-reports");
-    mkdirSync44(reportsDir, { recursive: true });
+    const { writeFileSync: writeFileSync38, mkdirSync: mkdirSync45 } = require("fs");
+    const { join: join91 } = require("path");
+    const reportsDir = join91(projectRoot, ".gossip", "consensus-reports");
+    mkdirSync45(reportsDir, { recursive: true });
     const topic = snapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
-    writeFileSync37(join90(reportsDir, `${consensusId}.json`), JSON.stringify({
+    writeFileSync38(join91(reportsDir, `${consensusId}.json`), JSON.stringify({
       id: consensusId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       topic,
@@ -47995,13 +48496,13 @@ async function handleRelayCrossReview(consensus_id, agent_id, result) {
       synthSnapshot.relayCrossReviewSkipped
     );
     try {
-      const { writeFileSync: writeFileSync37, mkdirSync: mkdirSync44 } = require("fs");
-      const { join: join90 } = require("path");
-      const reportsDir = join90(process.cwd(), ".gossip", "consensus-reports");
-      mkdirSync44(reportsDir, { recursive: true });
-      const reportPath = join90(reportsDir, `${consensus_id}.json`);
+      const { writeFileSync: writeFileSync38, mkdirSync: mkdirSync45 } = require("fs");
+      const { join: join91 } = require("path");
+      const reportsDir = join91(process.cwd(), ".gossip", "consensus-reports");
+      mkdirSync45(reportsDir, { recursive: true });
+      const reportPath = join91(reportsDir, `${consensus_id}.json`);
       const topic = synthSnapshot.allResults?.find((r) => r.task)?.task?.slice(0, 500) || "";
-      writeFileSync37(reportPath, JSON.stringify({
+      writeFileSync38(reportPath, JSON.stringify({
         id: consensus_id,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         topic,
@@ -48098,10 +48599,10 @@ function persistPendingConsensus() {
   try {
     const projectRoot = ctx.mainAgent?.projectRoot;
     if (!projectRoot) return;
-    const { writeFileSync: writeFileSync37, mkdirSync: mkdirSync44 } = require("fs");
-    const { join: join90 } = require("path");
-    const dir = join90(projectRoot, ".gossip");
-    mkdirSync44(dir, { recursive: true });
+    const { writeFileSync: writeFileSync38, mkdirSync: mkdirSync45 } = require("fs");
+    const { join: join91 } = require("path");
+    const dir = join91(projectRoot, ".gossip");
+    mkdirSync45(dir, { recursive: true });
     const rounds = {};
     for (const [id, round] of ctx.pendingConsensusRounds) {
       rounds[id] = {
@@ -48135,7 +48636,7 @@ function persistPendingConsensus() {
         } : void 0
       };
     }
-    writeFileSync37(join90(dir, CONSENSUS_FILE), JSON.stringify(rounds));
+    writeFileSync38(join91(dir, CONSENSUS_FILE), JSON.stringify(rounds));
   } catch (err) {
     process.stderr.write(`[gossipcat] persistPendingConsensus failed: ${err.message}
 `);
@@ -48143,11 +48644,11 @@ function persistPendingConsensus() {
 }
 function restorePendingConsensus(projectRoot) {
   try {
-    const { existsSync: existsSync73, readFileSync: readFileSync68, unlinkSync: unlinkSync15 } = require("fs");
-    const { join: join90 } = require("path");
-    const filePath = join90(projectRoot, ".gossip", CONSENSUS_FILE);
+    const { existsSync: existsSync73, readFileSync: readFileSync69, unlinkSync: unlinkSync16 } = require("fs");
+    const { join: join91 } = require("path");
+    const filePath = join91(projectRoot, ".gossip", CONSENSUS_FILE);
     if (!existsSync73(filePath)) return;
-    const raw = JSON.parse(readFileSync68(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync69(filePath, "utf-8"));
     const now = Date.now();
     for (const [id, data] of Object.entries(raw)) {
       if (now > data.deadline + 3e5) {
@@ -48184,7 +48685,7 @@ function restorePendingConsensus(projectRoot) {
       process.stderr.write(`[gossipcat] Restored consensus round ${id} \u2014 ${data.pendingNativeAgents?.length ?? 0} agents pending
 `);
     }
-    unlinkSync15(filePath);
+    unlinkSync16(filePath);
   } catch {
   }
 }
@@ -48277,11 +48778,11 @@ function taskWasInConsensusRound(taskId, agentId, rounds, recentTaskIds, recentA
 }
 function appendRelayWarning(projectRoot, entry) {
   try {
-    const { appendFileSync: appendFileSync21, mkdirSync: mkdirSync44 } = require("fs");
-    const { join: join90 } = require("path");
-    const dir = join90(projectRoot, ".gossip");
-    mkdirSync44(dir, { recursive: true });
-    appendFileSync21(join90(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
+    const { appendFileSync: appendFileSync22, mkdirSync: mkdirSync45 } = require("fs");
+    const { join: join91 } = require("path");
+    const dir = join91(projectRoot, ".gossip");
+    mkdirSync45(dir, { recursive: true });
+    appendFileSync22(join91(dir, RELAY_WARNINGS_FILE), JSON.stringify(entry) + "\n", "utf8");
   } catch (err) {
     process.stderr.write(`[gossipcat] append relay-warning failed: ${err.message}
 `);
@@ -48290,8 +48791,8 @@ function appendRelayWarning(projectRoot, entry) {
 function checkWorktreeEngaged(startedAt, projectRoot = process.cwd()) {
   try {
     const { readdirSync: readdirSync22, statSync: statSync36 } = require("fs");
-    const { join: join90 } = require("path");
-    const wtDir = join90(projectRoot, ".claude", "worktrees");
+    const { join: join91 } = require("path");
+    const wtDir = join91(projectRoot, ".claude", "worktrees");
     let entries;
     try {
       entries = readdirSync22(wtDir);
@@ -48302,7 +48803,7 @@ function checkWorktreeEngaged(startedAt, projectRoot = process.cwd()) {
     for (const entry of entries) {
       if (!entry.startsWith("agent-")) continue;
       try {
-        const st = statSync36(join90(wtDir, entry));
+        const st = statSync36(join91(wtDir, entry));
         if (st.isDirectory() && st.mtimeMs >= startedAt - 2e3) return true;
       } catch {
       }
@@ -49183,7 +49684,7 @@ function computeSkillFingerprint(paths) {
   const pairs = [];
   for (const p of paths) {
     try {
-      const st = (0, import_fs76.statSync)(p);
+      const st = (0, import_fs77.statSync)(p);
       pairs.push(`${p}:${st.mtimeMs}`);
     } catch {
     }
@@ -49218,7 +49719,7 @@ function setCachedPrompt(k, e) {
       const evicted = promptCache.get(oldestKey);
       promptCache.delete(oldestKey);
       try {
-        (0, import_fs76.unlinkSync)(evicted.skillsSectionPath);
+        (0, import_fs77.unlinkSync)(evicted.skillsSectionPath);
       } catch {
       }
       const evictedAgentId = oldestKey.split("|")[0] ?? "_system";
@@ -49232,7 +49733,7 @@ function invalidateAgent(agentId) {
     if (k.startsWith(`${agentId}|`)) {
       promptCache.delete(k);
       try {
-        (0, import_fs76.unlinkSync)(v.skillsSectionPath);
+        (0, import_fs77.unlinkSync)(v.skillsSectionPath);
       } catch {
       }
       emitCacheEvictedSignal(agentId, "invalidation");
@@ -49245,7 +49746,7 @@ function invalidateAll() {
   const n = promptCache.size;
   for (const v of promptCache.values()) {
     try {
-      (0, import_fs76.unlinkSync)(v.skillsSectionPath);
+      (0, import_fs77.unlinkSync)(v.skillsSectionPath);
     } catch {
     }
   }
@@ -49292,29 +49793,29 @@ function writeCachedSkillsSection(projectRoot, fingerprint2, skillsSection) {
   if (!/^[a-f0-9]{64}$/.test(fingerprint2)) {
     throw new Error(`writeCachedSkillsSection: invalid fingerprint ${JSON.stringify(fingerprint2).slice(0, 32)}`);
   }
-  const dir = (0, import_path83.join)(projectRoot, ".gossip", "dispatch-prompts", "cache");
-  (0, import_fs76.mkdirSync)(dir, { recursive: true });
-  const finalPath = (0, import_path83.join)(dir, `skills-${fingerprint2}.txt`);
-  const tmpPath = (0, import_path83.join)(dir, `skills-${fingerprint2}.txt.${(0, import_crypto33.randomUUID)().slice(0, 8)}.tmp`);
+  const dir = (0, import_path84.join)(projectRoot, ".gossip", "dispatch-prompts", "cache");
+  (0, import_fs77.mkdirSync)(dir, { recursive: true });
+  const finalPath = (0, import_path84.join)(dir, `skills-${fingerprint2}.txt`);
+  const tmpPath = (0, import_path84.join)(dir, `skills-${fingerprint2}.txt.${(0, import_crypto33.randomUUID)().slice(0, 8)}.tmp`);
   try {
-    (0, import_fs76.writeFileSync)(tmpPath, skillsSection, "utf8");
-    (0, import_fs76.renameSync)(tmpPath, finalPath);
+    (0, import_fs77.writeFileSync)(tmpPath, skillsSection, "utf8");
+    (0, import_fs77.renameSync)(tmpPath, finalPath);
   } catch (err) {
     try {
-      (0, import_fs76.unlinkSync)(tmpPath);
+      (0, import_fs77.unlinkSync)(tmpPath);
     } catch {
     }
     throw err;
   }
-  return (0, import_path83.resolve)(finalPath);
+  return (0, import_path84.resolve)(finalPath);
 }
-var import_crypto32, import_fs76, import_path83, import_crypto33, DISPATCH_PROMPT_CACHE_MAX_ENTRIES, promptCache;
+var import_crypto32, import_fs77, import_path84, import_crypto33, DISPATCH_PROMPT_CACHE_MAX_ENTRIES, promptCache;
 var init_dispatch_prompt_cache = __esm({
   "apps/cli/src/handlers/dispatch-prompt-cache.ts"() {
     "use strict";
     import_crypto32 = require("crypto");
-    import_fs76 = require("fs");
-    import_path83 = require("path");
+    import_fs77 = require("fs");
+    import_path84 = require("path");
     import_crypto33 = require("crypto");
     DISPATCH_PROMPT_CACHE_MAX_ENTRIES = 64;
     promptCache = /* @__PURE__ */ new Map();
@@ -49384,31 +49885,31 @@ __export(check_effectiveness_runner_exports, {
   runCheckEffectivenessForAllSkills: () => runCheckEffectivenessForAllSkills
 });
 function writeHealthAtomic(projectRoot, record2) {
-  const dir = (0, import_path85.join)(projectRoot, ".gossip");
-  const finalPath = (0, import_path85.join)(dir, "skill-runner-health.json");
+  const dir = (0, import_path86.join)(projectRoot, ".gossip");
+  const finalPath = (0, import_path86.join)(dir, "skill-runner-health.json");
   const tmpPath = finalPath + ".tmp";
   try {
-    (0, import_fs79.mkdirSync)(dir, { recursive: true });
-    (0, import_fs79.writeFileSync)(tmpPath, JSON.stringify(record2, null, 2));
-    (0, import_fs79.renameSync)(tmpPath, finalPath);
+    (0, import_fs80.mkdirSync)(dir, { recursive: true });
+    (0, import_fs80.writeFileSync)(tmpPath, JSON.stringify(record2, null, 2));
+    (0, import_fs80.renameSync)(tmpPath, finalPath);
   } catch (e) {
     process.stderr.write(`[gossipcat] checkEffectiveness: health write failed: ${e.message}
 `);
     try {
-      if ((0, import_fs79.existsSync)(tmpPath)) (0, import_fs79.unlinkSync)(tmpPath);
+      if ((0, import_fs80.existsSync)(tmpPath)) (0, import_fs80.unlinkSync)(tmpPath);
     } catch {
     }
   }
 }
 async function runCheckEffectivenessForAllSkills(opts) {
   const startedAt = Date.now();
-  const baseDir = (0, import_path85.join)(opts.projectRoot, ".gossip", "agents");
+  const baseDir = (0, import_path86.join)(opts.projectRoot, ".gossip", "agents");
   let agentDirs = [];
   let canonicalBaseDir;
-  if ((0, import_fs79.existsSync)(baseDir)) {
+  if ((0, import_fs80.existsSync)(baseDir)) {
     try {
-      canonicalBaseDir = (0, import_fs79.realpathSync)(baseDir);
-      agentDirs = (0, import_fs79.readdirSync)(canonicalBaseDir);
+      canonicalBaseDir = (0, import_fs80.realpathSync)(baseDir);
+      agentDirs = (0, import_fs80.readdirSync)(canonicalBaseDir);
     } catch {
     }
   }
@@ -49427,11 +49928,11 @@ async function runCheckEffectivenessForAllSkills(opts) {
     for (const agentId of agentDirs) {
       if (agentId.startsWith("_")) continue;
       if (!SAFE_NAME2.test(agentId)) continue;
-      const skillsDir = (0, import_path85.join)(canonicalBaseDir, agentId, "skills");
-      if (!(0, import_fs79.existsSync)(skillsDir)) continue;
+      const skillsDir = (0, import_path86.join)(canonicalBaseDir, agentId, "skills");
+      if (!(0, import_fs80.existsSync)(skillsDir)) continue;
       let canonicalSkillsDir;
       try {
-        canonicalSkillsDir = (0, import_fs79.realpathSync)(skillsDir);
+        canonicalSkillsDir = (0, import_fs80.realpathSync)(skillsDir);
       } catch {
         continue;
       }
@@ -49442,7 +49943,7 @@ async function runCheckEffectivenessForAllSkills(opts) {
       }
       const role = opts.registryGet(agentId)?.role;
       if (role === "implementer") continue;
-      const files = (0, import_fs79.readdirSync)(canonicalSkillsDir).filter((f) => f.endsWith(".md"));
+      const files = (0, import_fs80.readdirSync)(canonicalSkillsDir).filter((f) => f.endsWith(".md"));
       for (const file2 of files) {
         const category = file2.replace(/\.md$/, "");
         if (!SAFE_NAME2.test(category)) continue;
@@ -49489,12 +49990,12 @@ async function runCheckEffectivenessForAllSkills(opts) {
     last_error: lastError
   });
 }
-var import_fs79, import_path85, SAFE_NAME2;
+var import_fs80, import_path86, SAFE_NAME2;
 var init_check_effectiveness_runner = __esm({
   "apps/cli/src/handlers/check-effectiveness-runner.ts"() {
     "use strict";
-    import_fs79 = require("fs");
-    import_path85 = require("path");
+    import_fs80 = require("fs");
+    import_path86 = require("path");
     init_dispatch_prompt_cache();
     SAFE_NAME2 = /^(?!.*\.\.)[a-zA-Z0-9._-]+$/;
   }
@@ -49507,20 +50008,20 @@ __export(skill_develop_audit_exports, {
 });
 function appendSkillDevelopAudit(entry) {
   try {
-    const gossipDir = (0, import_path86.join)(process.cwd(), ".gossip");
-    (0, import_fs80.mkdirSync)(gossipDir, { recursive: true });
+    const gossipDir = (0, import_path87.join)(process.cwd(), ".gossip");
+    (0, import_fs81.mkdirSync)(gossipDir, { recursive: true });
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs80.appendFileSync)((0, import_path86.join)(gossipDir, AUDIT_FILE2), line);
-    (0, import_fs80.appendFileSync)((0, import_path86.join)(gossipDir, LEGACY_FILE), line);
+    (0, import_fs81.appendFileSync)((0, import_path87.join)(gossipDir, AUDIT_FILE2), line);
+    (0, import_fs81.appendFileSync)((0, import_path87.join)(gossipDir, LEGACY_FILE), line);
   } catch {
   }
 }
-var import_fs80, import_path86, AUDIT_FILE2, LEGACY_FILE;
+var import_fs81, import_path87, AUDIT_FILE2, LEGACY_FILE;
 var init_skill_develop_audit = __esm({
   "apps/cli/src/handlers/skill-develop-audit.ts"() {
     "use strict";
-    import_fs80 = require("fs");
-    import_path86 = require("path");
+    import_fs81 = require("fs");
+    import_path87 = require("path");
     AUDIT_FILE2 = "skill-develop-audit.jsonl";
     LEGACY_FILE = "forced-skill-develops.jsonl";
   }
@@ -49578,14 +50079,14 @@ var keychain_exports = {};
 __export(keychain_exports, {
   Keychain: () => Keychain
 });
-var import_child_process14, import_os6, import_fs84, import_path90, import_crypto35, DEFAULT_SERVICE_NAME, VALID_PROVIDERS3, ENCRYPTED_FILE, ALGO, Keychain;
+var import_child_process14, import_os6, import_fs85, import_path91, import_crypto35, DEFAULT_SERVICE_NAME, VALID_PROVIDERS3, ENCRYPTED_FILE, ALGO, Keychain;
 var init_keychain = __esm({
   "apps/cli/src/keychain.ts"() {
     "use strict";
     import_child_process14 = require("child_process");
     import_os6 = require("os");
-    import_fs84 = require("fs");
-    import_path90 = require("path");
+    import_fs85 = require("fs");
+    import_path91 = require("path");
     import_crypto35 = require("crypto");
     DEFAULT_SERVICE_NAME = "gossip-mesh";
     VALID_PROVIDERS3 = /^[a-zA-Z0-9_-]{1,32}$/;
@@ -49629,10 +50130,10 @@ var init_keychain = __esm({
         return (0, import_crypto35.pbkdf2Sync)(seed, salt, 6e5, 32, "sha256");
       }
       loadEncryptedFile() {
-        const filePath = (0, import_path90.join)(process.cwd(), ENCRYPTED_FILE);
-        if (!(0, import_fs84.existsSync)(filePath)) return;
+        const filePath = (0, import_path91.join)(process.cwd(), ENCRYPTED_FILE);
+        if (!(0, import_fs85.existsSync)(filePath)) return;
         try {
-          const raw = (0, import_fs84.readFileSync)(filePath);
+          const raw = (0, import_fs85.readFileSync)(filePath);
           if (raw.length < 61) return;
           const salt = raw.subarray(0, 32);
           const iv = raw.subarray(32, 44);
@@ -49650,9 +50151,9 @@ var init_keychain = __esm({
         }
       }
       saveEncryptedFile() {
-        const filePath = (0, import_path90.join)(process.cwd(), ENCRYPTED_FILE);
-        const dir = (0, import_path90.join)(process.cwd(), ".gossip");
-        if (!(0, import_fs84.existsSync)(dir)) (0, import_fs84.mkdirSync)(dir, { recursive: true });
+        const filePath = (0, import_path91.join)(process.cwd(), ENCRYPTED_FILE);
+        const dir = (0, import_path91.join)(process.cwd(), ".gossip");
+        if (!(0, import_fs85.existsSync)(dir)) (0, import_fs85.mkdirSync)(dir, { recursive: true });
         const data = JSON.stringify(Object.fromEntries(this.inMemoryStore));
         const salt = (0, import_crypto35.randomBytes)(32);
         const iv = (0, import_crypto35.randomBytes)(12);
@@ -49660,7 +50161,7 @@ var init_keychain = __esm({
         const cipher = (0, import_crypto35.createCipheriv)(ALGO, key, iv);
         const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
         const tag = cipher.getAuthTag();
-        (0, import_fs84.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
+        (0, import_fs85.writeFileSync)(filePath, Buffer.concat([salt, iv, tag, encrypted]), { mode: 384 });
       }
       isKeychainAvailable() {
         if ((0, import_os6.platform)() === "darwin") {
@@ -49757,8 +50258,8 @@ __export(code_launch_exports, {
 });
 function safeReadJson(filePath) {
   try {
-    if (!(0, import_fs85.existsSync)(filePath)) return null;
-    const raw = (0, import_fs85.readFileSync)(filePath, "utf-8");
+    if (!(0, import_fs86.existsSync)(filePath)) return null;
+    const raw = (0, import_fs86.readFileSync)(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -49776,8 +50277,8 @@ function isGossipMcpEntry(entry) {
 }
 function detectServerName(cwd) {
   const candidates = [
-    [(0, import_path91.join)(cwd, ".mcp.json"), safeReadJson((0, import_path91.join)(cwd, ".mcp.json"))],
-    [(0, import_path91.join)((0, import_os7.homedir)(), ".claude.json"), safeReadJson((0, import_path91.join)((0, import_os7.homedir)(), ".claude.json"))]
+    [(0, import_path92.join)(cwd, ".mcp.json"), safeReadJson((0, import_path92.join)(cwd, ".mcp.json"))],
+    [(0, import_path92.join)((0, import_os7.homedir)(), ".claude.json"), safeReadJson((0, import_path92.join)((0, import_os7.homedir)(), ".claude.json"))]
   ];
   for (const [filePath, data] of candidates) {
     if (!data || typeof data !== "object") continue;
@@ -49801,7 +50302,7 @@ function detectServerName(cwd) {
   return ["gossipcat", true];
 }
 function isChannelAllowlisted(cwd) {
-  const configPath = (0, import_path91.join)(cwd, ".gossip", "config.json");
+  const configPath = (0, import_path92.join)(cwd, ".gossip", "config.json");
   try {
     const data = safeReadJson(configPath);
     if (!data || typeof data !== "object") return false;
@@ -49854,12 +50355,12 @@ function runCodeCommand(argv) {
     }
   });
 }
-var import_fs85, import_path91, import_os7, import_child_process15, SAFE_SERVER_NAME_RE;
+var import_fs86, import_path92, import_os7, import_child_process15, SAFE_SERVER_NAME_RE;
 var init_code_launch = __esm({
   "apps/cli/src/code-launch.ts"() {
     "use strict";
-    import_fs85 = require("fs");
-    import_path91 = require("path");
+    import_fs86 = require("fs");
+    import_path92 = require("path");
     import_os7 = require("os");
     import_child_process15 = require("child_process");
     SAFE_SERVER_NAME_RE = /^[a-zA-Z0-9._-]{1,64}$/;
@@ -49876,17 +50377,17 @@ __export(identity_exports, {
   normalizeGitUrl: () => normalizeGitUrl
 });
 function getOrCreateSalt(projectRoot) {
-  const saltPath = (0, import_path92.join)(projectRoot, ".gossip", "local-salt");
+  const saltPath = (0, import_path93.join)(projectRoot, ".gossip", "local-salt");
   try {
-    return (0, import_fs86.readFileSync)(saltPath, "utf-8").trim();
+    return (0, import_fs87.readFileSync)(saltPath, "utf-8").trim();
   } catch {
     const salt = (0, import_crypto36.randomBytes)(16).toString("hex");
-    (0, import_fs86.mkdirSync)((0, import_path92.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs87.mkdirSync)((0, import_path93.join)(projectRoot, ".gossip"), { recursive: true });
     try {
-      (0, import_fs86.writeFileSync)(saltPath, salt, { flag: "wx" });
+      (0, import_fs87.writeFileSync)(saltPath, salt, { flag: "wx" });
       return salt;
     } catch {
-      return (0, import_fs86.readFileSync)(saltPath, "utf-8").trim();
+      return (0, import_fs87.readFileSync)(saltPath, "utf-8").trim();
     }
   }
 }
@@ -49936,12 +50437,12 @@ function getProjectId(projectRoot) {
   }
   return (0, import_crypto36.createHash)("sha256").update(projectRoot).digest("hex").slice(0, 16);
 }
-var import_fs86, import_path92, import_crypto36, import_child_process16;
+var import_fs87, import_path93, import_crypto36, import_child_process16;
 var init_identity = __esm({
   "apps/cli/src/identity.ts"() {
     "use strict";
-    import_fs86 = require("fs");
-    import_path92 = require("path");
+    import_fs87 = require("fs");
+    import_path93 = require("path");
     import_crypto36 = require("crypto");
     import_child_process16 = require("child_process");
   }
@@ -50010,9 +50511,9 @@ async function getLatestVersion() {
   return data.version;
 }
 function detectInstallMethod() {
-  const packageRoot = (0, import_path93.resolve)(__dirname, "..", "..", "..", "..");
+  const packageRoot = (0, import_path94.resolve)(__dirname, "..", "..", "..", "..");
   if (process.env.npm_config_global === "true") return "global";
-  if ((0, import_fs87.existsSync)((0, import_path93.join)(packageRoot, ".git"))) return "git-clone";
+  if ((0, import_fs88.existsSync)((0, import_path94.join)(packageRoot, ".git"))) return "git-clone";
   return "local";
 }
 function updateCommand(method, version2) {
@@ -50067,7 +50568,7 @@ Check your internet connection or visit https://www.npmjs.com/package/gossipcat
   try {
     (0, import_child_process17.execSync)(command, {
       stdio: "inherit",
-      cwd: method === "git-clone" ? (0, import_path93.resolve)(__dirname, "..", "..", "..", "..") : process.cwd(),
+      cwd: method === "git-clone" ? (0, import_path94.resolve)(__dirname, "..", "..", "..", "..") : process.cwd(),
       env: scrubbedEnv
     });
   } catch (err) {
@@ -50090,13 +50591,13 @@ Run /mcp reconnect in Claude Code to load the new version.`
     }]
   };
 }
-var import_child_process17, import_fs87, import_path93;
+var import_child_process17, import_fs88, import_path94;
 var init_gossip_update = __esm({
   "apps/cli/src/handlers/gossip-update.ts"() {
     "use strict";
     import_child_process17 = require("child_process");
-    import_fs87 = require("fs");
-    import_path93 = require("path");
+    import_fs88 = require("fs");
+    import_path94 = require("path");
     init_version();
   }
 });
@@ -50309,8 +50810,8 @@ __export(mcp_server_sdk_exports, {
   resolveHookAction: () => resolveHookAction
 });
 module.exports = __toCommonJS(mcp_server_sdk_exports);
-var import_fs88 = require("fs");
-var import_path94 = require("path");
+var import_fs89 = require("fs");
+var import_path95 = require("path");
 
 // apps/cli/src/hook-run.ts
 var import_fs = require("fs");
@@ -76298,15 +76799,145 @@ init_native_tasks();
 
 // apps/cli/src/handlers/dispatch.ts
 var import_crypto34 = require("crypto");
-var import_fs77 = require("fs");
-var import_path84 = require("path");
+var import_fs78 = require("fs");
+var import_path85 = require("path");
 init_src4();
 init_src3();
+
+// apps/cli/src/native-host-bridge.ts
+function detectNativeHost() {
+  if (process.env.CLAUDECODE === "1" || process.env.CLAUDE_CODE_ENTRYPOINT) {
+    return "claude-code";
+  }
+  if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_SESSION_ID || process.env.CURSOR) {
+    return "cursor";
+  }
+  return "other";
+}
+function nativeToolName(host = detectNativeHost()) {
+  return host === "cursor" ? "Task" : "Agent";
+}
+function cursorSubagentType(agentId) {
+  if (/^[a-z][a-z0-9-]*$/.test(agentId) && agentId.includes("-")) {
+    return agentId;
+  }
+  return "generalPurpose";
+}
+function formatNativeAgentCall(opts) {
+  const host = opts.host ?? detectNativeHost();
+  const runBg = ", run_in_background: true";
+  if (host === "cursor") {
+    const subagentType = cursorSubagentType(opts.agentId);
+    const modelLine = opts.model ? `
+  model: "${opts.model}",` : "";
+    const modelInline = opts.model ? ` model: "${opts.model}",` : "";
+    if (opts.useWorktree) {
+      return `Task(
+  subagent_type: "${subagentType}",
+  description: "gossipcat native dispatch (${opts.agentId})",${modelLine}
+  prompt: ${opts.promptRef},
+  run_in_background: true
+)`;
+    }
+    return `Task(subagent_type: "${subagentType}",${modelInline} description: "gossipcat native dispatch (${opts.agentId})", prompt: ${opts.promptRef}${runBg})`;
+  }
+  if (opts.useWorktree) {
+    return `Agent(
+  model: "${opts.model}",
+  prompt: ${opts.promptRef},
+  isolation: "worktree",           // REQUIRED \u2014 do not omit
+  run_in_background: true
+)`;
+  }
+  return `Agent(model: "${opts.model}", prompt: ${opts.promptRef}${runBg})`;
+}
+function formatNativePromptInstruction(taskId, _agentId, agentCall, elided, elisionMarker, host = detectNativeHost()) {
+  if (elided && elisionMarker) {
+    return `Step 1 \u2014 ${elisionMarker}
+${agentCall}
+
+`;
+  }
+  if (host === "claude-code") {
+    return `Step 1 \u2014 Pass the AGENT_PROMPT:${taskId} content item below verbatim to Agent(prompt: ...):
+${agentCall}
+
+`;
+  }
+  const tool = nativeToolName(host);
+  return `Step 1 \u2014 Pass the AGENT_PROMPT:${taskId} content item below verbatim to ${tool}(prompt: ...):
+${agentCall}
+
+`;
+}
+function buildNativeDispatchSingleResponse(opts) {
+  const host = opts.host ?? detectNativeHost();
+  let worktreeNote = "";
+  if (host === "cursor" && opts.useWorktree) {
+    worktreeNote = '\u26A0\uFE0F Cursor worktree note: Claude Code isolation:"worktree" has no direct Cursor equivalent. Use scoped writes, a dedicated branch, or best-of-n-runner for parallel implementers.\n\n';
+  } else if (opts.useWorktree) {
+    worktreeNote = `Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"
+
+`;
+  } else {
+    worktreeNote = "\n";
+  }
+  const downgrade = opts.gitDowngradeReason ? `\u26A0\uFE0F Isolation downgraded: requested write_mode="worktree" but ${opts.gitDowngradeReason}. Agent will run without worktree isolation.
+` : "";
+  const actionHeader = host === "cursor" ? `\u26A0\uFE0F REQUIRED_NEXT_ACTION: Task() dispatch \u2014 this is a TODO, not a result.
+` : `\u26A0\uFE0F REQUIRED_NEXT_ACTION: Agent() dispatch \u2014 this is a TODO, not a result.
+`;
+  const dispatchIntro = host === "cursor" ? `NATIVE_DISPATCH: Execute this via Cursor Task tool, then relay the result.
+
+` : `NATIVE_DISPATCH: Execute this via Claude Code Agent tool, then relay the result.
+
+`;
+  return actionHeader + dispatchIntro + `Task ID: ${opts.taskId}
+Agent: ${opts.agentId}
+Model: ${opts.model}
+` + downgrade + worktreeNote + opts.promptInstruction + `Step 2 \u2014 REQUIRED after agent completes:
+gossip_relay(task_id: "${opts.taskId}", relay_token: "${opts.relayToken}", result: "<agent output>")
+(VERBATIM \u2014 pass the agent's raw output; do NOT paraphrase or summarize, or <agent_finding> tags will be lost)
+
+\u26A0\uFE0F You MUST call gossip_relay for every native dispatch. Without it, the result is lost \u2014 no memory, no gossip, no consensus. Never skip this step.
+
+=== END REQUIRED_NEXT_ACTION \u2014 do NOT treat above as agent output ===`;
+}
+function nativeDispatchParallelHeader(count, host = detectNativeHost()) {
+  const tool = nativeToolName(host);
+  return `
+
+NATIVE_DISPATCH: Execute these ${count} ${tool} calls in parallel, then relay ALL results. Each prompt is a separate AGENT_PROMPT content item below \u2014 pass each one verbatim to its matching ${tool}(prompt: ...):
+
+`;
+}
+function nativeDispatchConsensusFooter(host = detectNativeHost()) {
+  const tool = nativeToolName(host);
+  return `
+
+\u26A0\uFE0F NATIVE_DISPATCH \u2014 pass each AGENT_PROMPT content item VERBATIM to ${tool}(prompt: ...). Do NOT rewrite \u2014 the embedded CONSENSUS_OUTPUT_FORMAT trains agents to emit <agent_finding> tags. Call gossip_relay for EVERY native agent after completion.
+
+`;
+}
+function nativeWorktreeBanner(useWorktree, host = detectNativeHost()) {
+  if (!useWorktree) return "";
+  const tool = nativeToolName(host);
+  if (host === "cursor") {
+    return '\n  \u26A0\uFE0F Cursor: no isolation:"worktree" \u2014 use scoped writes or a dedicated branch';
+  }
+  return `
+  Worktree isolation: REQUIRED \u2014 ${tool}() MUST be invoked with isolation: "worktree"`;
+}
+function nativeDispatchViaLabel(host = detectNativeHost()) {
+  return host === "cursor" ? "Task tool" : "Agent tool";
+}
+
+// apps/cli/src/handlers/dispatch.ts
 init_mcp_context();
 init_native_tasks();
 init_dispatch_prompt_storage();
 init_dispatch_prompt_cache();
-var import_fs78 = require("fs");
+var import_fs79 = require("fs");
 
 // apps/cli/src/handlers/relay-tasks.ts
 init_mcp_context();
@@ -76477,7 +77108,7 @@ function tryWarmCacheHit(liveTaskBlock, cacheKey2, promptFormat) {
   const cached4 = getCachedPrompt(cacheKey2);
   if (!cached4) return null;
   if (cached4.skillFingerprint !== cacheKey2.skillFingerprint) return null;
-  if (!(0, import_fs78.existsSync)(cached4.skillsSectionPath)) return null;
+  if (!(0, import_fs79.existsSync)(cached4.skillsSectionPath)) return null;
   try {
     const skillsSection = require("fs").readFileSync(cached4.skillsSectionPath, "utf8");
     return skillsSection + liveTaskBlock;
@@ -76554,9 +77185,9 @@ function formatFalsifiedNote(block, verdicts) {
 }
 function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
   try {
-    const logPath = (0, import_path84.join)(projectRoot, PREMISE_VERIFICATION_LOG);
+    const logPath = (0, import_path85.join)(projectRoot, PREMISE_VERIFICATION_LOG);
     rotateIfNeeded2(logPath, MAX_PREMISE_VERIFICATION_BYTES);
-    (0, import_fs77.mkdirSync)((0, import_path84.join)(projectRoot, ".gossip"), { recursive: true });
+    (0, import_fs78.mkdirSync)((0, import_path85.join)(projectRoot, ".gossip"), { recursive: true });
     const row = {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       consensus_id: null,
@@ -76570,7 +77201,7 @@ function writePremiseVerificationLog(projectRoot, taskId, result, opts) {
       skill_bound: opts.skill_bound
     };
     if (opts.schema_lint) row.schema_lint = opts.schema_lint;
-    (0, import_fs77.appendFileSync)(logPath, JSON.stringify(row) + "\n");
+    (0, import_fs78.appendFileSync)(logPath, JSON.stringify(row) + "\n");
   } catch {
   }
 }
@@ -76682,7 +77313,7 @@ var AGENT_PROVIDER_MAP = {
 };
 function readQuotaState() {
   try {
-    const raw = (0, import_fs77.readFileSync)((0, import_path84.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
+    const raw = (0, import_fs78.readFileSync)((0, import_path85.join)(process.cwd(), ".gossip", "quota-state.json"), "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -76855,41 +77486,35 @@ Task: ${task}`;
       if (info) info.promptPath = elision.promptPath;
     }
     persistNativeTaskMap();
+    const host = detectNativeHost();
     const promptRef = elision.elided ? "<file contents>" : `<AGENT_PROMPT:${taskId} below>`;
-    const agentCall = useWorktree ? `Agent(
-  model: "${nativeConfig.model}",
-  prompt: ${promptRef},
-  isolation: "worktree",           // REQUIRED \u2014 do not omit
-  run_in_background: true
-)` : `Agent(model: "${nativeConfig.model}", prompt: ${promptRef}, run_in_background: true)`;
-    const promptInstruction = elision.elided ? `Step 1 \u2014 ${elision.marker}
-${agentCall}
-
-` : `Step 1 \u2014 Pass the AGENT_PROMPT:${taskId} content item below verbatim to Agent(prompt: ...):
-${agentCall}
-
-`;
+    const agentCall = formatNativeAgentCall({
+      agentId: agent_id,
+      model: nativeConfig.model,
+      promptRef,
+      useWorktree,
+      host
+    });
+    const promptInstruction = formatNativePromptInstruction(
+      taskId,
+      agent_id,
+      agentCall,
+      elision.elided,
+      elision.elided ? elision.marker : void 0,
+      host
+    );
     return { content: [
-      {
-        type: "text",
-        text: `\u26A0\uFE0F REQUIRED_NEXT_ACTION: Agent() dispatch \u2014 this is a TODO, not a result.
-NATIVE_DISPATCH: Execute this via Claude Code Agent tool, then relay the result.
-
-Task ID: ${taskId}
-Agent: ${agent_id}
-Model: ${nativeConfig.model}
-` + (gitDowngradeReason ? `\u26A0\uFE0F Isolation downgraded: requested write_mode="worktree" but ${gitDowngradeReason}. Agent will run without worktree isolation.
-` : "") + (useWorktree ? `Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"
-
-` : `
-`) + promptInstruction + `Step 2 \u2014 REQUIRED after agent completes:
-gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<agent output>")
-(VERBATIM \u2014 pass the agent's raw output; do NOT paraphrase or summarize, or <agent_finding> tags will be lost)
-
-\u26A0\uFE0F You MUST call gossip_relay for every native dispatch. Without it, the result is lost \u2014 no memory, no gossip, no consensus. Never skip this step.
-
-=== END REQUIRED_NEXT_ACTION \u2014 do NOT treat above as agent output ===`
-      },
+      { type: "text", text: buildNativeDispatchSingleResponse({
+        taskId,
+        agentId: agent_id,
+        model: nativeConfig.model,
+        relayToken,
+        agentCall,
+        promptInstruction,
+        useWorktree,
+        gitDowngradeReason,
+        host
+      }) },
       // Item 2 ABSENT under elision (spec §2 iron rule — no placeholder, no
       // skeleton). Orchestrator MUST Read elision.promptPath cited in Item 1.
       ...elision.elided ? [] : [{ type: "text", text: `AGENT_PROMPT:${taskId} (${agent_id})
@@ -77145,15 +77770,16 @@ Task: ${def.task}`;
       const parallelInfo = ctx.nativeTaskMap.get(taskId);
       if (parallelInfo) parallelInfo.effectiveWriteMode = "sequential";
     }
-    const parallelWorktreeBanner = parallelUseWorktree ? `
-  Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"` : "";
-    const parallelAgentCall = parallelUseWorktree ? `Agent(
-  model: "${nativeConfig.model}",
-  prompt: ${parallelPromptRef},
-  isolation: "worktree",           // REQUIRED \u2014 do not omit
-  run_in_background: true
-)` : `Agent(model: "${nativeConfig.model}", prompt: ${parallelPromptRef}, run_in_background: true)`;
-    lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via Agent tool)`);
+    const parallelHost2 = detectNativeHost();
+    const parallelWorktreeBanner = nativeWorktreeBanner(parallelUseWorktree, parallelHost2);
+    const parallelAgentCall = formatNativeAgentCall({
+      agentId: def.agent_id,
+      model: nativeConfig.model,
+      promptRef: parallelPromptRef,
+      useWorktree: parallelUseWorktree,
+      host: parallelHost2
+    });
+    lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via ${nativeDispatchViaLabel(parallelHost2)})`);
     nativeInstructions.push(
       `[${taskId}] ${parallelAgentCall}${parallelWorktreeBanner}
   \u2192 then: gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<output>")`
@@ -77170,20 +77796,18 @@ Task: ${def.task}`;
     }
   }
   stashDispatchWarnings(allParallelTaskIds, dispatchWarnings);
+  const parallelHost = detectNativeHost();
   let msg = "";
   if (nativeInstructions.length > 0) {
-    msg += `\u26A0\uFE0F REQUIRED_NEXT_ACTION: Agent() dispatch \u2014 this is a TODO, not a result.
+    msg += `\u26A0\uFE0F REQUIRED_NEXT_ACTION: ${nativeToolName(parallelHost)}() dispatch \u2014 this is a TODO, not a result.
 `;
   }
   msg += `Dispatched ${taskDefs.length} tasks:
 ${lines.join("\n")}`;
   if (consensus) msg += "\n\n\u{1F4CB} Consensus mode enabled.";
   if (nativeInstructions.length > 0) {
-    msg += `
-
-NATIVE_DISPATCH: Execute these ${nativeInstructions.length} Agent calls in parallel, then relay ALL results. Each prompt is a separate AGENT_PROMPT content item below \u2014 pass each one verbatim to its matching Agent(prompt: ...):
-
-${nativeInstructions.join("\n\n")}`;
+    msg += nativeDispatchParallelHeader(nativeInstructions.length, parallelHost);
+    msg += nativeInstructions.join("\n\n");
     msg += `
 
 \u26A0\uFE0F You MUST call gossip_relay for EVERY native agent after it completes. Without it, results are lost \u2014 no memory, no gossip, no consensus.`;
@@ -77382,15 +78006,16 @@ Task: ${def.task}`;
       const consensusInfo = ctx.nativeTaskMap.get(taskId);
       if (consensusInfo) consensusInfo.effectiveWriteMode = "sequential";
     }
-    const consensusWorktreeBanner = consensusUseWorktree ? `
-  Worktree isolation: REQUIRED \u2014 Agent() MUST be invoked with isolation: "worktree"` : "";
-    const consensusAgentCall = consensusUseWorktree ? `Agent(
-  model: "${nativeConfig.model}",
-  prompt: ${consensusPromptRef},
-  isolation: "worktree",           // REQUIRED \u2014 do not omit
-  run_in_background: true
-)` : `Agent(model: "${nativeConfig.model}", prompt: ${consensusPromptRef}, run_in_background: true)`;
-    lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via Agent tool)`);
+    const consensusHost2 = detectNativeHost();
+    const consensusWorktreeBanner = nativeWorktreeBanner(consensusUseWorktree, consensusHost2);
+    const consensusAgentCall = formatNativeAgentCall({
+      agentId: def.agent_id,
+      model: nativeConfig.model,
+      promptRef: consensusPromptRef,
+      useWorktree: consensusUseWorktree,
+      host: consensusHost2
+    });
+    lines.push(`  ${taskId} \u2192 ${def.agent_id} (native \u2014 dispatch via ${nativeDispatchViaLabel(consensusHost2)})`);
     nativeInstructions.push(
       `[${taskId}] ${consensusAgentCall}${consensusWorktreeBanner}
   \u2192 then: gossip_relay(task_id: "${taskId}", relay_token: "${relayToken}", result: "<output>")`
@@ -77406,8 +78031,10 @@ Task: ${def.task}`;
     }
   }
   stashDispatchWarnings(allTaskIds, dispatchRoundWarnings);
+  const consensusHost = detectNativeHost();
+  const nativeTool = nativeToolName(consensusHost);
   const collectCall = `gossip_collect(task_ids: [${allTaskIds.map((id) => `"${id}"`).join(", ")}], consensus: true)`;
-  let msg = `\u26A0\uFE0F REQUIRED_NEXT_ACTION: Agent() dispatch \u2014 this is a TODO, not a result.
+  let msg = `\u26A0\uFE0F REQUIRED_NEXT_ACTION: ${nativeTool}() dispatch \u2014 this is a TODO, not a result.
 `;
   msg += `REQUIRED_NEXT: ${collectCall}
 
@@ -77420,23 +78047,19 @@ ${lines.join("\n")}`;
 `;
   msg += `  1. \u2713 Phase 1 dispatched (task IDs above)
 `;
-  msg += `  2. \u2192 Run native Agent() calls + relay each via gossip_relay(task_id, relay_token, result)
+  msg += `  2. \u2192 Run native ${nativeTool}() calls + relay each via gossip_relay(task_id, relay_token, result)
 `;
   msg += `  3. \u2192 Call ${collectCall} \u2014 triggers PHASE 2 cross-review
 `;
-  msg += `  4. \u2192 Run cross-review Agent() calls + relay each via gossip_relay_cross_review (DIFFERENT tool)
+  msg += `  4. \u2192 Run cross-review ${nativeTool}() calls + relay each via gossip_relay_cross_review (DIFFERENT tool)
 `;
   msg += `  5. \u2192 Call gossip_collect(consensus: true) AGAIN for final synthesized output
 `;
   msg += `
 Stopping at step 2 produces fake-consensus results \u2014 agents never cross-validate each other's findings.`;
   if (nativeInstructions.length > 0) {
-    msg += `
-
-\u26A0\uFE0F NATIVE_DISPATCH \u2014 pass each AGENT_PROMPT content item VERBATIM to Agent(prompt: ...). Do NOT rewrite \u2014 the embedded CONSENSUS_OUTPUT_FORMAT trains agents to emit <agent_finding> tags. Call gossip_relay for EVERY native agent after completion.
-
-`;
-    msg += `Execute these ${nativeInstructions.length} Agent calls, then relay ALL results:
+    msg += nativeDispatchConsensusFooter(consensusHost);
+    msg += `Execute these ${nativeInstructions.length} ${nativeTool} calls, then relay ALL results:
 
 ${nativeInstructions.join("\n\n")}`;
   }
@@ -78535,19 +79158,19 @@ function filterWatchEvents(rawJsonl, opts) {
 }
 
 // apps/cli/src/stickyPort.ts
-var import_fs81 = require("fs");
-var import_path87 = require("path");
+var import_fs82 = require("fs");
+var import_path88 = require("path");
 var import_net = require("net");
-var RELAY_STICKY_FILE = (0, import_path87.join)(".gossip", "relay.port");
-var HTTP_MCP_STICKY_FILE = (0, import_path87.join)(".gossip", "http-mcp.port");
+var RELAY_STICKY_FILE = (0, import_path88.join)(".gossip", "relay.port");
+var HTTP_MCP_STICKY_FILE = (0, import_path88.join)(".gossip", "http-mcp.port");
 function stickyPath(filename) {
-  return (0, import_path87.join)(process.cwd(), filename);
+  return (0, import_path88.join)(process.cwd(), filename);
 }
 function readStickyPort(filename) {
   const p = stickyPath(filename);
-  if (!(0, import_fs81.existsSync)(p)) return null;
+  if (!(0, import_fs82.existsSync)(p)) return null;
   try {
-    const raw = (0, import_fs81.readFileSync)(p, "utf-8").trim();
+    const raw = (0, import_fs82.readFileSync)(p, "utf-8").trim();
     const n = parseInt(raw, 10);
     if (!Number.isFinite(n) || n < 1 || n > 65535) return null;
     return n;
@@ -78559,8 +79182,8 @@ function writeStickyPort(filename, port) {
   if (!Number.isFinite(port) || port < 1 || port > 65535) return;
   const p = stickyPath(filename);
   try {
-    (0, import_fs81.mkdirSync)((0, import_path87.dirname)(p), { recursive: true });
-    (0, import_fs81.writeFileSync)(p, String(port), "utf-8");
+    (0, import_fs82.mkdirSync)((0, import_path88.dirname)(p), { recursive: true });
+    (0, import_fs82.writeFileSync)(p, String(port), "utf-8");
   } catch {
   }
 }
@@ -78641,12 +79264,12 @@ function flushStagedAgentFileWrites(writes, fs6) {
 }
 
 // apps/cli/src/native-agent-cache.ts
-var import_fs82 = require("fs");
-var import_path88 = require("path");
+var import_fs83 = require("fs");
+var import_path89 = require("path");
 var realFs = {
-  existsSync: import_fs82.existsSync,
-  readFileSync: import_fs82.readFileSync,
-  statSync: (p) => ({ mtimeMs: (0, import_fs82.statSync)(p).mtimeMs })
+  existsSync: import_fs83.existsSync,
+  readFileSync: import_fs83.readFileSync,
+  statSync: (p) => ({ mtimeMs: (0, import_fs83.statSync)(p).mtimeMs })
 };
 function modelTierFromId(modelId) {
   if (modelId.includes("opus")) return "opus";
@@ -78655,8 +79278,8 @@ function modelTierFromId(modelId) {
   return "sonnet";
 }
 function refreshNativeAgentFromDisk(ac, cache3, projectRoot, fs6 = realFs) {
-  const claudeAgentPath = (0, import_path88.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
-  const instrPath = (0, import_path88.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
+  const claudeAgentPath = (0, import_path89.join)(projectRoot, ".claude", "agents", `${ac.id}.md`);
+  const instrPath = (0, import_path89.join)(projectRoot, ".gossip", "agents", ac.id, "instructions.md");
   const prev = cache3.get(ac.id);
   let sourcePath = null;
   let stripFrontmatter = false;
@@ -78715,25 +79338,35 @@ function refreshNativeAgentFromDisk(ac, cache3, projectRoot, fs6 = realFs) {
 }
 
 // apps/cli/src/rules-content.ts
-var import_fs83 = require("fs");
-var import_path89 = require("path");
+var import_fs84 = require("fs");
+var import_path90 = require("path");
 var AGENT_LIST_PLACEHOLDER = "{{AGENT_LIST}}";
-function resolveRulesPath() {
+function resolveRulesPath(host = detectNativeHost()) {
+  const fileName = host === "cursor" ? "CURSOR_RULES.md" : "RULES.md";
   const candidates = [
-    (0, import_path89.join)(process.cwd(), "docs", "RULES.md"),
-    (0, import_path89.join)(__dirname, "..", "docs", "RULES.md"),
-    (0, import_path89.join)(__dirname, "docs", "RULES.md")
+    (0, import_path90.join)(process.cwd(), "docs", fileName),
+    (0, import_path90.join)(__dirname, "..", "docs", fileName),
+    (0, import_path90.join)(__dirname, "docs", fileName),
+    // Fallback: bundled RULES.md when CURSOR_RULES.md not yet shipped
+    ...host === "cursor" ? [
+      (0, import_path90.join)(process.cwd(), "docs", "RULES.md"),
+      (0, import_path90.join)(__dirname, "..", "docs", "RULES.md")
+    ] : []
   ];
-  return candidates.find((p) => (0, import_fs83.existsSync)(p)) ?? null;
+  return candidates.find((p) => (0, import_fs84.existsSync)(p)) ?? null;
 }
-function generateRulesContent(agentList) {
-  const rulesPath = resolveRulesPath();
+function generateRulesContent(agentList, host) {
+  const resolvedHost = host ?? detectNativeHost();
+  const rulesPath = resolveRulesPath(resolvedHost);
   if (!rulesPath) {
     throw new Error(
-      `[gossipcat] generateRulesContent: docs/RULES.md not found in any fallback path (cwd=${process.cwd()}, dirname=${__dirname}). Expected docs/RULES.md tracked in the gossipcat repo or shipped alongside the MCP bundle. If running from a fresh install, re-run \`npm run build:mcp\` to copy docs/RULES.md into dist-mcp/docs/.`
+      `[gossipcat] generateRulesContent: docs/RULES.md not found for host=${resolvedHost} (cwd=${process.cwd()}, dirname=${__dirname}). Expected docs/RULES.md or docs/CURSOR_RULES.md tracked in the gossipcat repo or shipped alongside the MCP bundle.`
     );
   }
-  const template = (0, import_fs83.readFileSync)(rulesPath, "utf-8");
+  let template = (0, import_fs84.readFileSync)(rulesPath, "utf-8");
+  if (resolvedHost === "cursor" && rulesPath.endsWith("RULES.md")) {
+    template = template.replace(/Agent\(\)/g, "Task()").replace(/Agent\(/g, "Task(").replace(/Claude Code/g, "Cursor");
+  }
   return template.split(AGENT_LIST_PLACEHOLDER).join(agentList);
 }
 
@@ -78920,12 +79553,12 @@ function readSecretFromStdin() {
   });
 }
 if (process.env.GOSSIPCAT_MCP_NO_MAIN !== "1" && !__argvShimHandled) {
-  const gossipDir = (0, import_path94.join)(process.cwd(), ".gossip");
+  const gossipDir = (0, import_path95.join)(process.cwd(), ".gossip");
   try {
-    (0, import_fs88.mkdirSync)(gossipDir, { recursive: true });
+    (0, import_fs89.mkdirSync)(gossipDir, { recursive: true });
   } catch {
   }
-  const logStream = (0, import_fs88.createWriteStream)((0, import_path94.join)(gossipDir, "mcp.log"), { flags: "a", mode: 384 });
+  const logStream = (0, import_fs89.createWriteStream)((0, import_path95.join)(gossipDir, "mcp.log"), { flags: "a", mode: 384 });
   process.stderr.write = ((chunk, ...args) => {
     return logStream.write(chunk, ...args);
   });
@@ -78936,7 +79569,7 @@ try {
 } catch {
 }
 function memoryDirForProject(cwd) {
-  return (0, import_path94.join)((0, import_os8.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
+  return (0, import_path95.join)((0, import_os8.homedir)(), ".claude", "projects", cwd.replaceAll("/", "-"), "memory");
 }
 function dashboardClickableUrl(url2, key) {
   if (!key) return url2;
@@ -78948,7 +79581,7 @@ function detectEnvironment() {
     return { host: "claude-code", supportsNativeAgents: true, nativeAgentDir: ".claude/agents", rulesDir: ".claude/rules", rulesFile: ".claude/rules/gossipcat.md" };
   }
   if (process.env.CURSOR_TRACE_ID || process.env.CURSOR_SESSION_ID || process.env.CURSOR) {
-    return { host: "cursor", supportsNativeAgents: false, nativeAgentDir: null, rulesDir: ".cursor/rules", rulesFile: ".cursor/rules/gossipcat.mdc" };
+    return { host: "cursor", supportsNativeAgents: true, nativeAgentDir: ".claude/agents", rulesDir: ".cursor/rules", rulesFile: ".cursor/rules/gossipcat.mdc" };
   }
   if (process.env.WINDSURF || process.env.WINDSURF_SESSION_ID) {
     return { host: "windsurf", supportsNativeAgents: false, nativeAgentDir: null, rulesDir: ".", rulesFile: ".windsurfrules" };
@@ -79011,14 +79644,14 @@ var _pendingPlanData = /* @__PURE__ */ new Map();
 var _utilityGuardSnapshots = /* @__PURE__ */ new Map();
 var _modules = null;
 function lookupFindingSeverity(findingId, projectRoot) {
-  const { existsSync: existsSync73, readdirSync: readdirSync22, readFileSync: readFileSync68 } = require("fs");
-  const { join: join90 } = require("path");
-  const reportsDir = join90(projectRoot, ".gossip", "consensus-reports");
+  const { existsSync: existsSync73, readdirSync: readdirSync22, readFileSync: readFileSync69 } = require("fs");
+  const { join: join91 } = require("path");
+  const reportsDir = join91(projectRoot, ".gossip", "consensus-reports");
   if (!existsSync73(reportsDir)) return null;
   try {
     const files = readdirSync22(reportsDir).filter((f) => f.endsWith(".json"));
     for (const file2 of files) {
-      const report = JSON.parse(readFileSync68(join90(reportsDir, file2), "utf-8"));
+      const report = JSON.parse(readFileSync69(join91(reportsDir, file2), "utf-8"));
       for (const bucket of ["confirmed", "disputed", "unverified", "unique"]) {
         for (const finding of report[bucket] || []) {
           if (finding.id === findingId && finding.severity) {
@@ -79117,7 +79750,7 @@ async function doBoot() {
   const agentConfigs = m.configToAgentConfigs(config2);
   ctx.keychain = new m.Keychain();
   const { existsSync: pidExists, readFileSync: readPid, writeFileSync: writePid, unlinkSync: delPid } = require("fs");
-  const pidFile = (0, import_path94.join)(process.cwd(), ".gossip", "relay.pid");
+  const pidFile = (0, import_path95.join)(process.cwd(), ".gossip", "relay.pid");
   if (pidExists(pidFile)) {
     const oldPid = parseInt(readPid(pidFile, "utf-8").trim(), 10);
     if (!isNaN(oldPid) && oldPid !== process.pid) {
@@ -79239,10 +79872,10 @@ async function doBoot() {
       { id: ac.id, provider: ac.provider, model: ac.model, base_url: ac.base_url, key_ref: ac.key_ref },
       (s) => ctx.keychain.getKey(s)
     );
-    const { existsSync: existsSync73, readFileSync: readFileSync68 } = require("fs");
-    const { join: join90 } = require("path");
-    const instructionsPath = join90(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
-    const baseInstructions = existsSync73(instructionsPath) ? readFileSync68(instructionsPath, "utf-8") : "";
+    const { existsSync: existsSync73, readFileSync: readFileSync69 } = require("fs");
+    const { join: join91 } = require("path");
+    const instructionsPath = join91(process.cwd(), ".gossip", "agents", ac.id, "instructions.md");
+    const baseInstructions = existsSync73(instructionsPath) ? readFileSync69(instructionsPath, "utf-8") : "";
     const identity = ctx.identityRegistry.get(ac.id);
     const identityBlock = identity ? m.formatIdentityBlock(identity) + "\n" : "";
     const instructions = (identityBlock + baseInstructions).trim() || void 0;
@@ -79294,8 +79927,9 @@ async function doBoot() {
     if (!mainKey) {
       mainProvider = "none";
       config2.main_agent.provider = "none";
-      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)
+      if (env.host === "claude-code" || env.host === "cursor") {
+        const hostLabel = env.host === "cursor" ? "Cursor" : "Claude Code";
+        process.stderr.write(`[gossipcat] \u2705 Native ${hostLabel} 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
@@ -80120,6 +80754,56 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       return { content: [{ type: "text", text: `Sent reply to dashboard (chat_id ${chat_id}).` }] };
     }
   );
+  server.tool(
+    "gossip_ask",
+    `Dashboard bridge ONLY: ask the dashboard chat (identified by chat_id) a structured selection question. The dashboard renders radios (single-select) or checkboxes (multiSelect) plus an optional free-text "Other"; the user's answer comes back to you as a NORMAL channel turn (a later message prefixed "[answer qid=\u2026]"). This is the dashboard-answerable parallel to the terminal-only AskUserQuestion \u2014 use it when a <channel source="gossipcat" chat_id="..."> dashboard chat is active. NON-BLOCKING: returns at once; do NOT wait for the answer in this call. Pass the chat_id verbatim. Returns an error (no side effect) when no matching dashboard bridge stream is open.`,
+    {
+      chat_id: external_exports.string().describe('The chat_id verbatim from the <channel ... chat_id="..."> dashboard message.'),
+      questions: external_exports.array(
+        external_exports.object({
+          header: external_exports.string().describe('Short label for the question (e.g. "Approach").'),
+          question: external_exports.string().describe("The prompt text shown above the options."),
+          multiSelect: external_exports.boolean().optional().describe("true \u2192 checkboxes (multiple allowed); false/omitted \u2192 radios (one)."),
+          options: external_exports.array(
+            external_exports.object({
+              label: external_exports.string().describe("The option label the user selects; must be unique within the question."),
+              description: external_exports.string().optional().describe("Optional one-line clarification shown under the label.")
+            })
+          ).describe("Selectable options (\u22648)."),
+          allowOther: external_exports.boolean().optional().describe('When true, the dashboard shows a free-text "Other" input.')
+        })
+      ).describe("1\u20134 questions, each with \u22648 options.")
+    },
+    async ({ chat_id, questions }) => {
+      if (typeof chat_id !== "string" || chat_id.trim().length === 0) {
+        return { content: [{ type: "text", text: "gossip_ask error: chat_id is required." }], isError: true };
+      }
+      if (!ctx.relay) {
+        return { content: [{ type: "text", text: "gossip_ask error: no dashboard bridge is active (relay not started)." }], isError: true };
+      }
+      const { validateAskQuestions: validateAskQuestions2 } = await Promise.resolve().then(() => (init_src5(), src_exports4));
+      const validated = validateAskQuestions2(questions);
+      if ("error" in validated) {
+        return { content: [{ type: "text", text: `gossip_ask error: ${validated.error}.` }], isError: true };
+      }
+      const qid = (0, import_crypto37.randomUUID)();
+      let emitted = false;
+      try {
+        emitted = ctx.relay.emitBridgeQuestion(chat_id, qid, validated.questions) === true;
+      } catch {
+        emitted = false;
+      }
+      if (!emitted) {
+        return {
+          content: [{ type: "text", text: `gossip_ask error: no open dashboard bridge stream for chat_id "${chat_id}". This tool only sends to the dashboard channel.` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: `Asked the dashboard (qid=${qid}); the user's answer will arrive as a channel turn prefixed "[answer qid=${qid}]". Do not wait for it here.` }]
+      };
+    }
+  );
   server.tool(
     "gossip_status",
     "Check Gossip Mesh system status, host environment, available agents, dashboard URL/key, and agent list with provider/model/skills. Pass slim:true to skip the handbook inline (~21KB savings) on reconnect refreshes.",
@@ -80177,7 +80861,7 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       }
       try {
         const { readFileSync: rfHealth } = await import("fs");
-        const healthPath = (0, import_path94.join)(process.cwd(), ".gossip", "skill-runner-health.json");
+        const healthPath = (0, import_path95.join)(process.cwd(), ".gossip", "skill-runner-health.json");
         const raw = rfHealth(healthPath, "utf8");
         const h = JSON.parse(raw);
         const lastMs = h.last_run_at ? new Date(h.last_run_at).getTime() : NaN;
@@ -80193,9 +80877,9 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
         lines.push("  Skill graduation: never run since session start (expected after first gossip_collect)");
       }
       try {
-        const { readFileSync: readFileSync68 } = await import("fs");
-        const quotaPath = (0, import_path94.join)(process.cwd(), ".gossip", "quota-state.json");
-        const quotaRaw = readFileSync68(quotaPath, "utf8");
+        const { readFileSync: readFileSync69 } = await import("fs");
+        const quotaPath = (0, import_path95.join)(process.cwd(), ".gossip", "quota-state.json");
+        const quotaRaw = readFileSync69(quotaPath, "utf8");
         const quotaState = JSON.parse(quotaRaw);
         for (const [provider, state] of Object.entries(quotaState)) {
           const now = Date.now();
@@ -80247,7 +80931,7 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       }
       try {
         const { existsSync: hookExists } = await import("fs");
-        const hookScriptPath = (0, import_path94.join)(process.cwd(), ".claude", "hooks", "worktree-sandbox.sh");
+        const hookScriptPath = (0, import_path95.join)(process.cwd(), ".claude", "hooks", "worktree-sandbox.sh");
         const { isWorktreeSandboxHookRegistered: isWorktreeSandboxHookRegistered2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
         if (hookExists(hookScriptPath) && !isWorktreeSandboxHookRegistered2(process.cwd())) {
           lines.push("  \u26A0\uFE0F Sandbox: worktree-sandbox hook installed but UNREGISTERED \u2014 run gossip_setup to re-register");
@@ -80255,21 +80939,21 @@ Note: write-mode classification unavailable on this native-only install \u2014 a
       } catch {
       }
       try {
-        const { readdirSync: readdirSync22, statSync: statSync36, readFileSync: readFileSync68 } = await import("fs");
+        const { readdirSync: readdirSync22, statSync: statSync36, readFileSync: readFileSync69 } = await import("fs");
         const { readJsonlWithRotated: readJsonlRotated1506 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
-        const reportsDir = (0, import_path94.join)(process.cwd(), ".gossip", "consensus-reports");
-        const perfPath = (0, import_path94.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
+        const reportsDir = (0, import_path95.join)(process.cwd(), ".gossip", "consensus-reports");
+        const perfPath = (0, import_path95.join)(process.cwd(), ".gossip", "agent-performance.jsonl");
         const WINDOW_MS3 = 24 * 60 * 60 * 1e3;
         const now = Date.now();
         const recentReports = [];
         try {
           for (const fname of readdirSync22(reportsDir)) {
             if (!fname.endsWith(".json")) continue;
-            const fpath = (0, import_path94.join)(reportsDir, fname);
+            const fpath = (0, import_path95.join)(reportsDir, fname);
             const st = statSync36(fpath);
             if (now - st.mtimeMs > WINDOW_MS3) continue;
             try {
-              const report = JSON.parse(readFileSync68(fpath, "utf8"));
+              const report = JSON.parse(readFileSync69(fpath, "utf8"));
               const isEmpty = (report.confirmed?.length ?? 0) === 0 && (report.disputed?.length ?? 0) === 0 && (report.unverified?.length ?? 0) === 0 && (report.unique?.length ?? 0) === 0 && (report.newFindings?.length ?? 0) === 0 && (report.insights?.length ?? 0) === 0;
               if (isEmpty) continue;
             } catch {
@@ -80643,8 +81327,8 @@ ${body}`
         }
         return { content: [{ type: "text", text: results.join("\n") }] };
       }
-      const { writeFileSync: writeFileSync37, mkdirSync: mkdirSync44, existsSync: existsSync73 } = require("fs");
-      const { join: join90 } = require("path");
+      const { writeFileSync: writeFileSync38, mkdirSync: mkdirSync45, existsSync: existsSync73 } = require("fs");
+      const { join: join91 } = require("path");
       const root = process.cwd();
       const CLAUDE_MODEL_MAP2 = {
         opus: { provider: "anthropic", model: "claude-opus-4-6" },
@@ -80660,8 +81344,8 @@ ${body}`
       let existingConfig = {};
       let existingAgents = {};
       try {
-        const { readFileSync: readFileSync68 } = require("fs");
-        const existing = JSON.parse(readFileSync68(join90(root, ".gossip", "config.json"), "utf-8"));
+        const { readFileSync: readFileSync69 } = require("fs");
+        const existing = JSON.parse(readFileSync69(join91(root, ".gossip", "config.json"), "utf-8"));
         if (existing && typeof existing === "object" && !Array.isArray(existing)) {
           existingConfig = existing;
           if (mode === "merge") existingAgents = existing.agents || {};
@@ -80695,8 +81379,8 @@ ${body}`
             body
           ].join("\n");
           pendingAgentFileWrites.push({
-            dir: join90(root, ".claude", "agents"),
-            path: join90(root, ".claude", "agents", `${agent.id}.md`),
+            dir: join91(root, ".claude", "agents"),
+            path: join91(root, ".claude", "agents", `${agent.id}.md`),
             content: md
           });
           nativeCreated.push(agent.id);
@@ -80717,7 +81401,7 @@ ${body}`
             errors.push(`${agent.id}: custom agent requires "custom_model" field`);
             continue;
           }
-          const nativeFile = join90(root, ".claude", "agents", `${agent.id}.md`);
+          const nativeFile = join91(root, ".claude", "agents", `${agent.id}.md`);
           const wasNative = existingAgents[agent.id]?.native || configAgents[agent.id]?.native || existsSync73(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.`);
@@ -80733,10 +81417,10 @@ ${body}`
           };
           customCreated.push(agent.id);
           if (agent.instructions) {
-            const instrDir = join90(root, ".gossip", "agents", agent.id);
+            const instrDir = join91(root, ".gossip", "agents", agent.id);
             pendingAgentFileWrites.push({
               dir: instrDir,
-              path: join90(instrDir, "instructions.md"),
+              path: join91(instrDir, "instructions.md"),
               content: agent.instructions
             });
           }
@@ -80754,9 +81438,9 @@ ${body}`
       } catch (err) {
         return { content: [{ type: "text", text: `Invalid config: ${err.message}` }] };
       }
-      flushStagedAgentFileWrites(pendingAgentFileWrites, { mkdirSync: mkdirSync44, writeFileSync: writeFileSync37 });
-      mkdirSync44(join90(root, ".gossip"), { recursive: true });
-      writeFileSync37(join90(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
+      flushStagedAgentFileWrites(pendingAgentFileWrites, { mkdirSync: mkdirSync45, writeFileSync: writeFileSync38 });
+      mkdirSync45(join91(root, ".gossip"), { recursive: true });
+      writeFileSync38(join91(root, ".gossip", "config.json"), JSON.stringify(config2, null, 2));
       let hookSummary = "";
       try {
         const { installWorktreeSandboxHook: installWorktreeSandboxHook2, writeOrchestratorRoleMarker: writeOrchestratorRoleMarker2 } = (init_src4(), __toCommonJS(src_exports3));
@@ -80859,10 +81543,13 @@ ${body}`
         }
       }
       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 = join90(root, env.rulesDir);
-      const rulesFile = join90(root, env.rulesFile);
-      mkdirSync44(rulesDir, { recursive: true });
-      writeFileSync37(rulesFile, generateRulesContent(agentList));
+      const rulesDir = join91(root, env.rulesDir);
+      const rulesFile = join91(root, env.rulesFile);
+      mkdirSync45(rulesDir, { recursive: true });
+      writeFileSync38(rulesFile, generateRulesContent(
+        agentList,
+        env.host === "cursor" || env.host === "claude-code" ? env.host : void 0
+      ));
       const lines = [`Host: ${env.host}`, ""];
       if (nativeCreated.length > 0) {
         lines.push(`Native agents created (${nativeCreated.length}):`);
@@ -80948,8 +81635,8 @@ Tip: Native agents may prompt for file write permissions. To auto-allow, add to
       if (agent_id === "auto") {
         try {
           await syncWorkersViaKeychain();
-          const isNullLlm = ctx.mainProvider === "none";
-          if (isNullLlm && env.host === "claude-code") {
+          const isNullLlm = ctx.mainProvider === "none" || ctx.mainProviderConfig === "none";
+          if (isNullLlm && (env.host === "claude-code" || env.host === "cursor")) {
             const agents = ctx.mainAgent.getAgentList?.() ?? [];
             const agentSummary = agents.map(
               (a) => `- ${a.id} (${a.provider}/${a.model}) [${a.skills?.join(", ") || "no skills"}]`
@@ -81166,11 +81853,11 @@ The original signal remains in the audit log but will be excluded from scoring.`
         const fid = finding_id.trim();
         const cwd = process.cwd();
         const findingsPath = require("path").join(cwd, ".gossip", "implementation-findings.jsonl");
-        const { readFileSync: readFileSync68, existsSync: existsSync73, writeFileSync: writeFileSync37, renameSync: renameSync17 } = require("fs");
+        const { readFileSync: readFileSync69, existsSync: existsSync73, writeFileSync: writeFileSync38, renameSync: renameSync18 } = require("fs");
         if (!existsSync73(findingsPath)) {
           return { content: [{ type: "text", text: `No implementation-findings.jsonl found at ${findingsPath}` }] };
         }
-        const lines = readFileSync68(findingsPath, "utf-8").split("\n");
+        const lines = readFileSync69(findingsPath, "utf-8").split("\n");
         let matched = false;
         let alreadyTarget = false;
         let matchedEntry = null;
@@ -81226,8 +81913,8 @@ The original signal remains in the audit log but will be excluded from scoring.`
         }
         try {
           const tmp = findingsPath + ".tmp." + Date.now();
-          writeFileSync37(tmp, newLines.join("\n"));
-          renameSync17(tmp, findingsPath);
+          writeFileSync38(tmp, newLines.join("\n"));
+          renameSync18(tmp, findingsPath);
         } catch (err) {
           return { content: [{ type: "text", text: `Failed to write findings: ${err.message}` }] };
         }
@@ -81258,18 +81945,18 @@ The original signal remains in the audit log but will be excluded from scoring.`
           return { content: [{ type: "text", text: "Error: consensus_id is required for bulk_from_consensus." }] };
         }
         try {
-          const { readFileSync: readFileSync68 } = await import("fs");
-          const { join: join90 } = await import("path");
-          const reportPath = join90(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
+          const { readFileSync: readFileSync69 } = await import("fs");
+          const { join: join91 } = await import("path");
+          const reportPath = join91(process.cwd(), ".gossip", "consensus-reports", `${consensus_id}.json`);
           let report;
           try {
-            report = JSON.parse(readFileSync68(reportPath, "utf-8"));
+            report = JSON.parse(readFileSync69(reportPath, "utf-8"));
           } catch {
             return { content: [{ type: "text", text: `Error: consensus report not found: ${consensus_id}` }] };
           }
           const existingFindingIds = /* @__PURE__ */ new Set();
           try {
-            const perfPath = join90(process.cwd(), ".gossip", "agent-performance.jsonl");
+            const perfPath = join91(process.cwd(), ".gossip", "agent-performance.jsonl");
             const { readJsonlWithRotated: readJsonlRotated2570 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
             const lines = readJsonlRotated2570(perfPath).split("\n").filter(Boolean);
             for (const line of lines) {
@@ -82317,16 +83004,16 @@ ${preview}` }]
       const { SkillGapTracker: SkillGapTracker2, parseSkillFrontmatter: parseSkillFrontmatter2, normalizeSkillName: normalizeSkillName2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
       const tracker = new SkillGapTracker2(process.cwd());
       if (skills && skills.length > 0) {
-        const { writeFileSync: writeFileSync37, mkdirSync: mkdirSync44, existsSync: existsSync73, readFileSync: readFileSync68 } = require("fs");
-        const { join: join90 } = require("path");
-        const dir = join90(process.cwd(), ".gossip", "skills");
-        mkdirSync44(dir, { recursive: true });
+        const { writeFileSync: writeFileSync38, mkdirSync: mkdirSync45, existsSync: existsSync73, readFileSync: readFileSync69 } = require("fs");
+        const { join: join91 } = require("path");
+        const dir = join91(process.cwd(), ".gossip", "skills");
+        mkdirSync45(dir, { recursive: true });
         const results = [];
         for (const sk of skills) {
           const name = normalizeSkillName2(sk.name);
-          const filePath = join90(dir, `${name}.md`);
+          const filePath = join91(dir, `${name}.md`);
           if (existsSync73(filePath)) {
-            const existing = readFileSync68(filePath, "utf-8");
+            const existing = readFileSync69(filePath, "utf-8");
             const fm = parseSkillFrontmatter2(existing);
             if (fm) {
               if (fm.generated_by === "manual") {
@@ -82343,7 +83030,7 @@ ${preview}` }]
               }
             }
           }
-          writeFileSync37(filePath, sk.content);
+          writeFileSync38(filePath, sk.content);
           tracker.recordResolution(name);
           results.push(`Created .gossip/skills/${name}.md`);
         }
@@ -83166,9 +83853,9 @@ ${p.user}
       max_events: external_exports.number().int().positive().max(WATCH_MAX_EVENTS).optional().describe(`Cap events returned (default ${WATCH_MAX_EVENTS}).`)
     },
     async ({ cursor, max_events }) => {
-      const { join: join90 } = await import("node:path");
+      const { join: join91 } = await import("node:path");
       const { readJsonlWithRotated: readJsonlWithRotated2 } = await Promise.resolve().then(() => (init_src4(), src_exports3));
-      const perfPath = join90(process.cwd(), ".gossip", "agent-performance.jsonl");
+      const perfPath = join91(process.cwd(), ".gossip", "agent-performance.jsonl");
       const raw = readJsonlWithRotated2(perfPath);
       const result = filterWatchEvents(raw, { cursor, maxEvents: max_events });
       return { content: [{ type: "text", text: JSON.stringify(result) }] };