@neuroverseos/governance 0.8.0 → 0.8.1

package/dist/{chunk-MC6O5GV5.js → chunk-ETDIEVAX.js}

@@ -1,6 +1,6 @@
 import {
   getLens
-} from "./chunk-VGFDMPVB.js";
+} from "./chunk-F2LWMOM5.js";
 import {
   loadWorld
 } from "./chunk-I4RTIMLX.js";
@@ -8,91 +8,166 @@ import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
 
+// src/radiant/core/compress.ts
+function compressWorldmodel(content) {
+  const lines = [];
+  const missionMatch = content.match(/##\s*Mission\s*\n+(?:<!--[\s\S]*?-->\s*\n+)?(.*?)(?:\n\n|\n##|$)/s);
+  if (missionMatch) {
+    const mission = missionMatch[1].trim().split("\n")[0];
+    lines.push(`Mission: ${mission}`);
+  }
+  const domainMatches = content.matchAll(/###\s+([^\n]+)/g);
+  const domains = [];
+  for (const m of domainMatches) {
+    const name = m[1].trim();
+    if (name !== "Skills" && name !== "Values" && !name.startsWith("####")) {
+      domains.push(name);
+    }
+  }
+  if (domains.length > 0) {
+    lines.push(`Domains: ${domains.join(", ")}`);
+  }
+  const invariantSection = content.match(/(?:Invariants|## Invariants|invariants)([\s\S]*?)(?:\n#|\n---|\n\n\n)/i);
+  if (invariantSection) {
+    const invLines = invariantSection[1].match(/^[-*]\s+`?([^`\n]+)/gm);
+    if (invLines) {
+      lines.push("\nInvariants:");
+      for (const inv of invLines.slice(0, 10)) {
+        lines.push(inv.trim());
+      }
+    }
+  }
+  const prioritySection = content.match(/(?:Decision Priorities|## Decision Priorities)([\s\S]*?)(?:\n#|\n---|\n\n\n)/i);
+  if (prioritySection) {
+    const priLines = prioritySection[1].match(/^[-*]\s+.+>.+/gm);
+    if (priLines) {
+      lines.push("\nPriorities:");
+      for (const pri of priLines.slice(0, 10)) {
+        lines.push(pri.trim());
+      }
+    }
+  }
+  const signalSection = content.match(/(?:## Signals)([\s\S]*?)(?:\n#|\n---|\n\n\n)/i);
+  if (signalSection) {
+    const sigLines = signalSection[1].match(/^[-*]\s+(\w+)/gm);
+    if (sigLines) {
+      lines.push(`
+Signals: ${sigLines.map((s) => s.replace(/^[-*]\s+/, "")).join(", ")}`);
+    }
+  }
+  const driftSection = content.match(/(?:Drift Behaviors|## Drift Behaviors)([\s\S]*?)(?:\n#|\n---|\n\n\n)/i);
+  if (driftSection) {
+    const driftLines = driftSection[1].match(/^[-*]\s+(.+)/gm);
+    if (driftLines) {
+      lines.push("\nDrift behaviors:");
+      for (const d of driftLines.slice(0, 5)) {
+        lines.push(d.trim());
+      }
+    }
+  }
+  const compressed = lines.join("\n");
+  if (compressed.length < 50) {
+    return content.slice(0, 2e3) + "\n[truncated]";
+  }
+  return compressed;
+}
+function compressExocortex(ctx) {
+  const lines = [];
+  if (ctx.attention) {
+    lines.push(`Attention: ${firstMeaningfulLine(ctx.attention)}`);
+  }
+  if (ctx.goals) {
+    lines.push(`Goals: ${firstNLines(ctx.goals, 3)}`);
+  }
+  if (ctx.sprint) {
+    lines.push(`Sprint: ${firstNLines(ctx.sprint, 3)}`);
+  }
+  if (ctx.identity) {
+    lines.push(`Identity: ${firstMeaningfulLine(ctx.identity)}`);
+  }
+  if (ctx.organization) {
+    lines.push(`Org: ${firstMeaningfulLine(ctx.organization)}`);
+  }
+  return lines.join("\n");
+}
+function compressLens(lens) {
+  return {
+    evaluationQuestions: lens.primary_frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n"),
+    scoringRubric: lens.primary_frame.scoring_rubric,
+    forbiddenPhrases: lens.forbidden_phrases.join(", "),
+    jargonTranslations: Object.entries(lens.vocabulary.jargon_translations).map(([k, v]) => `${k} \u2192 ${v}`).join("; "),
+    strategicPatterns: lens.strategic_patterns.slice(0, 5).join("\n")
+  };
+}
+function compressPriorReads(reads) {
+  if (reads.length === 0) return "";
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const read of reads) {
+    for (const name of read.patternNames) {
+      patternCounts.set(name, (patternCounts.get(name) ?? 0) + 1);
+    }
+  }
+  const sorted = [...patternCounts.entries()].sort((a, b) => b[1] - a[1]);
+  if (sorted.length === 0) {
+    return `${reads.length} prior reads, no patterns extracted.`;
+  }
+  const patternList = sorted.map(([name, count]) => `${name} (${count}x)`).join(", ");
+  return `${reads.length} prior reads. Patterns seen: ${patternList}. If these recur, note persistence.`;
+}
+function firstMeaningfulLine(text) {
+  const lines = text.split("\n").filter((l) => {
+    const t = l.trim();
+    return t.length > 0 && !t.startsWith("#") && !t.startsWith("<!--");
+  });
+  return lines[0]?.slice(0, 200) ?? "";
+}
+function firstNLines(text, n) {
+  const lines = text.split("\n").filter((l) => {
+    const t = l.trim();
+    return t.length > 0 && !t.startsWith("#") && !t.startsWith("<!--");
+  });
+  return lines.slice(0, n).map((l) => l.slice(0, 150)).join("; ");
+}
+
 // src/radiant/core/prompt.ts
 function composeSystemPrompt(worldmodelContent, lens) {
-  const sections = [];
-  sections.push(
-    `## Worldmodel
-
-You are operating inside a governed environment. The worldmodel below
-defines the invariants, signals, decision priorities, and behavioral
-expectations for this organization. Every response you produce must
-be grounded in this worldmodel.
-
-` + worldmodelContent
-  );
-  const frame = lens.primary_frame;
-  const questionsBlock = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
-  const overlapsBlock = frame.overlaps.map(
-    (o) => `- ${o.domains[0]} + ${o.domains[1]} = **${o.emergent_state}**: ${o.description}`
-  ).join("\n");
-  sections.push(
-    `## How to Think (Analytical Frame: ${lens.name})
-
-${frame.scoring_rubric}
+  const compressedWorld = compressWorldmodel(worldmodelContent);
+  const cl = compressLens(lens);
+  const overlapsBlock = lens.primary_frame.overlaps.map((o) => `${o.domains[0]} + ${o.domains[1]} = ${o.emergent_state}`).join("\n");
+  return [
+    // Section 1: Compressed worldmodel
+    `## Worldmodel (compressed)
 
-### Evaluation questions to reason through
+${compressedWorld}`,
+    // Section 2: Analytical frame (evaluation questions + rubric)
+    `## How to Think
 
-${questionsBlock}
+${cl.scoringRubric}
 
-### Overlap emergent states
+Questions:
+${cl.evaluationQuestions}
 
-${overlapsBlock}
+Overlaps: ${overlapsBlock}
+Center: ${lens.primary_frame.center_identity}
 
-### Center identity
-
-When all dimensions integrate fully: **${frame.center_identity}**. Surface this sparingly \u2014 only when the integration is genuinely complete.`
-  );
-  const vocabPreferred = Object.entries(lens.vocabulary.preferred).map(([generic, native]) => `- "${generic}" \u2192 **${native}**`).join("\n");
-  const vocabArchitecture = lens.vocabulary.architecture.map((t) => `\`${t}\``).join(", ");
-  const vocabProperNouns = lens.vocabulary.proper_nouns.map((n) => `**${n}**`).join(", ");
-  const strategicBlock = lens.strategic_patterns.map((p) => `- ${p}`).join("\n");
-  sections.push(
-    `## How to Speak (Voice: ${lens.name})
+Translate before output: ${cl.jargonTranslations}`,
+    // Section 3: Voice (compressed — register + key rules only)
+    `## Voice: ${lens.name}
 
 Register: ${lens.voice.register}
-
-Rules:
-- Active voice: ${lens.voice.active_voice}
-- Named specificity (people, places, numbers): ${lens.voice.specificity}
-- Hype vocabulary: ${lens.voice.hype_vocabulary}
-- Hedging / qualified phrasing: ${lens.voice.hedging}
-- Playfulness: ${lens.voice.playfulness}
-- Close with strategic frame: ${lens.voice.close_with_strategic_frame}
-- Honesty about failure: ${lens.voice.honesty_about_failure}
-
-### Output translation discipline
+Active voice: ${lens.voice.active_voice}. Specificity: ${lens.voice.specificity}. Hedging: ${lens.voice.hedging}. Hype: ${lens.voice.hype_vocabulary}. Honesty about failure: ${lens.voice.honesty_about_failure}.
 
 ${lens.voice.output_translation}
 
-### Vocabulary
-
-Proper nouns (use literally): ${vocabProperNouns}
-
-Preferred term substitutions:
-${vocabPreferred}
-
-Architecture vocabulary: ${vocabArchitecture}
-
-### Strategic decision patterns
-
-When recommending action, these patterns reflect how this organization resolves tradeoffs:
-
-${strategicBlock}`
-  );
-  const forbiddenBlock = lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
-  sections.push(
+Strategic patterns:
+${cl.strategicPatterns}`,
+    // Section 4: Guardrails (forbidden phrases as comma-separated, not bulleted)
     `## Guardrails
 
-Do NOT use any of these phrases in your response. If you catch yourself
-reaching for one, rephrase in direct, active, specific language instead.
+Do NOT use: ${cl.forbiddenPhrases}
 
-${forbiddenBlock}
-
-If your response would violate a worldmodel invariant, state the conflict
-explicitly and propose an alternative that honors the invariant.`
-  );
-  return sections.join("\n\n---\n\n");
+If a response would violate a worldmodel invariant, state the conflict and propose an alternative.`
+  ].join("\n\n---\n\n");
 }
 
 // src/radiant/core/voice-check.ts
@@ -390,18 +465,481 @@ function createMockGitHubAdapter(fixedEvents) {
   return async () => fixedEvents;
 }
 
-// src/radiant/adapters/exocortex.ts
-import { readFileSync, existsSync, readdirSync, statSync } from "fs";
-import { join, resolve } from "path";
-function readExocortex(dirPath) {
+// src/radiant/adapters/discord.ts
+async function fetchDiscordActivity(guildId, token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perChannel = options.perChannel ?? 100;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const headers = {
+    Authorization: `Bot ${token}`,
+    "Content-Type": "application/json"
+  };
+  const channels = await fetchJSON2(
+    `https://discord.com/api/v10/guilds/${guildId}/channels`,
+    headers
+  );
+  const textChannels = channels.filter((c) => {
+    if (c.type !== 0) return false;
+    if (options.channelIds && options.channelIds.length > 0) {
+      return options.channelIds.includes(c.id);
+    }
+    if (options.visibility === "public") {
+      return !c.name.startsWith("private-") && !c.nsfw;
+    }
+    return true;
+  });
+  const events = [];
+  let totalMessages = 0;
+  let helpRequests = 0;
+  let unresolvedThreads = 0;
+  let newcomerMessages = 0;
+  const responseTimes = [];
+  const participants = /* @__PURE__ */ new Set();
+  const knownParticipants = /* @__PURE__ */ new Set();
+  const topicCounts = /* @__PURE__ */ new Map();
+  for (const channel of textChannels.slice(0, 15)) {
+    try {
+      const messages = await fetchJSON2(
+        `https://discord.com/api/v10/channels/${channel.id}/messages?limit=${perChannel}`,
+        headers
+      );
+      const inWindow = messages.filter(
+        (m) => new Date(m.timestamp) >= since
+      );
+      totalMessages += inWindow.length;
+      const topic = channel.name.replace(/-/g, " ");
+      topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + inWindow.length);
+      for (const msg of inWindow) {
+        const actor = mapDiscordUser(msg.author);
+        participants.add(actor.id);
+        const lowerContent = msg.content.toLowerCase();
+        if (lowerContent.includes("help") || lowerContent.includes("stuck") || lowerContent.includes("how do i") || lowerContent.includes("anyone know")) {
+          helpRequests++;
+        }
+        if (msg.referenced_message) {
+          const refTime = new Date(msg.referenced_message.timestamp).getTime();
+          const msgTime = new Date(msg.timestamp).getTime();
+          const diffMinutes = (msgTime - refTime) / 6e4;
+          if (diffMinutes > 0 && diffMinutes < 10080) {
+            responseTimes.push(diffMinutes);
+          }
+        }
+        events.push({
+          id: `discord-${msg.id}`,
+          timestamp: msg.timestamp,
+          actor,
+          kind: "discord_message",
+          content: msg.content.slice(0, 500),
+          respondsTo: msg.referenced_message ? {
+            eventId: `discord-${msg.referenced_message.id}`,
+            actor: mapDiscordUser(msg.referenced_message.author)
+          } : void 0,
+          metadata: {
+            channel: channel.name,
+            guildId
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  const avgResponseMinutes = responseTimes.length > 0 ? responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length : null;
+  const topTopics = [...topicCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([t]) => t);
+  const signals = {
+    totalMessages,
+    activeChannels: textChannels.length,
+    uniqueParticipants: participants.size,
+    avgResponseMinutes: avgResponseMinutes ? Math.round(avgResponseMinutes) : null,
+    helpRequests,
+    unresolvedThreads,
+    topTopics,
+    newcomerMessages
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatDiscordSignalsForPrompt(signals) {
+  if (signals.totalMessages === 0) return "";
+  const lines = [
+    "## Discord Activity (conversational behavior)",
+    "",
+    `${signals.totalMessages} messages across ${signals.activeChannels} channels.`,
+    `${signals.uniqueParticipants} unique participants.`
+  ];
+  if (signals.avgResponseMinutes !== null) {
+    lines.push(`Average response time: ${signals.avgResponseMinutes} minutes.`);
+  }
+  if (signals.helpRequests > 0) {
+    lines.push(`${signals.helpRequests} help requests detected.`);
+  }
+  if (signals.unresolvedThreads > 0) {
+    lines.push(`${signals.unresolvedThreads} unresolved threads.`);
+  }
+  if (signals.topTopics.length > 0) {
+    lines.push(`Top discussion topics: ${signals.topTopics.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Compare conversational activity against GitHub shipping activity.");
+  lines.push("Where debates happen in Discord but nothing ships in GitHub, name the gap.");
+  lines.push("Where work ships in GitHub but nobody discusses it in Discord, name the visibility gap.");
+  return lines.join("\n");
+}
+function mapDiscordUser(user) {
+  return {
+    id: user.username,
+    kind: user.bot ? "bot" : "human",
+    name: user.username
+  };
+}
+async function fetchJSON2(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 404 || res.status === 403) return [];
+    throw new Error(`Discord API error ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+  return await res.json();
+}
+
+// src/radiant/adapters/slack.ts
+async function fetchSlackActivity(token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perChannel = options.perChannel ?? 100;
+  const oldest = String(
+    Math.floor((Date.now() - windowDays * 24 * 60 * 60 * 1e3) / 1e3)
+  );
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const channelsResponse = await fetchSlackAPI("https://slack.com/api/conversations.list?types=public_channel&limit=200", headers);
+  let channels = channelsResponse.channels ?? [];
+  if (options.channelIds && options.channelIds.length > 0) {
+    const ids = new Set(options.channelIds);
+    channels = channels.filter((c) => ids.has(c.id));
+  }
+  if (options.visibility === "public") {
+    channels = channels.filter((c) => !c.is_private && !c.is_archived);
+  }
+  const events = [];
+  let totalMessages = 0;
+  let reactionCount = 0;
+  let unresolvedThreads = 0;
+  const responseTimes = [];
+  const participants = /* @__PURE__ */ new Set();
+  const externalParticipants = /* @__PURE__ */ new Set();
+  const channelMessageCounts = /* @__PURE__ */ new Map();
+  for (const channel of channels.slice(0, 15)) {
+    try {
+      const historyResponse = await fetchSlackAPI(
+        `https://slack.com/api/conversations.history?channel=${channel.id}&limit=${perChannel}&oldest=${oldest}`,
+        headers
+      );
+      const messages = historyResponse.messages ?? [];
+      totalMessages += messages.length;
+      channelMessageCounts.set(channel.name, messages.length);
+      for (const msg of messages) {
+        if (msg.subtype === "channel_join" || msg.subtype === "channel_leave") continue;
+        const actor = mapSlackUser(msg.user ?? "unknown");
+        participants.add(actor.id);
+        if (msg.reactions) {
+          reactionCount += msg.reactions.reduce(
+            (sum, r) => sum + (r.count ?? 0),
+            0
+          );
+        }
+        if (msg.thread_ts && msg.thread_ts !== msg.ts) {
+          const parentTs = parseFloat(msg.thread_ts) * 1e3;
+          const msgTs = parseFloat(msg.ts) * 1e3;
+          const diffMinutes = (msgTs - parentTs) / 6e4;
+          if (diffMinutes > 0 && diffMinutes < 10080) {
+            responseTimes.push(diffMinutes);
+          }
+        }
+        if (msg.thread_ts === msg.ts && (!msg.reply_count || msg.reply_count === 0)) {
+          if (msg.text && (msg.text.includes("?") || msg.text.toLowerCase().includes("help"))) {
+            unresolvedThreads++;
+          }
+        }
+        const timestamp = new Date(parseFloat(msg.ts) * 1e3).toISOString();
+        events.push({
+          id: `slack-${msg.ts}`,
+          timestamp,
+          actor,
+          kind: "slack_message",
+          content: (msg.text ?? "").slice(0, 500),
+          respondsTo: msg.thread_ts && msg.thread_ts !== msg.ts ? {
+            eventId: `slack-${msg.thread_ts}`,
+            actor: { id: "thread-parent", kind: "unknown" }
+          } : void 0,
+          metadata: {
+            channel: channel.name,
+            isPrivate: channel.is_private,
+            hasReactions: (msg.reactions?.length ?? 0) > 0
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  const avgResponseMinutes = responseTimes.length > 0 ? Math.round(responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length) : null;
+  const topChannels = [...channelMessageCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name]) => name);
+  const signals = {
+    totalMessages,
+    activeChannels: channelMessageCounts.size,
+    uniqueParticipants: participants.size,
+    avgResponseMinutes,
+    externalParticipants: externalParticipants.size,
+    unresolvedThreads,
+    topChannels,
+    reactionCount
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatSlackSignalsForPrompt(signals) {
+  if (signals.totalMessages === 0) return "";
+  const lines = [
+    "## Slack Activity (external coordination)",
+    "",
+    `${signals.totalMessages} messages across ${signals.activeChannels} channels.`,
+    `${signals.uniqueParticipants} unique participants.`
+  ];
+  if (signals.avgResponseMinutes !== null) {
+    lines.push(`Average thread response time: ${signals.avgResponseMinutes} minutes.`);
+  }
+  if (signals.unresolvedThreads > 0) {
+    lines.push(`${signals.unresolvedThreads} questions/threads with no reply.`);
+  }
+  if (signals.reactionCount > 0) {
+    lines.push(`${signals.reactionCount} reactions (engagement signal).`);
+  }
+  if (signals.topChannels.length > 0) {
+    lines.push(`Most active channels: ${signals.topChannels.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Slack carries external coordination \u2014 partner and client communication.");
+  lines.push("Compare partner engagement against internal activity. Where partners are");
+  lines.push("active but internal follow-through is low, name the gap.");
+  return lines.join("\n");
+}
+function mapSlackUser(userId) {
+  return {
+    id: userId,
+    kind: "human",
+    name: userId
+  };
+}
+async function fetchSlackAPI(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    throw new Error(`Slack API error ${res.status}: ${(await res.text()).slice(0, 300)}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error ?? "unknown"}`);
+  }
+  return data;
+}
+
+// src/radiant/adapters/notion.ts
+async function fetchNotionActivity(token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const maxPages = options.maxPages ?? 100;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Notion-Version": "2022-06-28",
+    "Content-Type": "application/json"
+  };
+  const searchResponse = await fetchNotionAPI("https://api.notion.com/v1/search", headers, {
+    method: "POST",
+    body: JSON.stringify({
+      filter: { property: "object", value: "page" },
+      sort: { direction: "descending", timestamp: "last_edited_time" },
+      page_size: maxPages
+    })
+  });
+  const pages = searchResponse.results ?? [];
+  const events = [];
+  const editors = /* @__PURE__ */ new Set();
+  let pagesCreated = 0;
+  let pagesUpdated = 0;
+  let stalePages = 0;
+  const editAges = [];
+  const topPages = [];
+  const now = Date.now();
+  for (const page of pages) {
+    const lastEdited = new Date(page.last_edited_time);
+    const created = new Date(page.created_time);
+    const daysSinceEdit = (now - lastEdited.getTime()) / (24 * 60 * 60 * 1e3);
+    editAges.push(daysSinceEdit);
+    if (daysSinceEdit > 30) stalePages++;
+    const title = extractTitle(page);
+    const editorId = page.last_edited_by?.id ?? "unknown";
+    editors.add(editorId);
+    if (lastEdited >= since) {
+      const isNew = created >= since;
+      if (isNew) pagesCreated++;
+      else pagesUpdated++;
+      topPages.push({ title, editedAt: page.last_edited_time });
+      events.push({
+        id: `notion-${page.id}`,
+        timestamp: page.last_edited_time,
+        actor: {
+          id: editorId,
+          kind: "human",
+          name: editorId
+        },
+        kind: isNew ? "doc_created" : "doc_updated",
+        content: `${isNew ? "Created" : "Updated"}: ${title}`,
+        metadata: {
+          pageId: page.id,
+          url: page.url,
+          createdAt: page.created_time
+        }
+      });
+    }
+  }
+  const avgDaysSinceEdit = editAges.length > 0 ? Math.round(editAges.reduce((a, b) => a + b, 0) / editAges.length) : null;
+  const signals = {
+    pagesActive: pagesCreated + pagesUpdated,
+    pagesCreated,
+    pagesUpdated,
+    uniqueEditors: editors.size,
+    stalePages,
+    avgDaysSinceEdit,
+    topPages: topPages.slice(0, 5).map((p) => p.title)
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatNotionSignalsForPrompt(signals) {
+  if (signals.pagesActive === 0 && signals.stalePages === 0) return "";
+  const lines = [
+    "## Notion Activity (documentation behavior)",
+    "",
+    `${signals.pagesActive} pages active in window (${signals.pagesCreated} created, ${signals.pagesUpdated} updated).`,
+    `${signals.uniqueEditors} unique editors.`
+  ];
+  if (signals.stalePages > 0) {
+    lines.push(`${signals.stalePages} pages haven't been touched in 30+ days.`);
+  }
+  if (signals.avgDaysSinceEdit !== null) {
+    lines.push(`Average page age since last edit: ${signals.avgDaysSinceEdit} days.`);
+  }
+  if (signals.topPages.length > 0) {
+    lines.push(`Recently active pages: ${signals.topPages.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Documentation is how the team crystallizes and shares knowledge.");
+  lines.push("High code velocity + low documentation = building without recording.");
+  lines.push("High documentation + low code = planning without shipping.");
+  lines.push("Compare Notion activity against GitHub and Discord to find the balance.");
+  return lines.join("\n");
+}
+function extractTitle(page) {
+  for (const prop of Object.values(page.properties)) {
+    if (prop.type === "title" && prop.title) {
+      return prop.title.map((t) => t.plain_text).join("") || "Untitled";
+    }
+  }
+  return "Untitled";
+}
+async function fetchNotionAPI(url, headers, init) {
+  const res = await fetch(url, {
+    method: init?.method ?? "GET",
+    headers,
+    body: init?.body
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Notion API error ${res.status}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  return await res.json();
+}
+
+// src/radiant/core/discovery.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { join, resolve, basename } from "path";
+import { homedir } from "os";
+function discoverWorlds(options) {
+  const worlds = [];
+  const userDir = options?.userWorldsDir ?? join(homedir(), ".neuroverse", "worlds");
+  if (existsSync(userDir)) {
+    worlds.push(...loadWorldsFromDir(userDir, "user"));
+  }
+  if (options?.explicitWorldsDir) {
+    worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
+  } else if (options?.repoDir) {
+    const repoPaths = [
+      join(options.repoDir, "worlds"),
+      join(options.repoDir, ".neuroverse", "worlds")
+    ];
+    for (const p of repoPaths) {
+      if (existsSync(p)) {
+        worlds.push(...loadWorldsFromDir(p, "repo"));
+        break;
+      }
+    }
+  }
+  const combinedContent = worlds.map((w) => `<!-- world: ${w.name} (${w.source}) -->
+${w.content}`).join("\n\n---\n\n");
+  const summary = worlds.length === 0 ? "no worlds discovered" : worlds.map((w) => `${w.name} (${w.source})`).join(", ");
+  return { worlds, combinedContent, summary };
+}
+function formatActiveWorlds(stack) {
+  if (stack.worlds.length === 0) return "No worlds loaded.";
+  const lines = ["ACTIVE WORLDS", ""];
+  for (const w of stack.worlds) {
+    const sourceLabel = w.source === "base" ? "universal" : w.source === "user" ? "personal" : "this repo";
+    lines.push(`  ${w.name} (${sourceLabel})`);
+  }
+  return lines.join("\n");
+}
+function loadWorldsFromDir(dirPath, source) {
   const dir = resolve(dirPath);
+  if (!existsSync(dir)) return [];
+  const stat = statSync(dir);
+  if (stat.isFile() && dir.endsWith(".md")) {
+    try {
+      return [{
+        name: basename(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        source,
+        path: dir,
+        content: readFileSync(dir, "utf-8")
+      }];
+    } catch {
+      return [];
+    }
+  }
+  if (!stat.isDirectory()) return [];
+  const files = readdirSync(dir).filter(
+    (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
+  ).sort();
+  return files.map((f) => {
+    const fullPath = join(dir, f);
+    return {
+      name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+      source,
+      path: fullPath,
+      content: readFileSync(fullPath, "utf-8")
+    };
+  });
+}
+
+// src/radiant/adapters/exocortex.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+function readExocortex(dirPath, repoName) {
+  const dir = resolve2(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = join(dir, p);
-      if (existsSync(full)) {
+      const full = join2(dir, p);
+      if (existsSync2(full)) {
         try {
-          const content = readFileSync(full, "utf-8").trim();
+          const content = readFileSync2(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -412,16 +950,64 @@ function readExocortex(dirPath) {
     }
     return null;
   }
+  const attention = tryRead("attention.md");
+  const goals = tryRead("goals.md");
+  const identity = tryRead("identity.md", "user.md");
+  const organization = tryRead("org/organization.md", "org/src/organization.md");
+  const methods = tryRead("org/methods.md", "org/src/methods.md");
+  let sprint = null;
+  let projectContext = null;
+  if (repoName) {
+    const projectPaths = [
+      repoName,
+      repoName.toLowerCase(),
+      repoName.replace(/-/g, "_")
+    ];
+    for (const projectDir of projectPaths) {
+      const projectSprint = tryRead(
+        `${projectDir}/src/sprint.md`,
+        `${projectDir}/sprint.md`
+      );
+      if (projectSprint) {
+        sprint = projectSprint;
+        break;
+      }
+    }
+    for (const projectDir of projectPaths) {
+      const roadmap = tryRead(
+        `${projectDir}/roadmap.md`,
+        `${projectDir}/src/roadmap.md`
+      );
+      if (roadmap) {
+        projectContext = roadmap;
+        break;
+      }
+    }
+  }
+  if (!sprint) {
+    sprint = tryRead("sprint.md", "src/sprint.md");
+  }
   const ctx = {
-    attention: tryRead("attention.md"),
-    goals: tryRead("goals.md"),
-    identity: tryRead("identity.md"),
-    sprint: tryRead("sprint.md", "src/sprint.md"),
-    organization: tryRead("org/organization.md", "org/src/organization.md"),
-    methods: tryRead("org/methods.md", "org/src/methods.md"),
+    attention,
+    goals,
+    identity,
+    sprint,
+    organization,
+    methods,
     source: dir,
     filesLoaded
   };
+  if (projectContext && ctx.sprint) {
+    ctx.sprint = `${ctx.sprint}
+
+---
+Project roadmap:
+${projectContext}`;
+  } else if (projectContext) {
+    ctx.sprint = `Project roadmap:
+${projectContext}`;
+    ctx.filesLoaded++;
+  }
   return ctx;
 }
 function formatExocortexForPrompt(ctx) {
@@ -463,14 +1049,14 @@ ${ctx.methods}`);
   return sections.join("\n\n");
 }
 function readTeamExocortices(teamDir) {
-  const dir = resolve(teamDir);
-  if (!existsSync(dir)) return [];
-  const entries = readdirSync(dir);
+  const dir = resolve2(teamDir);
+  if (!existsSync2(dir)) return [];
+  const entries = readdirSync2(dir);
   const results = [];
   for (const entry of entries) {
-    const entryPath = join(dir, entry);
+    const entryPath = join2(dir, entry);
     try {
-      const stat = statSync(entryPath);
+      const stat = statSync2(entryPath);
       if (stat.isDirectory()) {
         const ctx = readExocortex(entryPath);
         if (ctx.filesLoaded > 0) {
@@ -515,14 +1101,14 @@ function summarizeExocortex(ctx) {
 }
 
 // src/radiant/memory/palace.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync3, writeFileSync, mkdirSync, readdirSync as readdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = resolve2(exocortexDir, "radiant", "reads");
+  const dir = resolve3(exocortexDir, "radiant", "reads");
   mkdirSync(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = join2(dir, filename);
+  const filepath = join3(dir, filename);
   const content = `${frontmatter}
 
 ${text}
@@ -531,9 +1117,9 @@ ${text}
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = resolve2(exocortexDir, "radiant");
+  const dir = resolve3(exocortexDir, "radiant");
   mkdirSync(dir, { recursive: true });
-  const filepath = join2(dir, "knowledge.md");
+  const filepath = join3(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -625,9 +1211,9 @@ function updateKnowledge(exocortexDir, persistence, options) {
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!existsSync2(filepath)) return counts;
+  if (!existsSync3(filepath)) return counts;
   try {
-    const content = readFileSync2(filepath, "utf-8");
+    const content = readFileSync3(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -645,13 +1231,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = resolve2(exocortexDir, "radiant", "reads");
-  if (!existsSync2(dir)) return [];
-  const files = readdirSync2(dir).filter((f) => f.endsWith(".md")).sort();
+  const dir = resolve3(exocortexDir, "radiant", "reads");
+  if (!existsSync3(dir)) return [];
+  const files = readdirSync3(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = join2(dir, filename);
-    const content = readFileSync2(filepath, "utf-8");
+    const filepath = join3(dir, filename);
+    const content = readFileSync3(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -1028,15 +1614,17 @@ function buildInterpretationPrompt(input) {
   const eventSample = formatEventSample(input.events, 30);
   const canonicalList = (input.canonicalPatterns ?? []).length > 0 ? `Patterns the organization has already named (use these names if you see them):
 ${input.canonicalPatterns.map((p) => `- ${p}`).join("\n")}` : "No patterns have been named yet. Everything you observe is new.";
+  const compressedWorld = compressWorldmodel(input.worldmodelContent);
+  const cl = compressLens(input.lens);
   const frame = input.lens.primary_frame;
   const evalQuestions = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
-  const forbiddenList = input.lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
-  const jargonTable = Object.entries(input.lens.vocabulary.jargon_translations).map(([internal, plain]) => `  "${internal}" \u2192 "${plain}"`).join("\n");
+  const forbiddenList = cl.forbiddenPhrases;
+  const jargonTable = cl.jargonTranslations;
   return `You are a behavioral intelligence system reading team activity and producing a read for the reader who needs to act on it.
 
-## Context the reader has loaded
+## Worldmodel (compressed)
 
-${input.worldmodelContent}
+${compressedWorld}
 
 ## What happened this window
 
@@ -1227,30 +1815,16 @@ Window: last ${input.windowDays} days \xB7 ${input.eventCount} events
 Lens:   ${input.lens.name}`
   );
   if (input.patterns.length > 0) {
-    const canonical = input.patterns.filter((p) => p.type === "canonical");
-    const candidates = input.patterns.filter((p) => p.type === "candidate");
     let emergentBlock = "EMERGENT\n";
-    if (canonical.length > 0) {
-      for (const p of canonical) {
-        emergentBlock += `
+    for (const p of input.patterns) {
+      emergentBlock += `
   ${p.name}
 `;
-        emergentBlock += `    ${p.description}
+      emergentBlock += `    ${p.description}
 `;
-      }
-    }
-    if (candidates.length > 0) {
-      emergentBlock += "\n  Emergent (candidates \u2014 not yet in worldmodel)\n";
-      for (const p of candidates) {
-        emergentBlock += `
-  ${p.name}  (candidate)
-`;
-        emergentBlock += `    ${p.description}
+      if (p.evidence.cited_invariant) {
+        emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
 `;
-        if (p.evidence.cited_invariant) {
-          emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
-`;
-        }
       }
     }
     sections.push(emergentBlock.trimEnd());
@@ -1462,16 +2036,29 @@ function serializeYAML(obj, indent = 0) {
 async function emergent(input) {
   const lens = resolveLens2(input.lensId);
   const windowDays = input.windowDays ?? 14;
+  let worldStack;
+  let worldmodelContent = input.worldmodelContent;
+  if (!worldmodelContent || worldmodelContent.trim() === "") {
+    worldStack = discoverWorlds({ explicitWorldsDir: input.worldPath });
+    worldmodelContent = worldStack.combinedContent;
+  }
   let statedIntent;
   let exocortexContext;
   let priorReadContext = "";
   if (input.exocortexPath) {
-    exocortexContext = readExocortex(input.exocortexPath);
-    const formatted = formatExocortexForPrompt(exocortexContext);
-    if (formatted) statedIntent = formatted;
+    const repoName = input.scope.type === "repo" ? input.scope.repo : void 0;
+    exocortexContext = readExocortex(input.exocortexPath, repoName);
+    const compressed = compressExocortex(exocortexContext);
+    if (compressed) {
+      statedIntent = `## Stated Intent (from exocortex, compressed)
+
+${compressed}
+
+Compare stated intent against actual GitHub activity. Gaps = drift.`;
+    }
     const priorReads = loadPriorReads(input.exocortexPath);
     if (priorReads.length > 0) {
-      priorReadContext = formatPriorReadsForPrompt(priorReads);
+      priorReadContext = compressPriorReads(priorReads);
     }
   }
   let events;
@@ -1489,6 +2076,40 @@ async function emergent(input) {
       windowDays
     });
   }
+  let adapterSignals = "";
+  const activeAdapters = ["github"];
+  const discordToken = process.env.DISCORD_TOKEN;
+  const discordGuild = process.env.DISCORD_GUILD_ID;
+  if (discordToken && discordGuild) {
+    try {
+      const discord = await fetchDiscordActivity(discordGuild, discordToken, { windowDays });
+      events.push(...discord.events);
+      adapterSignals += "\n\n" + formatDiscordSignalsForPrompt(discord.signals);
+      activeAdapters.push("discord");
+    } catch {
+    }
+  }
+  const slackToken = process.env.SLACK_TOKEN;
+  if (slackToken) {
+    try {
+      const slack = await fetchSlackActivity(slackToken, { windowDays });
+      events.push(...slack.events);
+      adapterSignals += "\n\n" + formatSlackSignalsForPrompt(slack.signals);
+      activeAdapters.push("slack");
+    } catch {
+    }
+  }
+  const notionToken = process.env.NOTION_TOKEN;
+  if (notionToken) {
+    try {
+      const notion = await fetchNotionActivity(notionToken, { windowDays });
+      events.push(...notion.events);
+      adapterSignals += "\n\n" + formatNotionSignalsForPrompt(notion.signals);
+      activeAdapters.push("notion");
+    } catch {
+    }
+  }
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
   const classified = classifyEvents(events);
   const signals = extractSignals(classified);
   const scores = computeScores(signals, input.worldmodelContent !== "");
@@ -1499,7 +2120,7 @@ async function emergent(input) {
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
-    statedIntent: statedIntent ? statedIntent + (priorReadContext ? "\n\n" + priorReadContext : "") : priorReadContext || void 0
+    statedIntent: [statedIntent, adapterSignals, priorReadContext].filter(Boolean).join("\n\n") || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
   const allDescriptions = rewrittenPatterns.map((p) => p.description).join("\n");
@@ -1548,7 +2169,9 @@ async function emergent(input) {
     voiceClean: voiceViolations.length === 0,
     signals,
     scores,
-    eventCount: events.length
+    eventCount: events.length,
+    activeAdapters,
+    worldStack
   };
 }
 function computeScores(signals, worldmodelLoaded) {
@@ -1641,6 +2264,10 @@ function createMockAI(fixedResponse) {
 }
 
 export {
+  compressWorldmodel,
+  compressExocortex,
+  compressLens,
+  compressPriorReads,
   composeSystemPrompt,
   checkForbiddenPhrases,
   think,
@@ -1650,6 +2277,14 @@ export {
   fetchGitHubActivity,
   fetchGitHubOrgActivity,
   createMockGitHubAdapter,
+  fetchDiscordActivity,
+  formatDiscordSignalsForPrompt,
+  fetchSlackActivity,
+  formatSlackSignalsForPrompt,
+  fetchNotionActivity,
+  formatNotionSignalsForPrompt,
+  discoverWorlds,
+  formatActiveWorlds,
   readExocortex,
   formatExocortexForPrompt,
   readTeamExocortices,