@neuroverseos/governance 0.7.0 → 0.8.1

package/dist/radiant/index.cjs

@@ -40,16 +40,30 @@ __export(radiant_exports, {
   classifyActorDomain: () => classifyActorDomain,
   classifyEvents: () => classifyEvents,
   composeSystemPrompt: () => composeSystemPrompt,
+  compressExocortex: () => compressExocortex,
+  compressLens: () => compressLens,
+  compressPriorReads: () => compressPriorReads,
+  compressWorldmodel: () => compressWorldmodel,
   computePersistence: () => computePersistence,
   createAnthropicAI: () => createAnthropicAI,
   createMockAI: () => createMockAI,
   createMockGitHubAdapter: () => createMockGitHubAdapter,
+  discoverWorlds: () => discoverWorlds,
   emergent: () => emergent,
   extractSignals: () => extractSignals,
+  fetchDiscordActivity: () => fetchDiscordActivity,
   fetchGitHubActivity: () => fetchGitHubActivity,
+  fetchGitHubOrgActivity: () => fetchGitHubOrgActivity,
+  fetchNotionActivity: () => fetchNotionActivity,
+  fetchSlackActivity: () => fetchSlackActivity,
+  formatActiveWorlds: () => formatActiveWorlds,
+  formatDiscordSignalsForPrompt: () => formatDiscordSignalsForPrompt,
   formatExocortexForPrompt: () => formatExocortexForPrompt,
+  formatNotionSignalsForPrompt: () => formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt: () => formatPriorReadsForPrompt,
   formatScope: () => formatScope,
+  formatSlackSignalsForPrompt: () => formatSlackSignalsForPrompt,
+  formatTeamExocorticesForPrompt: () => formatTeamExocorticesForPrompt,
   getLens: () => getLens,
   interpretPatterns: () => interpretPatterns,
   isPresent: () => isPresent,
@@ -58,13 +72,16 @@ __export(radiant_exports, {
   listLenses: () => listLenses,
   loadPriorReads: () => loadPriorReads,
   parseRepoScope: () => parseRepoScope,
+  parseScope: () => parseScope,
   presenceAverage: () => presenceAverage,
   readExocortex: () => readExocortex,
+  readTeamExocortices: () => readTeamExocortices,
   render: () => render,
   scoreComposite: () => scoreComposite,
   scoreCyber: () => scoreCyber,
   scoreLife: () => scoreLife,
   scoreNeuroVerse: () => scoreNeuroVerse,
+  sovereignConduitLens: () => sovereignConduitLens,
   summarizeExocortex: () => summarizeExocortex,
   think: () => think,
   updateKnowledge: () => updateKnowledge,
@@ -554,9 +571,290 @@ var aukiBuilderLens = {
   rewrite: aukiBuilderRewrite
 };
 
+// src/radiant/lenses/sovereign-conduit.ts
+var SOVEREIGN_CONDUIT_FRAME = {
+  domains: [
+    "stewardship",
+    "sovereignty",
+    "integration"
+  ],
+  overlaps: [
+    {
+      domains: ["stewardship", "sovereignty"],
+      emergent_state: "Trust",
+      description: "I am safe to be myself. When the system protects AND preserves individual authority, trust emerges \u2014 the feeling that you can think freely because someone is watching the boundaries."
+    },
+    {
+      domains: ["sovereignty", "integration"],
+      emergent_state: "Possibility",
+      description: "My thinking can expand. When individual authority is preserved AND AI extends cognitive capability, possibility opens \u2014 the feeling that you can reach further without losing yourself."
+    },
+    {
+      domains: ["integration", "stewardship"],
+      emergent_state: "Responsibility",
+      description: "Power is used with care. When AI extends capability AND the system protects integrity, responsibility emerges \u2014 the feeling that expansion comes with guardrails, not recklessness."
+    }
+  ],
+  center_identity: "The Sovereign Conduit",
+  evaluation_questions: [
+    "Is the human maintaining authority over their decisions, or is decision ownership quietly shifting to the AI?",
+    "Is the AI extending thinking, or is it replacing thinking? Look for the difference: extension means the human understands and owns the output. Replacement means they accept it without engaging.",
+    "Are the boundaries between human thinking and AI output clear and visible, or are they blurring?",
+    "Is diversity of thought preserved? Are people thinking differently from each other, or is the system funneling everyone into the same patterns?",
+    "Would you feel safe letting a child learn in this system? If not, what specifically makes it unsafe?",
+    "If this felt wrong, could you leave? Is the exit real or theoretical?"
+  ],
+  scoring_rubric: "For any activity, ask: is the human still the author of their decisions? Is the AI helping them think further, or thinking for them? Are the rules of this space clear, fair, and safe \u2014 like the rules at a good friend's house? When something feels off, name the feeling first, then the mechanism. Use everyday language. If a non-technical person couldn't understand the observation, rephrase it until they could.",
+  domain_skills: {
+    "stewardship": [
+      "boundary setting",
+      "risk awareness",
+      "ethical judgment",
+      "system protection",
+      "conflict stabilization",
+      "responsibility signaling",
+      "harm detection",
+      "constraint design"
+    ],
+    "sovereignty": [
+      "independent thinking",
+      "decision ownership",
+      "self-trust",
+      "value clarity",
+      "cognitive resistance",
+      "identity anchoring",
+      "perspective holding",
+      "authentic expression"
+    ],
+    "integration": [
+      "AI collaboration",
+      "cognitive expansion",
+      "prompt framing",
+      "insight synthesis",
+      "signal interpretation",
+      "tool fluency",
+      "co-creation",
+      "iterative thinking"
+    ]
+  },
+  output_translation: {
+    never_surface_in_output: [
+      "Stewardship",
+      "Sovereignty",
+      "Integration"
+    ],
+    surface_freely: [
+      "Trust",
+      "Possibility",
+      "Responsibility",
+      "Sovereign Conduit"
+    ],
+    translation_examples: [
+      {
+        internal_reasoning: "Stewardship is strong",
+        external_expression: "the boundaries are clear and the system feels safe to operate inside"
+      },
+      {
+        internal_reasoning: "Sovereignty is weakening",
+        external_expression: "decision ownership is quietly shifting \u2014 the human is accepting AI output without engaging with it"
+      },
+      {
+        internal_reasoning: "Integration is high but Stewardship is low",
+        external_expression: "the AI is expanding capability fast, but nobody is watching the guardrails \u2014 that's power without responsibility"
+      }
+    ]
+  }
+};
+var SOVEREIGN_CONDUIT_VOCABULARY = {
+  proper_nouns: [
+    "NeuroVerseOS",
+    "Sovereign Conduit",
+    "LifeOS",
+    "CyberOS",
+    "NeuroverseOS"
+  ],
+  preferred: {
+    "worldmodel": "thinking constitution",
+    "invariant": "non-negotiable rule",
+    "governance": "the rules of the space",
+    "alignment": "how well the work matches what was declared",
+    "drift": "quiet shift away from what was intended",
+    "signal": "something observable",
+    "evidence gate": "how much we need to see before we speak",
+    "actor domain": "who did the work \u2014 a person, an AI, or both together",
+    "rendering lens": "how the system speaks",
+    "candidate pattern": "something noticed but not yet named as important",
+    "cognitive liberty": "your right to think for yourself",
+    "homogenization": "everyone being funneled into the same patterns"
+  },
+  architecture: [
+    "thinking constitution",
+    "thinking space",
+    "cognitive extension",
+    "behavioral model",
+    "governance frame",
+    "world file",
+    "cocoon"
+  ],
+  economic: [],
+  framing: [
+    "humanity first",
+    "in constant learning",
+    "in shared teaching",
+    "extension not replacement",
+    "safe to think freely",
+    "the rules of this house",
+    "sovereign over your own thinking",
+    "idea calculator",
+    "Spock in your life",
+    "Jarvis in your life",
+    "funneling into fields",
+    "diversity of thought",
+    "thinking for yourself"
+  ],
+  jargon_translations: {
+    "worldmodel": "thinking constitution",
+    "invariant": "non-negotiable rule",
+    "canonical pattern": "something we're tracking by name",
+    "candidate pattern": "something noticed but not yet tracked",
+    "evidence gate": "how much we need to see before we speak up",
+    "signal extraction": "reading what happened",
+    "alignment score": "how well the work matches what was declared",
+    "actor domain": "who did this \u2014 a person, an AI, or both",
+    "presence-based averaging": "only counting what actually happened",
+    "drift detection": "noticing when things quietly shift",
+    "INSUFFICIENT_EVIDENCE": "not enough to say yet",
+    "UNAVAILABLE": "can't measure this yet",
+    "rendering lens": "how the system speaks to you"
+  }
+};
+var SOVEREIGN_CONDUIT_VOICE = {
+  register: "warm, accessible, teaching. Like a thoughtful parent explaining how the world works \u2014 not talking down, but making the complex feel natural. Use everyday analogies. Name emotions. If a non-technical person couldn't understand the output, it's wrong.",
+  active_voice: "preferred",
+  specificity: "preferred",
+  hype_vocabulary: "forbidden",
+  hedging: "discouraged",
+  playfulness: "allowed",
+  close_with_strategic_frame: "preferred",
+  punchline_move: "sparing",
+  honesty_about_failure: "required",
+  output_translation: `Reason internally through the three-domain frame (Stewardship, Sovereignty, Integration). Express externally through the skills inside each domain and the overlap feelings (Trust, Possibility, Responsibility). Do NOT surface the bucket names as labels. Readers understand "the boundaries feel safe" not "Stewardship is strong." Use everyday analogies \u2014 mom rules, friend's house rules, idea calculator. Name the emotion before the mechanism.`
+};
+var SOVEREIGN_CONDUIT_FORBIDDEN = Object.freeze([
+  // Bucket names as labels
+  "stewardship is",
+  "sovereignty is",
+  "integration is",
+  // AI-assistant hedging
+  "it may be beneficial to consider",
+  "there appears to be",
+  "one possible interpretation",
+  "it might be worth exploring",
+  "consider whether",
+  "it is worth noting",
+  // Corporate
+  "stakeholders",
+  "synergy",
+  "value proposition",
+  "paradigm shift",
+  "best-in-class",
+  "industry-leading",
+  // Cold/mechanical
+  "the system recommends",
+  "analysis suggests",
+  "data indicates",
+  "metrics show",
+  "according to the model"
+]);
+var SOVEREIGN_CONDUIT_PREFERRED = Object.freeze([
+  // Everyday analogies
+  "This is like [everyday analogy]. [What it means].",
+  "Think of it like the rules at a friend's house \u2014 [application].",
+  "The boundaries are [state]. That means [feeling].",
+  // Emotion-first
+  "This feels like [emotion] because [mechanism].",
+  "Trust is [emerging/breaking] here \u2014 [specific evidence].",
+  "Possibility is opening because [evidence]. But [caveat if any].",
+  // Teaching voice
+  "Here's what's actually happening: [plain explanation].",
+  "The question to ask yourself: [question].",
+  "The difference between [A] and [B] matters here: [why].",
+  // Sovereignty checks
+  "Are you still the author of this decision, or did the AI make it for you?",
+  "The AI extended your thinking here. That's working.",
+  "The AI replaced your thinking here. That's the drift to watch.",
+  // Safety
+  "Would you feel safe letting someone learn in this environment? [Why/why not].",
+  "The exit is real \u2014 you can [specific exit path].",
+  "The exit isn't real here \u2014 [what's blocking it]."
+]);
+var SOVEREIGN_CONDUIT_STRATEGIC = Object.freeze([
+  "Safety before expansion \u2014 always. No exception.",
+  "Sovereignty before convenience \u2014 the right to think for yourself is not a feature to optimize away.",
+  "Extension, not replacement \u2014 AI should make your thinking bigger, not do your thinking for you.",
+  "Diversity over uniformity \u2014 different thinkers produce different ideas, and that's the engine of progress.",
+  "The rules should be visible \u2014 like a good house, you know the rules before you walk in.",
+  "Exit must be real \u2014 if you can't leave a system that feels wrong, it's not governance, it's a cage.",
+  "Teach, don't lecture \u2014 help people think for themselves, not think what you think.",
+  "Name the feeling first \u2014 when something is off, the emotion arrives before the analysis. Trust that."
+]);
+var SOVEREIGN_CONDUIT_EXEMPLARS = Object.freeze([
+  {
+    path: "neuroverseos-sovereign-conduit.worldmodel.md",
+    title: "The Sovereign Conduit Worldmodel",
+    exhibits: ["stewardship", "sovereignty", "integration"],
+    integration_quality: "full \u2014 all three domains defined, overlaps named, center identity declared",
+    notes: 'The source worldmodel. The tagline "Humanity first. In constant learning. In shared teaching." is the voice compressed to its essence. Use this as the north star for tone calibration.'
+  }
+]);
+function sovereignConduitRewrite(pattern) {
+  if (pattern.evidence.cited_invariant) {
+    return {
+      ...pattern,
+      framing: "non-negotiable rule tested",
+      emphasis: "name the rule, name who it protects, name what would happen without it",
+      compress: false
+      // Sovereign Conduit is warm, not compressed
+    };
+  }
+  if (pattern.type === "candidate") {
+    return {
+      ...pattern,
+      framing: "something new noticed",
+      emphasis: "explain what was seen in everyday language, ask whether it matters",
+      compress: false
+    };
+  }
+  return {
+    ...pattern,
+    framing: "what this means for the people in the system",
+    emphasis: "humanity + sovereignty + learning",
+    compress: false
+  };
+}
+var sovereignConduitLens = {
+  name: "sovereign-conduit",
+  description: "The NeuroVerseOS base lens. Warm, accessible, teaching. Evaluates activity through Stewardship (safety), Sovereignty (authority over thinking), and Integration (AI as cognitive extension). Uses everyday analogies \u2014 mom rules, friend's house, idea calculator. Names emotions before mechanisms. If a non-technical person can't understand the output, the voice is wrong. Humanity first. In constant learning. In shared teaching.",
+  primary_frame: {
+    domains: SOVEREIGN_CONDUIT_FRAME.domains,
+    overlaps: SOVEREIGN_CONDUIT_FRAME.overlaps,
+    center_identity: SOVEREIGN_CONDUIT_FRAME.center_identity,
+    evaluation_questions: SOVEREIGN_CONDUIT_FRAME.evaluation_questions,
+    scoring_rubric: SOVEREIGN_CONDUIT_FRAME.scoring_rubric
+  },
+  vocabulary: SOVEREIGN_CONDUIT_VOCABULARY,
+  voice: SOVEREIGN_CONDUIT_VOICE,
+  forbidden_phrases: SOVEREIGN_CONDUIT_FORBIDDEN,
+  preferred_patterns: SOVEREIGN_CONDUIT_PREFERRED,
+  strategic_patterns: SOVEREIGN_CONDUIT_STRATEGIC,
+  exemplar_refs: SOVEREIGN_CONDUIT_EXEMPLARS,
+  rewrite: sovereignConduitRewrite
+};
+
 // src/radiant/lenses/index.ts
 var LENSES = Object.freeze({
-  "auki-builder": aukiBuilderLens
+  "auki-builder": aukiBuilderLens,
+  "sovereign-conduit": sovereignConduitLens
 });
 function getLens(id) {
   return LENSES[id];
@@ -700,91 +998,166 @@ var DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
   DECISION_MOMENTUM_EXTRACTOR
 ]);
 
+// 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}
-
-### Evaluation questions to reason through
+  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)
 
-${questionsBlock}
+${compressedWorld}`,
+    // Section 2: Analytical frame (evaluation questions + rubric)
+    `## How to Think
 
-### Overlap emergent states
+${cl.scoringRubric}
 
-${overlapsBlock}
+Questions:
+${cl.evaluationQuestions}
 
-### Center identity
+Overlaps: ${overlapsBlock}
+Center: ${lens.primary_frame.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
@@ -847,17 +1220,30 @@ function createMockAI(fixedResponse) {
 }
 
 // src/radiant/core/scopes.ts
-function parseRepoScope(scope) {
+function parseScope(scope) {
   const cleaned = scope.replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/$/, "");
-  const parts = cleaned.split("/");
-  if (parts.length < 2 || !parts[0] || !parts[1]) {
+  const parts = cleaned.split("/").filter(Boolean);
+  if (parts.length === 0 || !parts[0]) {
+    throw new Error(
+      `Cannot parse scope: "${scope}". Expected "owner/repo" or "owner".`
+    );
+  }
+  if (parts.length === 1) {
+    return { type: "org", owner: parts[0] };
+  }
+  return { type: "repo", owner: parts[0], repo: parts[1] };
+}
+function parseRepoScope(scope) {
+  const parsed = parseScope(scope);
+  if (parsed.type === "org") {
     throw new Error(
-      `Cannot parse repo scope: "${scope}". Expected "owner/repo" or a GitHub URL.`
+      `Expected "owner/repo" but got org-level scope "${parsed.owner}". Use parseScope() for org-level.`
     );
   }
-  return { owner: parts[0], repo: parts[1] };
+  return parsed;
 }
 function formatScope(scope) {
+  if (scope.type === "org") return `${scope.owner} (org)`;
   return `${scope.owner}/${scope.repo}`;
 }
 
@@ -1041,6 +1427,40 @@ async function fetchJSON(url, headers) {
   }
   return await res.json();
 }
+async function fetchGitHubOrgActivity(scope, token, options = {}) {
+  const perPage = options.perPage ?? 100;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const repos = await fetchJSON(
+    `https://api.github.com/orgs/${scope.owner}/repos?sort=pushed&direction=desc&per_page=${perPage}`,
+    headers
+  );
+  const windowDays = options.windowDays ?? 14;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const activeRepos = repos.filter(
+    (r) => new Date(r.pushed_at) >= since
+  );
+  const cappedRepos = activeRepos.slice(0, 10);
+  const allEvents = [];
+  const repoNames = [];
+  for (const repo of cappedRepos) {
+    const [owner, repoName] = repo.full_name.split("/");
+    try {
+      const repoScope = { type: "repo", owner, repo: repoName };
+      const events = await fetchGitHubActivity(repoScope, token, options);
+      allEvents.push(...events);
+      if (events.length > 0) repoNames.push(repo.full_name);
+    } catch {
+    }
+  }
+  allEvents.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return { events: allEvents, repos: repoNames };
+}
 function createMockGitHubAdapter(fixedEvents) {
   return async () => fixedEvents;
 }
@@ -1048,7 +1468,7 @@ function createMockGitHubAdapter(fixedEvents) {
 // src/radiant/adapters/exocortex.ts
 var import_fs = require("fs");
 var import_path = require("path");
-function readExocortex(dirPath) {
+function readExocortex(dirPath, repoName) {
   const dir = (0, import_path.resolve)(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
@@ -1067,16 +1487,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) {
@@ -1117,6 +1585,46 @@ ${ctx.methods}`);
   }
   return sections.join("\n\n");
 }
+function readTeamExocortices(teamDir) {
+  const dir = (0, import_path.resolve)(teamDir);
+  if (!(0, import_fs.existsSync)(dir)) return [];
+  const entries = (0, import_fs.readdirSync)(dir);
+  const results = [];
+  for (const entry of entries) {
+    const entryPath = (0, import_path.join)(dir, entry);
+    try {
+      const stat = (0, import_fs.statSync)(entryPath);
+      if (stat.isDirectory()) {
+        const ctx = readExocortex(entryPath);
+        if (ctx.filesLoaded > 0) {
+          results.push({ name: entry, context: ctx });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function formatTeamExocorticesForPrompt(team) {
+  if (team.length === 0) return "";
+  const sections = [
+    "## Team Intent (cross-exocortex read)",
+    "",
+    `Reading ${team.length} team members' exocortices. Compare each person's`,
+    "stated intent against the observed activity AND against each other.",
+    "Surface: duplicate focus, missing coverage, silent pivots,",
+    "and areas where no one is carrying the work.",
+    ""
+  ];
+  for (const { name, context } of team) {
+    sections.push(`### ${name}`);
+    if (context.attention) sections.push(`**Attention:** ${context.attention.split("\n")[0]}`);
+    if (context.goals) sections.push(`**Goals:** ${context.goals.split("\n").slice(0, 3).join("; ")}`);
+    if (context.sprint) sections.push(`**Sprint:** ${context.sprint.split("\n").slice(0, 3).join("; ")}`);
+    sections.push("");
+  }
+  return sections.join("\n");
+}
 function summarizeExocortex(ctx) {
   if (ctx.filesLoaded === 0) return "no exocortex files found";
   const loaded = [];
@@ -1129,6 +1637,400 @@ function summarizeExocortex(ctx) {
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
 
+// 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/patterns.ts
 async function interpretPatterns(input) {
   const prompt = buildInterpretationPrompt(input);
@@ -1146,15 +2048,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
 
@@ -1200,6 +2104,14 @@ ${jargonTable}
 
 For example: don't say "update the worldmodel." Say "add a line to your strategy file."
 
+## When the same invariant keeps firing
+
+If the prior read history or the current evidence shows the same worldmodel invariant being triggered repeatedly (by the same side \u2014 human or AI), name it in MEANING and ask the real question:
+
+  "This invariant has been tested N times across M reads. Always on the [human/AI] side. Either the team needs alignment on WHY this rule exists \u2014 or the team is telling you something the worldmodel hasn't absorbed yet."
+
+Don't just say "invariant held." Say what it means that people keep pushing against the same wall.
+
 ## Health is a valid read
 
 If the activity is healthy and aligned with the worldmodel, SAY SO. Don't fabricate problems. Over-prescription is a voice failure. Legitimate outputs include:
@@ -1337,30 +2249,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}
-`;
-      }
-    }
-    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}
+      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());
@@ -1568,6 +2466,75 @@ function serializeYAML(obj, indent = 0) {
 `;
 }
 
+// src/radiant/core/discovery.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os = require("os");
+function discoverWorlds(options) {
+  const worlds = [];
+  const userDir = options?.userWorldsDir ?? (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs2.existsSync)(userDir)) {
+    worlds.push(...loadWorldsFromDir(userDir, "user"));
+  }
+  if (options?.explicitWorldsDir) {
+    worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
+  } else if (options?.repoDir) {
+    const repoPaths = [
+      (0, import_path2.join)(options.repoDir, "worlds"),
+      (0, import_path2.join)(options.repoDir, ".neuroverse", "worlds")
+    ];
+    for (const p of repoPaths) {
+      if ((0, import_fs2.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 = (0, import_path2.resolve)(dirPath);
+  if (!(0, import_fs2.existsSync)(dir)) return [];
+  const stat = (0, import_fs2.statSync)(dir);
+  if (stat.isFile() && dir.endsWith(".md")) {
+    try {
+      return [{
+        name: (0, import_path2.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        source,
+        path: dir,
+        content: (0, import_fs2.readFileSync)(dir, "utf-8")
+      }];
+    } catch {
+      return [];
+    }
+  }
+  if (!stat.isDirectory()) return [];
+  const files = (0, import_fs2.readdirSync)(dir).filter(
+    (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
+  ).sort();
+  return files.map((f) => {
+    const fullPath = (0, import_path2.join)(dir, f);
+    return {
+      name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+      source,
+      path: fullPath,
+      content: (0, import_fs2.readFileSync)(fullPath, "utf-8")
+    };
+  });
+}
+
 // src/engine/text-utils.ts
 function normalizeEventText(event) {
   return [
@@ -2654,10 +3621,10 @@ function verdictToEvent(status, intent) {
 // src/loader/world-loader.ts
 async function loadWorldFromDirectory(dirPath) {
   const { readFile } = await import("fs/promises");
-  const { join: join3 } = await import("path");
-  const { readdirSync: readdirSync2 } = await import("fs");
+  const { join: join4 } = await import("path");
+  const { readdirSync: readdirSync4 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join3(dirPath, filename);
+    const filePath = join4(dirPath, filename);
     try {
       const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
@@ -2687,11 +3654,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join3(dirPath, "rules");
-    const ruleFiles = readdirSync2(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join4(dirPath, "rules");
+    const ruleFiles = readdirSync4(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile(join3(rulesDir, file), "utf-8");
+        const content = await readFile(join4(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -2851,25 +3818,25 @@ function emptyAudit(total, reason) {
 }
 
 // src/radiant/memory/palace.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_fs3 = require("fs");
+var import_path3 = require("path");
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = (0, import_path2.resolve)(exocortexDir, "radiant", "reads");
-  (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs3.mkdirSync)(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = (0, import_path2.join)(dir, filename);
+  const filepath = (0, import_path3.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs2.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs3.writeFileSync)(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = (0, import_path2.resolve)(exocortexDir, "radiant");
-  (0, import_fs2.mkdirSync)(dir, { recursive: true });
-  const filepath = (0, import_path2.join)(dir, "knowledge.md");
+  const dir = (0, import_path3.resolve)(exocortexDir, "radiant");
+  (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path3.join)(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -2956,14 +3923,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs2.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  (0, import_fs3.writeFileSync)(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!(0, import_fs2.existsSync)(filepath)) return counts;
+  if (!(0, import_fs3.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs2.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -2981,13 +3948,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = (0, import_path2.resolve)(exocortexDir, "radiant", "reads");
-  if (!(0, import_fs2.existsSync)(dir)) return [];
-  const files = (0, import_fs2.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs3.existsSync)(dir)) return [];
+  const files = (0, import_fs3.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = (0, import_path2.join)(dir, filename);
-    const content = (0, import_fs2.readFileSync)(filepath, "utf-8");
+    const filepath = (0, import_path3.join)(dir, filename);
+    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -3078,21 +4045,80 @@ function resolveLens(id) {
 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);
     }
   }
-  const events = await fetchGitHubActivity(input.scope, input.githubToken, {
-    windowDays
-  });
+  let events;
+  let orgRepos;
+  if (input.scope.type === "org") {
+    const orgResult = await fetchGitHubOrgActivity(
+      input.scope,
+      input.githubToken,
+      { windowDays }
+    );
+    events = orgResult.events;
+    orgRepos = orgResult.repos;
+  } else {
+    events = await fetchGitHubActivity(input.scope, input.githubToken, {
+      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 !== "");
@@ -3103,7 +4129,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");
@@ -3152,7 +4178,9 @@ async function emergent(input) {
     voiceClean: voiceViolations.length === 0,
     signals,
     scores,
-    eventCount: events.length
+    eventCount: events.length,
+    activeAdapters,
+    worldStack
   };
 }
 function computeScores(signals, worldmodelLoaded) {
@@ -3217,16 +4245,30 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   classifyActorDomain,
   classifyEvents,
   composeSystemPrompt,
+  compressExocortex,
+  compressLens,
+  compressPriorReads,
+  compressWorldmodel,
   computePersistence,
   createAnthropicAI,
   createMockAI,
   createMockGitHubAdapter,
+  discoverWorlds,
   emergent,
   extractSignals,
+  fetchDiscordActivity,
   fetchGitHubActivity,
+  fetchGitHubOrgActivity,
+  fetchNotionActivity,
+  fetchSlackActivity,
+  formatActiveWorlds,
+  formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
+  formatSlackSignalsForPrompt,
+  formatTeamExocorticesForPrompt,
   getLens,
   interpretPatterns,
   isPresent,
@@ -3235,13 +4277,16 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   listLenses,
   loadPriorReads,
   parseRepoScope,
+  parseScope,
   presenceAverage,
   readExocortex,
+  readTeamExocortices,
   render,
   scoreComposite,
   scoreCyber,
   scoreLife,
   scoreNeuroVerse,
+  sovereignConduitLens,
   summarizeExocortex,
   think,
   updateKnowledge,