@neuroverseos/governance 0.8.0 → 0.9.0

package/dist/cli/radiant.cjs

@@ -455,13 +455,300 @@ var init_auki_builder = __esm({
   }
 });
 
+// src/radiant/lenses/sovereign-conduit.ts
+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 + agency + learning",
+    compress: false
+  };
+}
+var SOVEREIGN_CONDUIT_FRAME, SOVEREIGN_CONDUIT_VOCABULARY, SOVEREIGN_CONDUIT_VOICE, SOVEREIGN_CONDUIT_FORBIDDEN, SOVEREIGN_CONDUIT_PREFERRED, SOVEREIGN_CONDUIT_STRATEGIC, SOVEREIGN_CONDUIT_EXEMPLARS, sovereignConduitLens;
+var init_sovereign_conduit = __esm({
+  "src/radiant/lenses/sovereign-conduit.ts"() {
+    "use strict";
+    SOVEREIGN_CONDUIT_FRAME = {
+      domains: [
+        "stewardship",
+        "agency",
+        "integration"
+      ],
+      overlaps: [
+        {
+          domains: ["stewardship", "agency"],
+          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: ["agency", "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"
+        ],
+        "agency": [
+          "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",
+          "Agency",
+          "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: "Agency 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"
+          }
+        ]
+      }
+    };
+    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"
+      }
+    };
+    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, Agency, 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.`
+    };
+    SOVEREIGN_CONDUIT_FORBIDDEN = Object.freeze([
+      // Bucket names as labels
+      "stewardship is",
+      "agency 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"
+    ]);
+    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].",
+      // Agency 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]."
+    ]);
+    SOVEREIGN_CONDUIT_STRATEGIC = Object.freeze([
+      "Safety before expansion \u2014 always. No exception.",
+      "Agency 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."
+    ]);
+    SOVEREIGN_CONDUIT_EXEMPLARS = Object.freeze([
+      {
+        path: "src/radiant/examples/neuroverse-base/neuroverseos-sovereign-conduit.worldmodel.md",
+        title: "The Sovereign Conduit Worldmodel",
+        exhibits: ["stewardship", "agency", "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.'
+      }
+    ]);
+    sovereignConduitLens = {
+      name: "sovereign-conduit",
+      description: "The NeuroVerseOS base lens. Warm, accessible, teaching. Evaluates activity through Stewardship (safety), Agency (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_exports = {};
 __export(lenses_exports, {
   LENSES: () => LENSES,
   aukiBuilderLens: () => aukiBuilderLens,
   getLens: () => getLens,
-  listLenses: () => listLenses
+  listLenses: () => listLenses,
+  sovereignConduitLens: () => sovereignConduitLens
 });
 function getLens(id) {
   return LENSES[id];
@@ -474,102 +761,186 @@ var init_lenses = __esm({
   "src/radiant/lenses/index.ts"() {
     "use strict";
     init_auki_builder();
+    init_sovereign_conduit();
     init_auki_builder();
+    init_sovereign_conduit();
     LENSES = Object.freeze({
-      "auki-builder": aukiBuilderLens
+      "auki-builder": aukiBuilderLens,
+      "sovereign-conduit": sovereignConduitLens
     });
   }
 });
 
+// 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("; ");
+}
+var init_compress = __esm({
+  "src/radiant/core/compress.ts"() {
+    "use strict";
+  }
+});
+
 // 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");
 }
 var init_prompt = __esm({
   "src/radiant/core/prompt.ts"() {
     "use strict";
+    init_compress();
   }
 });
 
@@ -890,16 +1261,791 @@ var init_github = __esm({
   }
 });
 
+// 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();
+}
+var init_discord = __esm({
+  "src/radiant/adapters/discord.ts"() {
+    "use strict";
+  }
+});
+
+// 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;
+}
+var init_slack = __esm({
+  "src/radiant/adapters/slack.ts"() {
+    "use strict";
+  }
+});
+
+// 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();
+}
+var init_notion = __esm({
+  "src/radiant/adapters/notion.ts"() {
+    "use strict";
+  }
+});
+
+// src/radiant/core/git-remote.ts
+function resolveGitConfigPath(repoDir) {
+  const dotGit = (0, import_path.join)(repoDir, ".git");
+  if (!(0, import_fs.existsSync)(dotGit)) return null;
+  try {
+    const stat = (0, import_fs.statSync)(dotGit);
+    if (stat.isDirectory()) {
+      return (0, import_path.join)(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs.readFileSync)(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = (0, import_path.resolve)(repoDir, match[1].trim());
+      const configPath = (0, import_path.join)(gitDir, "config");
+      return (0, import_fs.existsSync)(configPath) ? configPath : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readOriginRemote(repoDir) {
+  const configPath = resolveGitConfigPath(repoDir);
+  if (!configPath) return null;
+  try {
+    const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
+    const sectionRe = /\[remote "origin"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/;
+    const section = sectionRe.exec(raw);
+    if (!section) return null;
+    const urlRe = /^\s*url\s*=\s*(.+?)\s*$/m;
+    const url = urlRe.exec(section[1]);
+    return url ? url[1] : null;
+  } catch {
+    return null;
+  }
+}
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const ssh = /^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (ssh) return { host: ssh[1], owner: ssh[2], repo: ssh[3] };
+  const sshProto = /^ssh:\/\/git@([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (sshProto) return { host: sshProto[1], owner: sshProto[2], repo: sshProto[3] };
+  const https = /^https?:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (https) return { host: https[1], owner: https[2], repo: https[3] };
+  return null;
+}
+function getRepoOrigin(repoDir) {
+  const url = readOriginRemote(repoDir);
+  if (!url) return null;
+  return parseRemoteUrl(url);
+}
+var import_fs, import_path;
+var init_git_remote = __esm({
+  "src/radiant/core/git-remote.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+  }
+});
+
+// src/radiant/core/extends.ts
+function loadExtendsConfig(repoDir) {
+  const configPath = (0, import_path2.join)(repoDir, ".neuroverse", "config.json");
+  if (!(0, import_fs2.existsSync)(configPath)) return null;
+  try {
+    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseExtendsSpec(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("github:")) {
+    const rest = trimmed.slice("github:".length);
+    const match = /^([^/]+)\/([^@:]+)(?:@([^:]+))?(?::(.+))?$/.exec(rest);
+    if (!match) return null;
+    return {
+      raw: trimmed,
+      kind: "github",
+      owner: match[1],
+      repo: match[2],
+      ref: match[3] ?? "HEAD",
+      subpath: match[4] ?? ""
+    };
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || (0, import_path2.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  return null;
+}
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse", "cache", "extends");
+  const key = (0, import_crypto.createHash)("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return (0, import_path2.join)(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = (0, import_path2.join)(cacheDir, ".neuroverse-fetched");
+  if (!(0, import_fs2.existsSync)(stampPath)) return false;
+  try {
+    const stamp = (0, import_fs2.statSync)(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = (0, import_path2.join)(cacheDir, ".neuroverse-fetched");
+  try {
+    (0, import_fs2.mkdirSync)(cacheDir, { recursive: true });
+    (0, import_fs2.writeFileSync)(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = (0, import_path2.isAbsolute)(spec.path) ? spec.path : (0, import_path2.resolve)(repoDir, spec.path);
+    if (!(0, import_fs2.existsSync)(full)) {
+      return { spec, dir: null, warning: `local extends path not found: ${full}` };
+    }
+    return { spec, dir: full };
+  }
+  const cacheRoot = options?.cacheDir;
+  const ttl = options?.ttlMs ?? DEFAULT_TTL_MS;
+  const cacheDir = getCacheDir(spec, cacheRoot);
+  const fresh = isCacheFresh(cacheDir, ttl);
+  const needsFetch = options?.forceRefresh || !fresh || !(0, import_fs2.existsSync)(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if ((0, import_fs2.existsSync)(cacheDir) && (0, import_fs2.existsSync)((0, import_path2.join)(cacheDir, ".neuroverse-fetched"))) {
+      return resolveSubpath(spec, cacheDir);
+    }
+    return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `NEUROVERSE_NO_FETCH set and no cache for ${spec.raw}` };
+  }
+  if (needsFetch) {
+    const fetcher = options?.fetcher ?? defaultGitFetcher;
+    try {
+      fetcher(spec, cacheDir);
+      markCacheFresh(cacheDir);
+    } catch (err) {
+      if ((0, import_fs2.existsSync)(cacheDir) && (0, import_fs2.existsSync)((0, import_path2.join)(cacheDir, ".neuroverse-fetched"))) {
+        const result = resolveSubpath(spec, cacheDir);
+        return options?.silentOnMissing ? result : { ...result, warning: `fetch failed for ${spec.raw}, using stale cache: ${err.message}` };
+      }
+      return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `fetch failed for ${spec.raw}: ${err.message}` };
+    }
+  }
+  return resolveSubpath(spec, cacheDir);
+}
+function resolveSubpath(spec, cacheDir) {
+  const target = spec.subpath ? (0, import_path2.join)(cacheDir, spec.subpath) : cacheDir;
+  if (!(0, import_fs2.existsSync)(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      (0, import_path2.join)(target, "worlds"),
+      (0, import_path2.join)(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if ((0, import_fs2.existsSync)(c)) return { spec, dir: c };
+    }
+  }
+  return { spec, dir: target };
+}
+function detectOrgExtendsSpec(repoDir) {
+  const origin = getRepoOrigin(repoDir);
+  if (!origin) return null;
+  if (origin.host !== "github.com") return null;
+  if (origin.repo === "worlds") return null;
+  return {
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
+  };
+}
+function resolveAllExtends(repoDir, options) {
+  const config = options?.config !== void 0 ? options.config : loadExtendsConfig(repoDir);
+  if (!config?.extends || config.extends.length === 0) return [];
+  const results = [];
+  for (const raw of config.extends) {
+    const spec = parseExtendsSpec(raw);
+    if (!spec) {
+      results.push({
+        spec: { raw, kind: "local" },
+        dir: null,
+        warning: `unparseable extends spec: ${raw}`
+      });
+      continue;
+    }
+    results.push(resolveExtendsSpec(spec, repoDir, options));
+  }
+  return results;
+}
+var import_fs2, import_path2, import_os, import_crypto, import_child_process, DEFAULT_TTL_MS, defaultGitFetcher;
+var init_extends = __esm({
+  "src/radiant/core/extends.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_os = require("os");
+    import_crypto = require("crypto");
+    import_child_process = require("child_process");
+    init_git_remote();
+    DEFAULT_TTL_MS = 60 * 60 * 1e3;
+    defaultGitFetcher = (spec, destDir) => {
+      if (spec.kind !== "github") return;
+      const url = `https://github.com/${spec.owner}/${spec.repo}.git`;
+      const parent = (0, import_path2.resolve)(destDir, "..");
+      (0, import_fs2.mkdirSync)(parent, { recursive: true });
+      if ((0, import_fs2.existsSync)(destDir)) {
+        (0, import_fs2.rmSync)(destDir, { recursive: true, force: true });
+      }
+      const args = ["clone", "--depth", "1", "--filter=blob:none"];
+      if (spec.ref && spec.ref !== "HEAD") {
+        args.push("--branch", spec.ref);
+      }
+      args.push(url, destDir);
+      (0, import_child_process.execFileSync)("git", args, { stdio: "pipe" });
+    };
+  }
+});
+
+// src/radiant/core/discovery.ts
+function discoverWorlds(options) {
+  const worlds = [];
+  const warnings = [];
+  const forceRefresh = process.env.NEUROVERSE_REFRESH === "1";
+  const noFetch = process.env.NEUROVERSE_NO_FETCH === "1";
+  const noOrg = options?.disableOrg || process.env.NEUROVERSE_NO_ORG === "1";
+  const userDir = options?.userWorldsDir ?? (0, import_path3.join)((0, import_os2.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs3.existsSync)(userDir)) {
+    worlds.push(...loadWorldsFromDir(userDir, "user"));
+  }
+  if (!noOrg && !options?.explicitWorldsDir) {
+    const specs = [];
+    if (options?.repoDir) {
+      const fromGit = detectOrgExtendsSpec(options.repoDir);
+      if (fromGit) specs.push(fromGit);
+    }
+    if (options?.scopeOwner) {
+      const already = specs.some(
+        (s) => s.owner?.toLowerCase() === options.scopeOwner.toLowerCase()
+      );
+      if (!already) {
+        specs.push({
+          raw: `github:${options.scopeOwner}/worlds`,
+          kind: "github",
+          owner: options.scopeOwner,
+          repo: "worlds"
+        });
+      }
+    }
+    const baseDir = options?.repoDir ?? process.cwd();
+    for (const spec of specs) {
+      const result = resolveExtendsSpec(spec, baseDir, {
+        cacheDir: options?.extendsCacheDir,
+        fetcher: options?.extendsFetcher,
+        ttlMs: options?.extendsTtlMs,
+        forceRefresh,
+        noFetch,
+        silentOnMissing: true
+      });
+      worlds.push(...loadExtendsWorlds(result, "org"));
+    }
+  }
+  if (options?.repoDir && !options.disableExtends && !options.explicitWorldsDir) {
+    const results = resolveAllExtends(options.repoDir, {
+      cacheDir: options.extendsCacheDir,
+      fetcher: options.extendsFetcher,
+      ttlMs: options.extendsTtlMs,
+      forceRefresh,
+      noFetch
+    });
+    for (const result of results) {
+      worlds.push(...loadExtendsWorlds(result, "extends"));
+      if (result.warning) warnings.push(result.warning);
+    }
+  }
+  if (options?.explicitWorldsDir) {
+    worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
+  } else if (options?.repoDir) {
+    const repoPaths = [
+      (0, import_path3.join)(options.repoDir, "worlds"),
+      (0, import_path3.join)(options.repoDir, ".neuroverse", "worlds")
+    ];
+    for (const p of repoPaths) {
+      if ((0, import_fs3.existsSync)(p)) {
+        worlds.push(...loadWorldsFromDir(p, "repo"));
+        break;
+      }
+    }
+  }
+  const combinedContent = worlds.map((w) => {
+    const tag = w.extendsFrom ? `<!-- world: ${w.name} (${w.source} ${w.extendsFrom}) -->` : `<!-- world: ${w.name} (${w.source}) -->`;
+    return `${tag}
+${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, warnings };
+}
+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" : w.source === "org" ? `org (${w.extendsFrom ?? "auto"})` : w.source === "extends" ? `shared (${w.extendsFrom ?? "extends"})` : "this repo";
+    lines.push(`  ${w.name} (${sourceLabel})`);
+  }
+  if (stack.warnings.length > 0) {
+    lines.push("", "WARNINGS");
+    for (const w of stack.warnings) lines.push(`  ${w}`);
+  }
+  return lines.join("\n");
+}
+function loadExtendsWorlds(result, source) {
+  if (!result.dir) return [];
+  const loaded = loadWorldsFromDir(result.dir, source);
+  return loaded.map((w) => ({ ...w, extendsFrom: result.spec.raw }));
+}
+function loadWorldsFromDir(dirPath, source) {
+  const dir = (0, import_path3.resolve)(dirPath);
+  if (!(0, import_fs3.existsSync)(dir)) return [];
+  const stat = (0, import_fs3.statSync)(dir);
+  if (stat.isFile() && dir.endsWith(".md")) {
+    try {
+      return [{
+        name: (0, import_path3.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        source,
+        path: dir,
+        content: (0, import_fs3.readFileSync)(dir, "utf-8")
+      }];
+    } catch {
+      return [];
+    }
+  }
+  if (!stat.isDirectory()) return [];
+  const files = (0, import_fs3.readdirSync)(dir).filter(
+    (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
+  ).sort();
+  return files.map((f) => {
+    const fullPath = (0, import_path3.join)(dir, f);
+    return {
+      name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+      source,
+      path: fullPath,
+      content: (0, import_fs3.readFileSync)(fullPath, "utf-8")
+    };
+  });
+}
+var import_fs3, import_path3, import_os2;
+var init_discovery = __esm({
+  "src/radiant/core/discovery.ts"() {
+    "use strict";
+    import_fs3 = require("fs");
+    import_path3 = require("path");
+    import_os2 = require("os");
+    init_extends();
+  }
+});
+
 // src/radiant/adapters/exocortex.ts
-function readExocortex(dirPath) {
-  const dir = (0, import_path.resolve)(dirPath);
+function readExocortex(dirPath, repoName) {
+  const dir = (0, import_path4.resolve)(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = (0, import_path.join)(dir, p);
-      if ((0, import_fs.existsSync)(full)) {
+      const full = (0, import_path4.join)(dir, p);
+      if ((0, import_fs4.existsSync)(full)) {
         try {
-          const content = (0, import_fs.readFileSync)(full, "utf-8").trim();
+          const content = (0, import_fs4.readFileSync)(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -910,55 +2056,65 @@ 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
   };
-  return ctx;
-}
-function formatExocortexForPrompt(ctx) {
-  if (ctx.filesLoaded === 0) return "";
-  const sections = [];
-  sections.push(
-    "## Stated Intent (from exocortex)\n\nThe following is what the person/team SAYS they are doing, focused on, and working toward. Compare this against the ACTUAL activity from GitHub. Where stated intent and observed behavior diverge, that gap is the most valuable signal in this read. Name it directly."
-  );
-  if (ctx.attention) {
-    sections.push(`### Current attention
+  if (projectContext && ctx.sprint) {
+    ctx.sprint = `${ctx.sprint}
 
-${ctx.attention}`);
+---
+Project roadmap:
+${projectContext}`;
+  } else if (projectContext) {
+    ctx.sprint = `Project roadmap:
+${projectContext}`;
+    ctx.filesLoaded++;
   }
-  if (ctx.goals) {
-    sections.push(`### Goals
-
-${ctx.goals}`);
-  }
-  if (ctx.sprint) {
-    sections.push(`### Sprint focus
-
-${ctx.sprint}`);
-  }
-  if (ctx.identity) {
-    sections.push(`### Identity and values
-
-${ctx.identity}`);
-  }
-  if (ctx.organization) {
-    sections.push(`### Organization
-
-${ctx.organization}`);
-  }
-  if (ctx.methods) {
-    sections.push(`### Methods
-
-${ctx.methods}`);
-  }
-  return sections.join("\n\n");
+  return ctx;
 }
 function summarizeExocortex(ctx) {
   if (ctx.filesLoaded === 0) return "no exocortex files found";
@@ -971,33 +2127,33 @@ function summarizeExocortex(ctx) {
   if (ctx.methods) loaded.push("methods");
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
-var import_fs, import_path;
+var import_fs4, import_path4;
 var init_exocortex = __esm({
   "src/radiant/adapters/exocortex.ts"() {
     "use strict";
-    import_fs = require("fs");
-    import_path = require("path");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
   }
 });
 
 // src/radiant/memory/palace.ts
 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_path5.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs5.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_path5.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs2.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs5.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_path5.resolve)(exocortexDir, "radiant");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path5.join)(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -1084,14 +2240,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs2.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  (0, import_fs5.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_fs5.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs2.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -1109,13 +2265,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_path5.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs5.existsSync)(dir)) return [];
+  const files = (0, import_fs5.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_path5.join)(dir, filename);
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -1149,33 +2305,12 @@ function computePersistence(priorReads, currentPatternNames) {
     dates: dates.sort()
   })).sort((a, b) => b.occurrences - a.occurrences);
 }
-function formatPriorReadsForPrompt(priorReads) {
-  if (priorReads.length === 0) return "";
-  const lines = [
-    "## Prior Radiant reads (history)",
-    "",
-    `Radiant has run ${priorReads.length} time${priorReads.length > 1 ? "s" : ""} before on this scope.`,
-    "If you see patterns that appeared in prior reads, note their persistence.",
-    "Patterns that recur across 3+ reads are strong candidates for declaration in the strategy file.",
-    ""
-  ];
-  for (const read of priorReads.slice(-4)) {
-    lines.push(`### Read from ${read.date}`);
-    if (read.patternNames.length > 0) {
-      lines.push(`Patterns observed: ${read.patternNames.join(", ")}`);
-    } else {
-      lines.push("No patterns extracted from frontmatter.");
-    }
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-var import_fs2, import_path2;
+var import_fs5, import_path5;
 var init_palace = __esm({
   "src/radiant/memory/palace.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
   }
 });
 
@@ -2284,10 +3419,10 @@ var init_guard_engine = __esm({
 // src/loader/world-loader.ts
 async function loadWorldFromDirectory(dirPath) {
   const { readFile } = await import("fs/promises");
-  const { join: join5 } = await import("path");
-  const { readdirSync: readdirSync5 } = await import("fs");
+  const { join: join8 } = await import("path");
+  const { readdirSync: readdirSync6 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join5(dirPath, filename);
+    const filePath = join8(dirPath, filename);
     try {
       const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
@@ -2317,11 +3452,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join5(dirPath, "rules");
-    const ruleFiles = readdirSync5(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join8(dirPath, "rules");
+    const ruleFiles = readdirSync6(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile(join5(rulesDir, file), "utf-8");
+        const content = await readFile(join8(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -2728,15 +3863,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
 
@@ -2915,6 +4052,7 @@ function isPatternLike(x) {
 var init_patterns = __esm({
   "src/radiant/core/patterns.ts"() {
     "use strict";
+    init_compress();
   }
 });
 
@@ -2932,30 +4070,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());
@@ -3174,16 +4298,29 @@ var init_renderer = __esm({
 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;
@@ -3201,6 +4338,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 !== "");
@@ -3211,7 +4382,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");
@@ -3260,7 +4431,9 @@ async function emergent(input) {
     voiceClean: voiceViolations.length === 0,
     signals,
     scores,
-    eventCount: events.length
+    eventCount: events.length,
+    activeAdapters,
+    worldStack
   };
 }
 function computeScores(signals, worldmodelLoaded) {
@@ -3315,8 +4488,13 @@ var init_emergent = __esm({
     "use strict";
     init_lenses();
     init_github();
+    init_discord();
+    init_slack();
+    init_notion();
+    init_discovery();
     init_exocortex();
     init_palace();
+    init_compress();
     init_governance();
     init_signals();
     init_math();
@@ -3373,22 +4551,22 @@ __export(server_exports, {
   startRadiantMcp: () => startRadiantMcp
 });
 function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path3.resolve)(worldsPath);
-  if (!(0, import_fs3.existsSync)(resolved)) {
+  const resolved = (0, import_path6.resolve)(worldsPath);
+  if (!(0, import_fs6.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs3.statSync)(resolved);
+  const stat = (0, import_fs6.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs3.readFileSync)(resolved, "utf-8");
+    return (0, import_fs6.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs3.readdirSync)(resolved).filter(
-      (f) => (0, import_path3.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs6.readdirSync)(resolved).filter(
+      (f) => (0, import_path6.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(`No worldmodel files found in ${resolved}`);
     }
-    return files.map((f) => (0, import_fs3.readFileSync)((0, import_path3.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
+    return files.map((f) => (0, import_fs6.readFileSync)((0, import_path6.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
   }
   throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
 }
@@ -3407,12 +4585,12 @@ async function startRadiantMcp(args) {
   const server = new RadiantMcpServer({ worldsPath, lensId, model });
   await server.start();
 }
-var import_fs3, import_path3, TOOLS, RadiantMcpServer;
+var import_fs6, import_path6, TOOLS, RadiantMcpServer;
 var init_server = __esm({
   "src/radiant/mcp/server.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path3 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     init_think();
     init_emergent();
     init_ai();
@@ -3643,14 +4821,15 @@ __export(radiant_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(radiant_exports);
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 init_think();
 init_emergent();
 init_ai();
 init_scopes();
 init_exocortex();
 init_lenses();
+init_discovery();
 var RED = "\x1B[31m";
 var DIM = "\x1B[2m";
 var BOLD = "\x1B[1m";
@@ -3676,6 +4855,18 @@ ${BOLD}Usage:${RESET}
   neuroverse radiant lenses list
   neuroverse radiant lenses describe auki-builder
 
+${BOLD}Auto-discovery:${RESET}
+  You do not need to clone the target repo.
+
+    radiant emergent NeuroverseOS/       \u2192 probes github.com/NeuroverseOS/worlds
+    radiant emergent aukiverse/posemesh  \u2192 probes github.com/aukiverse/worlds
+
+  The scope argument itself is enough. Discovery also picks up
+  ~/.neuroverse/worlds/ (personal), the org from your current clone's
+  .git/config (if any), and ./worlds/ (this repo).
+
+  Set NEUROVERSE_NO_ORG=1 to disable org probing for a single run.
+
 ${BOLD}Environment:${RESET}
   ANTHROPIC_API_KEY    Required for AI commands (think, emergent, decision)
   RADIANT_WORLDS       Default worlds directory (overridden by --worlds)
@@ -3742,17 +4933,17 @@ function parseArgs(argv) {
   return result;
 }
 function loadWorldmodelContent2(worldsPath) {
-  const resolved = (0, import_path4.resolve)(worldsPath);
-  if (!(0, import_fs4.existsSync)(resolved)) {
+  const resolved = (0, import_path7.resolve)(worldsPath);
+  if (!(0, import_fs7.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs4.statSync)(resolved);
+  const stat = (0, import_fs7.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs4.readFileSync)(resolved, "utf-8");
+    return (0, import_fs7.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs4.readdirSync)(resolved).filter(
-      (f) => (0, import_path4.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs7.readdirSync)(resolved).filter(
+      (f) => (0, import_path7.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(
@@ -3760,27 +4951,55 @@ function loadWorldmodelContent2(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs4.readFileSync)((0, import_path4.join)(resolved, f), "utf-8");
+      const content = (0, import_fs7.readFileSync)((0, import_path7.join)(resolved, f), "utf-8");
       return `<!-- worldmodel: ${f} -->
 ${content}`;
     }).join("\n\n---\n\n");
   }
   throw new Error(`Worlds path is neither a file nor a directory: ${resolved}`);
 }
-async function cmdThink(args) {
-  const lensId = args.lens ?? process.env.RADIANT_LENS;
-  if (!lensId) {
+function resolveWorldmodelContent(explicitPath, scopeOwner) {
+  if (explicitPath) {
+    return loadWorldmodelContent2(explicitPath);
+  }
+  const stack = discoverWorlds({
+    repoDir: process.cwd(),
+    scopeOwner
+  });
+  if (stack.worlds.length === 0) {
+    const scopeLine = scopeOwner ? `  3. github:${scopeOwner}/worlds (from scope arg)
+` : "";
+    const ext = scopeOwner ? 4 : 3;
+    const repo = scopeOwner ? 5 : 4;
     process.stderr.write(
-      `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
-${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
+      `${RED}Error:${RESET} No worldmodel found.
+${DIM}Tried (in order):
+  1. ~/.neuroverse/worlds/              (user tier)
+  2. github:<owner>/worlds              (org auto-detect from git remote)
+` + scopeLine + `  ${ext}. .neuroverse/config.json extends    (explicit shared worlds)
+  ${repo}. ./worlds/ or ./.neuroverse/worlds/ (repo tier)
+
+Pass --worlds <dir> or set RADIANT_WORLDS to specify explicitly.
+Or run against a <scope>/ where github.com/<scope>/worlds exists.${RESET}
 `
     );
     process.exit(1);
   }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
+  process.stderr.write(`${DIM}${formatActiveWorlds(stack)}${RESET}
+
+`);
+  for (const warning of stack.warnings) {
+    process.stderr.write(`${YELLOW}\u26A0${RESET}  ${warning}
+`);
+  }
+  return stack.combinedContent;
+}
+async function cmdThink(args) {
+  const lensId = args.lens ?? process.env.RADIANT_LENS;
+  if (!lensId) {
     process.stderr.write(
-      `${RED}Error:${RESET} --worlds <dir> or RADIANT_WORLDS required.
+      `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
+${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
 `
     );
     process.exit(1);
@@ -3799,7 +5018,7 @@ ${DIM}Set it to your Anthropic API key to use Radiant's AI features.${RESET}
     query = args.rest.join(" ");
   }
   if (!query && !process.stdin.isTTY) {
-    query = (0, import_fs4.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs7.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -3809,12 +5028,12 @@ ${DIM}Use --query "...", pass as trailing args, or pipe via stdin.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent2(worldsPath);
+  const explicitWorldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  const worldmodelContent = resolveWorldmodelContent(explicitWorldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(apiKey, model || void 0);
   process.stderr.write(
-    `${DIM}Worlds: ${worldsPath}${RESET}
-${DIM}Lens:   ${lensId}${RESET}
+    `${DIM}Lens:   ${lensId}${RESET}
 ${DIM}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET}
 
 `
@@ -3873,14 +5092,6 @@ async function cmdEmergent(args) {
     process.stderr.write(
       `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
 ${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
-`
-    );
-    process.exit(1);
-  }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
-    process.stderr.write(
-      `${RED}Error:${RESET} --worlds <dir> or RADIANT_WORLDS required.
 `
     );
     process.exit(1);
@@ -3902,7 +5113,11 @@ ${DIM}Set it to a GitHub PAT with repo read access.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent2(worldsPath);
+  const explicitWorldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  const worldmodelContent = resolveWorldmodelContent(
+    explicitWorldsPath,
+    scope.owner
+  );
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(anthropicKey, model || void 0);
   const view = args.view ?? process.env.RADIANT_VIEW ?? "community";