@neuroverseos/governance 0.8.0 → 0.9.0

package/dist/radiant/index.cjs

@@ -40,10 +40,16 @@ __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,
+  detectOrgExtendsSpec: () => detectOrgExtendsSpec,
+  discoverWorlds: () => discoverWorlds,
   emergent: () => emergent,
   extractSignals: () => extractSignals,
   fetchDiscordActivity: () => fetchDiscordActivity,
@@ -51,6 +57,7 @@ __export(radiant_exports, {
   fetchGitHubOrgActivity: () => fetchGitHubOrgActivity,
   fetchNotionActivity: () => fetchNotionActivity,
   fetchSlackActivity: () => fetchSlackActivity,
+  formatActiveWorlds: () => formatActiveWorlds,
   formatDiscordSignalsForPrompt: () => formatDiscordSignalsForPrompt,
   formatExocortexForPrompt: () => formatExocortexForPrompt,
   formatNotionSignalsForPrompt: () => formatNotionSignalsForPrompt,
@@ -58,23 +65,32 @@ __export(radiant_exports, {
   formatScope: () => formatScope,
   formatSlackSignalsForPrompt: () => formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt: () => formatTeamExocorticesForPrompt,
+  getCacheDir: () => getCacheDir,
   getLens: () => getLens,
+  getRepoOrigin: () => getRepoOrigin,
   interpretPatterns: () => interpretPatterns,
   isPresent: () => isPresent,
   isScored: () => isScored,
   isSentinel: () => isSentinel,
   listLenses: () => listLenses,
+  loadExtendsConfig: () => loadExtendsConfig,
   loadPriorReads: () => loadPriorReads,
+  parseExtendsSpec: () => parseExtendsSpec,
+  parseRemoteUrl: () => parseRemoteUrl,
   parseRepoScope: () => parseRepoScope,
   parseScope: () => parseScope,
   presenceAverage: () => presenceAverage,
   readExocortex: () => readExocortex,
+  readOriginRemote: () => readOriginRemote,
   readTeamExocortices: () => readTeamExocortices,
   render: () => render,
+  resolveAllExtends: () => resolveAllExtends,
+  resolveExtendsSpec: () => resolveExtendsSpec,
   scoreComposite: () => scoreComposite,
   scoreCyber: () => scoreCyber,
   scoreLife: () => scoreLife,
   scoreNeuroVerse: () => scoreNeuroVerse,
+  sovereignConduitLens: () => sovereignConduitLens,
   summarizeExocortex: () => summarizeExocortex,
   think: () => think,
   updateKnowledge: () => updateKnowledge,
@@ -564,9 +580,290 @@ var aukiBuilderLens = {
   rewrite: aukiBuilderRewrite
 };
 
+// src/radiant/lenses/sovereign-conduit.ts
+var 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"
+      }
+    ]
+  }
+};
+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, 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.`
+};
+var 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"
+]);
+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].",
+  // 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]."
+]);
+var 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."
+]);
+var 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.'
+  }
+]);
+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 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 = Object.freeze({
-  "auki-builder": aukiBuilderLens
+  "auki-builder": aukiBuilderLens,
+  "sovereign-conduit": sovereignConduitLens
 });
 function getLens(id) {
   return LENSES[id];
@@ -710,91 +1007,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.
-
-${forbiddenBlock}
+Do NOT use: ${cl.forbiddenPhrases}
 
-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
@@ -1105,7 +1477,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) {
@@ -1124,16 +1496,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) {
@@ -1637,15 +2057,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
 
@@ -1836,30 +2258,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());
@@ -2067,6 +2475,356 @@ function serializeYAML(obj, indent = 0) {
 `;
 }
 
+// src/radiant/core/discovery.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_os2 = require("os");
+
+// src/radiant/core/extends.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os = require("os");
+var import_crypto = require("crypto");
+var import_child_process = require("child_process");
+
+// src/radiant/core/git-remote.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+function resolveGitConfigPath(repoDir) {
+  const dotGit = (0, import_path2.join)(repoDir, ".git");
+  if (!(0, import_fs2.existsSync)(dotGit)) return null;
+  try {
+    const stat = (0, import_fs2.statSync)(dotGit);
+    if (stat.isDirectory()) {
+      return (0, import_path2.join)(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs2.readFileSync)(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = (0, import_path2.resolve)(repoDir, match[1].trim());
+      const configPath = (0, import_path2.join)(gitDir, "config");
+      return (0, import_fs2.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_fs2.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);
+}
+
+// src/radiant/core/extends.ts
+function loadExtendsConfig(repoDir) {
+  const configPath = (0, import_path3.join)(repoDir, ".neuroverse", "config.json");
+  if (!(0, import_fs3.existsSync)(configPath)) return null;
+  try {
+    const raw = (0, import_fs3.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_path3.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  return null;
+}
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? (0, import_path3.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_path3.join)(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = (0, import_path3.join)(cacheDir, ".neuroverse-fetched");
+  if (!(0, import_fs3.existsSync)(stampPath)) return false;
+  try {
+    const stamp = (0, import_fs3.statSync)(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = (0, import_path3.join)(cacheDir, ".neuroverse-fetched");
+  try {
+    (0, import_fs3.mkdirSync)(cacheDir, { recursive: true });
+    (0, import_fs3.writeFileSync)(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+var defaultGitFetcher = (spec, destDir) => {
+  if (spec.kind !== "github") return;
+  const url = `https://github.com/${spec.owner}/${spec.repo}.git`;
+  const parent = (0, import_path3.resolve)(destDir, "..");
+  (0, import_fs3.mkdirSync)(parent, { recursive: true });
+  if ((0, import_fs3.existsSync)(destDir)) {
+    (0, import_fs3.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" });
+};
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = (0, import_path3.isAbsolute)(spec.path) ? spec.path : (0, import_path3.resolve)(repoDir, spec.path);
+    if (!(0, import_fs3.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_fs3.existsSync)(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if ((0, import_fs3.existsSync)(cacheDir) && (0, import_fs3.existsSync)((0, import_path3.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_fs3.existsSync)(cacheDir) && (0, import_fs3.existsSync)((0, import_path3.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_path3.join)(cacheDir, spec.subpath) : cacheDir;
+  if (!(0, import_fs3.existsSync)(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      (0, import_path3.join)(target, "worlds"),
+      (0, import_path3.join)(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if ((0, import_fs3.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;
+}
+
+// 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_path4.join)((0, import_os2.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs4.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_path4.join)(options.repoDir, "worlds"),
+      (0, import_path4.join)(options.repoDir, ".neuroverse", "worlds")
+    ];
+    for (const p of repoPaths) {
+      if ((0, import_fs4.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_path4.resolve)(dirPath);
+  if (!(0, import_fs4.existsSync)(dir)) return [];
+  const stat = (0, import_fs4.statSync)(dir);
+  if (stat.isFile() && dir.endsWith(".md")) {
+    try {
+      return [{
+        name: (0, import_path4.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        source,
+        path: dir,
+        content: (0, import_fs4.readFileSync)(dir, "utf-8")
+      }];
+    } catch {
+      return [];
+    }
+  }
+  if (!stat.isDirectory()) return [];
+  const files = (0, import_fs4.readdirSync)(dir).filter(
+    (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
+  ).sort();
+  return files.map((f) => {
+    const fullPath = (0, import_path4.join)(dir, f);
+    return {
+      name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+      source,
+      path: fullPath,
+      content: (0, import_fs4.readFileSync)(fullPath, "utf-8")
+    };
+  });
+}
+
 // src/engine/text-utils.ts
 function normalizeEventText(event) {
   return [
@@ -3153,10 +3911,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: readdirSync3 } = await import("fs");
+  const { join: join6 } = await import("path");
+  const { readdirSync: readdirSync4 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join3(dirPath, filename);
+    const filePath = join6(dirPath, filename);
     try {
       const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
@@ -3186,11 +3944,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join3(dirPath, "rules");
-    const ruleFiles = readdirSync3(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join6(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(join6(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -3350,25 +4108,25 @@ function emptyAudit(total, reason) {
 }
 
 // src/radiant/memory/palace.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = 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_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 = [
@@ -3455,14 +4213,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]*?-->/
     );
@@ -3480,13 +4238,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] : "";
@@ -3577,16 +4335,29 @@ 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);
     }
   }
   let events;
@@ -3604,6 +4375,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 !== "");
@@ -3614,7 +4419,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");
@@ -3663,7 +4468,9 @@ async function emergent(input) {
     voiceClean: voiceViolations.length === 0,
     signals,
     scores,
-    eventCount: events.length
+    eventCount: events.length,
+    activeAdapters,
+    worldStack
   };
 }
 function computeScores(signals, worldmodelLoaded) {
@@ -3728,10 +4535,16 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   classifyActorDomain,
   classifyEvents,
   composeSystemPrompt,
+  compressExocortex,
+  compressLens,
+  compressPriorReads,
+  compressWorldmodel,
   computePersistence,
   createAnthropicAI,
   createMockAI,
   createMockGitHubAdapter,
+  detectOrgExtendsSpec,
+  discoverWorlds,
   emergent,
   extractSignals,
   fetchDiscordActivity,
@@ -3739,6 +4552,7 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   fetchGitHubOrgActivity,
   fetchNotionActivity,
   fetchSlackActivity,
+  formatActiveWorlds,
   formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
   formatNotionSignalsForPrompt,
@@ -3746,23 +4560,32 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   formatScope,
   formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt,
+  getCacheDir,
   getLens,
+  getRepoOrigin,
   interpretPatterns,
   isPresent,
   isScored,
   isSentinel,
   listLenses,
+  loadExtendsConfig,
   loadPriorReads,
+  parseExtendsSpec,
+  parseRemoteUrl,
   parseRepoScope,
   parseScope,
   presenceAverage,
   readExocortex,
+  readOriginRemote,
   readTeamExocortices,
   render,
+  resolveAllExtends,
+  resolveExtendsSpec,
   scoreComposite,
   scoreCyber,
   scoreLife,
   scoreNeuroVerse,
+  sovereignConduitLens,
   summarizeExocortex,
   think,
   updateKnowledge,