@neuroverseos/governance 0.8.0 → 0.9.0

package/dist/cli/neuroverse.cjs

@@ -2002,10 +2002,10 @@ __export(world_loader_exports, {
 });
 async function loadWorldFromDirectory(dirPath) {
   const { readFile: readFile4 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const { readdirSync: readdirSync10 } = await import("fs");
+  const { join: join21 } = await import("path");
+  const { readdirSync: readdirSync11 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join18(dirPath, filename);
+    const filePath = join21(dirPath, filename);
     try {
       const content = await readFile4(filePath, "utf-8");
       return JSON.parse(content);
@@ -2035,11 +2035,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join18(dirPath, "rules");
-    const ruleFiles = readdirSync10(rulesDir).filter((f) => f.endsWith(".json")).sort();
+    const rulesDir = join21(dirPath, "rules");
+    const ruleFiles = readdirSync11(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile4(join18(rulesDir, file), "utf-8");
+        const content = await readFile4(join21(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -2093,8 +2093,8 @@ async function loadWorld(worldPath) {
 }
 async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
   const { readFile: readFile4 } = await import("fs/promises");
-  const { join: join18, dirname: dirname4 } = await import("path");
-  const { existsSync: existsSync14 } = await import("fs");
+  const { join: join21, dirname: dirname4 } = await import("path");
+  const { existsSync: existsSync17 } = await import("fs");
   const { fileURLToPath: fileURLToPath3 } = await import("url");
   const { parseWorldMarkdown: parseWorldMarkdown2 } = await Promise.resolve().then(() => (init_bootstrap_parser(), bootstrap_parser_exports));
   const { emitWorldDefinition: emitWorldDefinition2 } = await Promise.resolve().then(() => (init_bootstrap_emitter(), bootstrap_emitter_exports));
@@ -2102,16 +2102,16 @@ async function loadBundledWorld(name = DEFAULT_BUNDLED_WORLD) {
   let packageRoot;
   try {
     const thisFile = typeof __dirname !== "undefined" ? __dirname : dirname4(fileURLToPath3(import_meta.url));
-    packageRoot = join18(thisFile, "..", "..");
+    packageRoot = join21(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join18(packageRoot, "dist", "worlds", filename),
-    join18(packageRoot, "src", "worlds", filename)
+    join21(packageRoot, "dist", "worlds", filename),
+    join21(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync14(candidate)) {
+    if (existsSync17(candidate)) {
       const markdown = await readFile4(candidate, "utf-8");
       const parsed = parseWorldMarkdown2(markdown);
       if (!parsed.world) {
@@ -2141,8 +2141,8 @@ function slugify(text) {
 }
 async function addGuard(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const guardsPath = join18(worldDir, "guards.json");
+  const { join: join21 } = await import("path");
+  const guardsPath = join21(worldDir, "guards.json");
   let config;
   try {
     const raw = await readFile4(guardsPath, "utf-8");
@@ -2182,13 +2182,13 @@ async function addGuard(worldDir, input) {
 }
 async function addRule(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const { readdirSync: readdirSync10 } = await import("fs");
-  const rulesDir = join18(worldDir, "rules");
+  const { join: join21 } = await import("path");
+  const { readdirSync: readdirSync11 } = await import("fs");
+  const rulesDir = join21(worldDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
-    const existing = readdirSync10(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
+    const existing = readdirSync11(rulesDir).filter((f) => f.match(/^rule-\d+\.json$/)).sort();
     if (existing.length > 0) {
       const lastFile = existing[existing.length - 1];
       const match = lastFile.match(/rule-(\d+)\.json/);
@@ -2214,7 +2214,7 @@ async function addRule(worldDir, input) {
       effect_text: input.effects ? input.effects.map((e) => `${e.target} ${e.operation} ${e.value}`).join(", ") : "No direct effects"
     }
   };
-  const rulePath = join18(rulesDir, `rule-${ruleNum}.json`);
+  const rulePath = join21(rulesDir, `rule-${ruleNum}.json`);
   await writeFile6(rulePath, JSON.stringify(rule, null, 2) + "\n");
   const { loadWorldFromDirectory: loadWorldFromDirectory3 } = await Promise.resolve().then(() => (init_world_loader(), world_loader_exports));
   const world = await loadWorldFromDirectory3(worldDir);
@@ -2230,8 +2230,8 @@ async function addRule(worldDir, input) {
 }
 async function addInvariant(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const invariantsPath = join18(worldDir, "invariants.json");
+  const { join: join21 } = await import("path");
+  const invariantsPath = join21(worldDir, "invariants.json");
   let config;
   try {
     const raw = await readFile4(invariantsPath, "utf-8");
@@ -2849,27 +2849,27 @@ ${candidates.map((c) => `  - ${c}`).join("\n")}`
 }
 async function collectMarkdownSources(inputPath) {
   const { stat, readFile: rf, readdir } = await import("fs/promises");
-  const { join: pathJoin, extname: extname4, basename: basename5 } = await import("path");
+  const { join: pathJoin, extname: extname4, basename: basename6 } = await import("path");
   const stats = await stat(inputPath);
   if (stats.isFile()) {
     const content = await rf(inputPath, "utf-8");
-    return [{ filename: basename5(inputPath), content }];
+    return [{ filename: basename6(inputPath), content }];
   }
   if (stats.isDirectory()) {
     const sources = [];
-    await collectDir(inputPath, sources, rf, pathJoin, extname4, basename5);
+    await collectDir(inputPath, sources, rf, pathJoin, extname4, basename6);
     sources.sort((a, b) => a.filename.localeCompare(b.filename));
     return sources;
   }
   throw new Error(`Input path is neither a file nor a directory: ${inputPath}`);
 }
-async function collectDir(dir, sources, rf, pathJoin, extname4, basename5) {
+async function collectDir(dir, sources, rf, pathJoin, extname4, basename6) {
   const { readdir } = await import("fs/promises");
   const entries = await readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = pathJoin(dir, entry.name);
     if (entry.isDirectory()) {
-      await collectDir(fullPath, sources, rf, pathJoin, extname4, basename5);
+      await collectDir(fullPath, sources, rf, pathJoin, extname4, basename6);
     } else if (entry.isFile() && extname4(entry.name).toLowerCase() === ".md") {
       const content = await rf(fullPath, "utf-8");
       sources.push({ filename: entry.name, content });
@@ -3528,21 +3528,21 @@ function parseArgs2(argv) {
 }
 async function writeWorldFiles(outputDir, world) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join18(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join18(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join18(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join18(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile6(join18(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join18(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join18(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join18(outputDir, "rules");
+  await writeFile6(join21(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile6(join21(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile6(join21(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile6(join21(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  await writeFile6(join21(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile6(join21(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile6(join21(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  const rulesDir = join21(outputDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
   for (let i = 0; i < sortedRules.length; i++) {
     const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile6(join18(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join21(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
 }
 function write(msg) {
@@ -3557,12 +3557,12 @@ function printInsight(finding2) {
 async function main2(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs2(argv);
-    const { basename: basename5 } = await import("path");
+    const { basename: basename6 } = await import("path");
     write(`
 NeuroVerse World Builder
 `);
     write(`
-Analyzing: ${basename5(args.inputPath)}
+Analyzing: ${basename6(args.inputPath)}
 `);
     const derivedPath = args.outputDir ? `${args.outputDir}/source.nv-world.md` : ".neuroverse/build-output.nv-world.md";
     const { mkdir: mkdir3 } = await import("fs/promises");
@@ -3673,9 +3673,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join18 } = await import("path");
+      const { join: join21 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join18(outputDir, "source.nv-world.md");
+      const sourceDest = join21(outputDir, "source.nv-world.md");
       if (derivedPath !== sourceDest) {
         await copyFile(derivedPath, sourceDest);
       }
@@ -5009,8 +5009,8 @@ async function main6(argv = process.argv.slice(2)) {
   try {
     const args = parseArgs6(argv);
     const { writeFile: writeFile6 } = await import("fs/promises");
-    const { existsSync: existsSync14 } = await import("fs");
-    if (existsSync14(args.outputPath)) {
+    const { existsSync: existsSync17 } = await import("fs");
+    if (existsSync17(args.outputPath)) {
       process.stderr.write(`File already exists: ${args.outputPath}
 `);
       process.stderr.write("Use a different --output path or remove the existing file.\n");
@@ -5868,22 +5868,22 @@ function parseArgs9(argv) {
 }
 async function writeWorldFiles2(outputDir, world) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join18(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join18(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join18(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join18(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join18(outputDir, "rules");
+  await writeFile6(join21(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
+  await writeFile6(join21(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
+  await writeFile6(join21(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
+  await writeFile6(join21(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
+  const rulesDir = join21(outputDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   const sortedRules = [...world.rules].sort((a, b) => a.order - b.order);
   for (let i = 0; i < sortedRules.length; i++) {
     const ruleNum = String(i + 1).padStart(3, "0");
-    await writeFile6(join18(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
+    await writeFile6(join21(rulesDir, `rule-${ruleNum}.json`), JSON.stringify(sortedRules[i], null, 2));
   }
-  await writeFile6(join18(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join18(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join18(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
+  await writeFile6(join21(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
+  await writeFile6(join21(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
+  await writeFile6(join21(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
 }
 async function main9(argv = process.argv.slice(2)) {
   const startTime = performance.now();
@@ -8242,13 +8242,13 @@ function handleHealthCheck() {
 }
 async function handleListPresets(policiesDir) {
   const { readdir, readFile: readFile4 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const dir = policiesDir ?? join18(process.cwd(), "policies");
+  const { join: join21 } = await import("path");
+  const dir = policiesDir ?? join21(process.cwd(), "policies");
   const presets = [];
   try {
     const files = await readdir(dir);
     for (const file of files.filter((f) => f.endsWith(".txt")).sort()) {
-      const content = await readFile4(join18(dir, file), "utf-8");
+      const content = await readFile4(join21(dir, file), "utf-8");
       const id = file.replace(".txt", "");
       const name = id.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
       const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
@@ -8320,7 +8320,7 @@ function govern(action, world, options) {
 }
 async function writeTempWorld(dir, policyLines) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   await mkdir3(dir, { recursive: true });
   const worldJson = {
     world_id: "demo-live",
@@ -8362,9 +8362,9 @@ async function writeTempWorld(dir, policyLines) {
     authoring_method: "manual-authoring"
   };
   await Promise.all([
-    writeFile6(join18(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile6(join18(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile6(join18(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
+    writeFile6(join21(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
+    writeFile6(join21(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
+    writeFile6(join21(dir, "metadata.json"), JSON.stringify(metadataJson, null, 2))
   ]);
 }
 var init_govern = __esm({
@@ -8708,10 +8708,10 @@ data: ${data}
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
   }
   function readBody(req) {
-    return new Promise((resolve10, reject) => {
+    return new Promise((resolve14, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve10(Buffer.concat(chunks).toString("utf-8")));
+      req.on("end", () => resolve14(Buffer.concat(chunks).toString("utf-8")));
       req.on("error", reject);
     });
   }
@@ -11475,9 +11475,9 @@ async function main15(argv) {
   }
   if (worldPath) {
     try {
-      const { existsSync: existsSync14 } = await import("fs");
-      const { join: join18 } = await import("path");
-      const hasWorld = existsSync14(join18(worldPath, "world.json"));
+      const { existsSync: existsSync17 } = await import("fs");
+      const { join: join21 } = await import("path");
+      const hasWorld = existsSync17(join21(worldPath, "world.json"));
       checks.push({
         label: "World file detected",
         status: hasWorld ? "pass" : "fail",
@@ -11492,12 +11492,12 @@ async function main15(argv) {
       });
     }
   } else {
-    const { existsSync: existsSync14 } = await import("fs");
-    const { join: join18 } = await import("path");
+    const { existsSync: existsSync17 } = await import("fs");
+    const { join: join21 } = await import("path");
     const candidates = ["./world", "./.neuroverse", "./worlds"];
     let found;
     for (const dir of candidates) {
-      if (existsSync14(join18(dir, "world.json"))) {
+      if (existsSync17(join21(dir, "world.json"))) {
         found = dir;
         break;
       }
@@ -12549,8 +12549,8 @@ async function deriveCommand(args) {
     return;
   }
   const plan = result.plan;
-  const { mkdirSync: mkdirSync6 } = await import("fs");
-  mkdirSync6(outputDir, { recursive: true });
+  const { mkdirSync: mkdirSync7 } = await import("fs");
+  mkdirSync7(outputDir, { recursive: true });
   const worldJson = {
     world_id: `plan_${plan.plan_id}`,
     name: `Derived: ${plan.objective}`,
@@ -13148,7 +13148,7 @@ async function runPipeMode(config) {
 `);
   }
   const MAX_BUFFER_SIZE = 1e6;
-  return new Promise((resolve10, reject) => {
+  return new Promise((resolve14, reject) => {
     let buffer = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
@@ -13194,7 +13194,7 @@ async function runPipeMode(config) {
         `[neuroverse] Session complete: ${finalState.actionsEvaluated} evaluated, ${finalState.actionsAllowed} allowed, ${finalState.actionsBlocked} blocked, ${finalState.actionsPaused} paused
 `
       );
-      resolve10();
+      resolve14();
     });
     process.stdin.on("error", reject);
   });
@@ -13310,8 +13310,8 @@ ${response.content}
   rl2.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve10) => {
-    rl2.on("close", resolve10);
+  return new Promise((resolve14) => {
+    rl2.on("close", resolve14);
   });
 }
 var SessionManager;
@@ -14422,27 +14422,27 @@ function computeWorldDiff(a, b) {
 }
 async function worldSnapshot(worldPath) {
   const { readdir, readFile: readFile4, mkdir: mkdir3, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join18(worldPath, ".snapshots", timestamp);
+  const snapshotDir = join21(worldPath, ".snapshots", timestamp);
   await mkdir3(snapshotDir, { recursive: true });
   const files = await readdir(worldPath);
   let copied = 0;
   for (const file of files) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join18(worldPath, file), "utf-8");
-      await writeFile6(join18(snapshotDir, file), content, "utf-8");
+      const content = await readFile4(join21(worldPath, file), "utf-8");
+      await writeFile6(join21(snapshotDir, file), content, "utf-8");
       copied++;
     }
   }
   try {
-    const rulesDir = join18(worldPath, "rules");
+    const rulesDir = join21(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join18(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join21(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join18(rulesDir, file), "utf-8");
-        await writeFile6(join18(snapshotDir, "rules", file), content, "utf-8");
+        const content = await readFile4(join21(rulesDir, file), "utf-8");
+        await writeFile6(join21(snapshotDir, "rules", file), content, "utf-8");
         copied++;
       }
     }
@@ -14455,8 +14455,8 @@ async function worldSnapshot(worldPath) {
 }
 async function worldRollback(worldPath) {
   const { readdir, readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
-  const snapshotsDir = join18(worldPath, ".snapshots");
+  const { join: join21 } = await import("path");
+  const snapshotsDir = join21(worldPath, ".snapshots");
   let snapshots;
   try {
     snapshots = (await readdir(snapshotsDir)).sort();
@@ -14471,34 +14471,34 @@ async function worldRollback(worldPath) {
     return;
   }
   const latest = snapshots[snapshots.length - 1];
-  const snapshotDir = join18(snapshotsDir, latest);
+  const snapshotDir = join21(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join18(snapshotsDir, backupTimestamp);
+  const backupDir = join21(snapshotsDir, backupTimestamp);
   await mkdir3(backupDir, { recursive: true });
   const currentFiles = await readdir(worldPath);
   for (const file of currentFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join18(worldPath, file), "utf-8");
-      await writeFile6(join18(backupDir, file), content, "utf-8");
+      const content = await readFile4(join21(worldPath, file), "utf-8");
+      await writeFile6(join21(backupDir, file), content, "utf-8");
     }
   }
   const snapshotFiles = await readdir(snapshotDir);
   let restored = 0;
   for (const file of snapshotFiles) {
     if (file.endsWith(".json")) {
-      const content = await readFile4(join18(snapshotDir, file), "utf-8");
-      await writeFile6(join18(worldPath, file), content, "utf-8");
+      const content = await readFile4(join21(snapshotDir, file), "utf-8");
+      await writeFile6(join21(worldPath, file), content, "utf-8");
       restored++;
     }
   }
   try {
-    const rulesDir = join18(snapshotDir, "rules");
+    const rulesDir = join21(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join18(worldPath, "rules"), { recursive: true });
+    await mkdir3(join21(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join18(rulesDir, file), "utf-8");
-        await writeFile6(join18(worldPath, "rules", file), content, "utf-8");
+        const content = await readFile4(join21(rulesDir, file), "utf-8");
+        await writeFile6(join21(worldPath, "rules", file), content, "utf-8");
         restored++;
       }
     }
@@ -16400,27 +16400,27 @@ function closePrompts() {
 }
 function ask(question, defaultValue) {
   const suffix = defaultValue ? ` [${defaultValue}]` : "";
-  return new Promise((resolve10) => {
+  return new Promise((resolve14) => {
     getRL().question(`
   ${question}${suffix}: `, (answer) => {
       const val = answer.trim();
-      resolve10(val || defaultValue || "");
+      resolve14(val || defaultValue || "");
     });
   });
 }
 function confirm(question, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve10) => {
+  return new Promise((resolve14) => {
     getRL().question(`
   ${question} ${hint}: `, (answer) => {
       const val = answer.trim().toLowerCase();
-      if (val === "") resolve10(defaultYes);
-      else resolve10(val === "y" || val === "yes");
+      if (val === "") resolve14(defaultYes);
+      else resolve14(val === "y" || val === "yes");
     });
   });
 }
 function choose(question, options) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve14) => {
     const r = getRL();
     r.write(`
   ${question}
@@ -16430,9 +16430,9 @@ function choose(question, options) {
     r.question(`  Choice [1-${options.length}]: `, (answer) => {
       const idx = parseInt(answer.trim(), 10) - 1;
       if (idx >= 0 && idx < options.length) {
-        resolve10(options[idx]);
+        resolve14(options[idx]);
       } else {
-        resolve10(options[0]);
+        resolve14(options[0]);
       }
     });
   });
@@ -16901,15 +16901,15 @@ function generateWorld(state) {
   return { worldJson, stateSchema, guardsJson, rules, gatesJson, invariants, outcomes, metadata };
 }
 async function writeWorld(outputDir, world) {
-  const { mkdirSync: mkdirSync6, existsSync: existsSync14 } = await import("fs");
+  const { mkdirSync: mkdirSync7, existsSync: existsSync17 } = await import("fs");
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   const files = [];
-  if (!existsSync14(outputDir)) mkdirSync6(outputDir, { recursive: true });
-  const rulesDir = join18(outputDir, "rules");
-  if (!existsSync14(rulesDir)) mkdirSync6(rulesDir, { recursive: true });
+  if (!existsSync17(outputDir)) mkdirSync7(outputDir, { recursive: true });
+  const rulesDir = join21(outputDir, "rules");
+  if (!existsSync17(rulesDir)) mkdirSync7(rulesDir, { recursive: true });
   const writeJson = async (name, data) => {
-    const path = join18(outputDir, name);
+    const path = join21(outputDir, name);
     await writeFile6(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
     files.push(path);
   };
@@ -16921,7 +16921,7 @@ async function writeWorld(outputDir, world) {
   await writeJson("outcomes.json", world.outcomes);
   await writeJson("metadata.json", world.metadata);
   for (const rule of world.rules) {
-    const rulePath = join18(rulesDir, `${rule.id}.json`);
+    const rulePath = join21(rulesDir, `${rule.id}.json`);
     await writeFile6(rulePath, JSON.stringify(rule, null, 2) + "\n", "utf-8");
     files.push(rulePath);
   }
@@ -17008,7 +17008,7 @@ async function main31(argv = process.argv.slice(2)) {
 }
 async function phaseRefine(outputDir, world) {
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   heading("Refinement: Thresholds & Collapse");
   const primaryMetric = world.gatesJson.viability_classification[0]?.field || "system_health";
   info(`
@@ -17025,7 +17025,7 @@ async function phaseRefine(outputDir, world) {
       if (!isNaN(parsed)) gate.value = parsed;
     }
     await writeFile6(
-      join18(outputDir, "gates.json"),
+      join21(outputDir, "gates.json"),
       JSON.stringify(world.gatesJson, null, 2) + "\n",
       "utf-8"
     );
@@ -17047,7 +17047,7 @@ async function phaseRefine(outputDir, world) {
           result: "MODEL_COLLAPSES"
         };
         await writeFile6(
-          join18(outputDir, "rules", `${rule.id}.json`),
+          join21(outputDir, "rules", `${rule.id}.json`),
           JSON.stringify(rule, null, 2) + "\n",
           "utf-8"
         );
@@ -18100,9 +18100,9 @@ async function cmdAdd(argv) {
     id = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
   }
   const { readFile: readFile4, writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join18 } = await import("path");
+  const { join: join21 } = await import("path");
   const possiblePaths = [
-    join18(worldPath, "world.nv-world.md"),
+    join21(worldPath, "world.nv-world.md"),
     worldPath
   ];
   let mdPath = "";
@@ -18123,7 +18123,7 @@ async function cmdAdd(argv) {
       const files = await readdir(worldPath);
       const mdFile = files.find((f) => f.endsWith(".nv-world.md"));
       if (mdFile) {
-        mdPath = join18(worldPath, mdFile);
+        mdPath = join21(worldPath, mdFile);
         mdContent = await readFile4(mdPath, "utf-8");
       }
     } catch {
@@ -18795,6 +18795,15 @@ var init_worldmodel_parser = __esm({
 });
 
 // src/engine/worldmodel-compiler.ts
+var worldmodel_compiler_exports = {};
+__export(worldmodel_compiler_exports, {
+  compileWorldModel: () => compileWorldModel,
+  emitContextsConfig: () => emitContextsConfig,
+  emitLensSuggestions: () => emitLensSuggestions,
+  emitOverlapMap: () => emitOverlapMap,
+  emitSignalSchema: () => emitSignalSchema,
+  emitWorldMarkdown: () => emitWorldMarkdown
+});
 function toSnakeCase(text) {
   return text.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
 }
@@ -19128,6 +19137,207 @@ var init_worldmodel_compiler = __esm({
   }
 });
 
+// src/cli/worldmodel-create.ts
+var worldmodel_create_exports = {};
+__export(worldmodel_create_exports, {
+  askQuestions: () => askQuestions,
+  saveWorldmodel: () => saveWorldmodel,
+  structureWorldmodel: () => structureWorldmodel
+});
+async function askQuestions() {
+  const rl2 = (0, import_readline.createInterface)({
+    input: process.stdin,
+    output: process.stderr
+    // questions to stderr so stdout stays clean
+  });
+  const answers = {};
+  process.stderr.write("\n");
+  process.stderr.write("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n");
+  process.stderr.write("  \u2551  NeuroVerseOS \u2014 Build your thinking constitution \u2551\n");
+  process.stderr.write("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D\n");
+  process.stderr.write("\n");
+  process.stderr.write("  Answer these questions in your own words.\n");
+  process.stderr.write("  There are no wrong answers \u2014 just say what you mean.\n");
+  process.stderr.write("  The AI will structure your answers into a worldmodel.\n\n");
+  for (const q of QUESTIONS) {
+    const answer = await new Promise((resolve14) => {
+      process.stderr.write(`  \x1B[1m${q.question}\x1B[0m
+`);
+      process.stderr.write(`  \x1B[2m${q.placeholder}\x1B[0m
+`);
+      rl2.question("  > ", (ans) => {
+        process.stderr.write("\n");
+        resolve14(ans.trim());
+      });
+    });
+    answers[q.id] = answer;
+  }
+  rl2.close();
+  return answers;
+}
+async function structureWorldmodel(answers, apiKey) {
+  const prompt = buildStructuringPrompt(answers);
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      max_tokens: 4096,
+      system: "You are a behavioral model architect. You take conversational answers about an organization's values, purpose, and priorities, and structure them into a precise .worldmodel.md file that follows the NeuroVerseOS three-layer format. Output ONLY the markdown file content, nothing else.",
+      messages: [{ role: "user", content: prompt }]
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`AI structuring failed: ${res.status}`);
+  }
+  const data = await res.json();
+  const text = data.content?.filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
+  if (!text) throw new Error("AI returned no content");
+  return text.replace(/^```markdown\n?/, "").replace(/\n?```$/, "").trim();
+}
+function buildStructuringPrompt(answers) {
+  return `Structure these conversational answers into a .worldmodel.md file.
+
+The file MUST follow this exact three-layer format:
+
+---
+name: ${answers.name}
+version: 1.0.0
+---
+
+# Core Model Geometry
+
+## Mission
+(from the mission answer)
+
+## Domains
+(2-4 domains from the domains answer, each with:)
+### Domain Name
+#### Skills (8-10 skills per domain, inferred from the answers)
+#### Values (3-4 values per domain, drawn from the non-negotiables + mission)
+
+## Overlap Effects
+(from the overlaps answer, formatted as: Domain A + Domain B = Emergent State)
+
+## Center Identity
+(from the center answer)
+
+# Contextual Modifiers
+
+## Authority Layers
+(infer 4-5 authority levels appropriate to this organization)
+
+## Spatial Contexts
+(infer 4-5 contexts where behavior happens)
+
+## Interpretation Rules
+(infer 3-5 rules about how context changes meaning)
+
+# Evolution Layer
+
+## Aligned Behaviors
+(from the success answer, expanded to 5-8 items)
+
+## Drift Behaviors
+(from the drift answer, expanded to 5-8 items)
+
+## Signals
+(infer 5-7 observable signals from the answers, snake_case)
+
+## Decision Priorities
+(from the priorities answer, formatted as: preferred > secondary)
+
+## Evolution Conditions
+(infer 3-5 conditions for when the model should adapt)
+
+HERE ARE THE ANSWERS:
+
+Name: ${answers.name}
+
+Mission: ${answers.mission}
+
+Domains: ${answers.domains}
+
+Overlaps: ${answers.overlaps}
+
+Center identity: ${answers.center}
+
+Non-negotiables: ${answers.nonnegotiables}
+
+Success looks like: ${answers.success}
+
+Drift looks like: ${answers.drift}
+
+Priorities: ${answers.priorities}
+
+Output ONLY the .worldmodel.md content. No explanation. No commentary. Just the file.`;
+}
+function saveWorldmodel(content, outputPath) {
+  const resolved = (0, import_path12.resolve)(outputPath);
+  (0, import_fs11.writeFileSync)(resolved, content, "utf-8");
+  return resolved;
+}
+var import_readline, import_fs11, import_path12, QUESTIONS;
+var init_worldmodel_create = __esm({
+  "src/cli/worldmodel-create.ts"() {
+    "use strict";
+    import_readline = require("readline");
+    import_fs11 = require("fs");
+    import_path12 = require("path");
+    QUESTIONS = [
+      {
+        id: "name",
+        question: "What should we call this model? (Your name, your org, your project)",
+        placeholder: 'e.g., "Kirsten", "Auki", "My Startup"'
+      },
+      {
+        id: "mission",
+        question: "In one or two sentences \u2014 what does this system exist to do? Not a slogan. The real purpose.",
+        placeholder: 'e.g., "Protect human thinking while expanding cognitive capability through AI"'
+      },
+      {
+        id: "domains",
+        question: "What are the 2-3 big areas of focus? Not departments \u2014 the major kinds of work that matter most. Separate with commas.",
+        placeholder: 'e.g., "Safety and boundaries, Individual authority, AI as cognitive extension"'
+      },
+      {
+        id: "overlaps",
+        question: "When those areas work well TOGETHER, what does that feel like? Name a feeling for each pair.",
+        placeholder: 'e.g., "Safety + Authority = Trust, Authority + AI = Possibility"'
+      },
+      {
+        id: "center",
+        question: "When EVERYTHING is aligned \u2014 all areas working together \u2014 what does the system become? One name or phrase.",
+        placeholder: 'e.g., "The Sovereign Conduit", "Collective Vanguard Leader"'
+      },
+      {
+        id: "nonnegotiables",
+        question: "What's absolutely non-negotiable? What would you walk away over? List a few.",
+        placeholder: 'e.g., "Humans retain authority over thinking. AI extends, never replaces. People can always leave."'
+      },
+      {
+        id: "success",
+        question: `What does success look like in action? What would you point at and say "that's what I mean"?`,
+        placeholder: 'e.g., "Someone maintaining clear authorship of decisions even when AI contributed"'
+      },
+      {
+        id: "drift",
+        question: "What does drift look like? What would worry you if you saw it happening?",
+        placeholder: 'e.g., "Decision ownership quietly shifting to AI without explicit delegation"'
+      },
+      {
+        id: "priorities",
+        question: 'When tradeoffs appear, what wins? Give a few "X over Y" pairs.',
+        placeholder: 'e.g., "Safety over speed, sovereignty over convenience, diversity over uniformity"'
+      }
+    ];
+  }
+});
+
 // src/cli/worldmodel.ts
 var worldmodel_exports = {};
 __export(worldmodel_exports, {
@@ -19164,8 +19374,8 @@ function formatIssue(issue) {
   return `  ${color}${icon}${RESET2} [${issue.section}${lineRef}] ${issue.message}`;
 }
 async function readSourceFile(inputPath) {
-  const fullPath = (0, import_path12.resolve)(inputPath);
-  if (!(0, import_fs11.existsSync)(fullPath)) {
+  const fullPath = (0, import_path13.resolve)(inputPath);
+  if (!(0, import_fs12.existsSync)(fullPath)) {
     process.stderr.write(`File not found: ${fullPath}
 `);
     process.exit(3);
@@ -19189,30 +19399,145 @@ async function cmdInit(argv) {
   const args = parseArgs26(argv);
   if (args.help) {
     process.stdout.write(
-      'neuroverse worldmodel init \u2014 Scaffold a new .worldmodel.md template\n\nOptions:\n  --name <name>    Model name (default: "My Behavioral Model")\n  --output <path>  Output path (default: ./model.worldmodel.md)\n'
+      'neuroverse worldmodel init \u2014 Create a new behavioral model\n\nWith ANTHROPIC_API_KEY set:\n  Interactive \u2014 answers questions, AI structures your worldmodel.\n  Your natural process: talk \u2192 structure \u2192 refine.\n\nWithout ANTHROPIC_API_KEY:\n  Template \u2014 generates a scaffold you fill in manually.\n\nOptions:\n  --name <name>      Model name (default: "My Behavioral Model")\n  --output <path>    Output path (default: ./model.worldmodel.md)\n  --template         Force template mode even with API key set\n'
     );
     return;
   }
   const modelName = args.name || "My Behavioral Model";
-  const outputPath = (0, import_path12.resolve)(
+  const outputPath = (0, import_path13.resolve)(
     args.output || `./${toFileName(modelName)}.worldmodel.md`
   );
-  if ((0, import_fs11.existsSync)(outputPath)) {
+  if ((0, import_fs12.existsSync)(outputPath)) {
     process.stderr.write(`File already exists: ${outputPath}
 `);
     process.stderr.write("Use --output to specify a different path.\n");
     process.exit(1);
   }
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  const forceTemplate = argv.includes("--template");
+  if (apiKey && !forceTemplate && process.stdin.isTTY) {
+    const { askQuestions: askQuestions2, structureWorldmodel: structureWorldmodel2, saveWorldmodel: saveWorldmodel2 } = await Promise.resolve().then(() => (init_worldmodel_create(), worldmodel_create_exports));
+    process.stderr.write(`
+`);
+    const answers = await askQuestions2();
+    process.stderr.write(`${DIM2}Structuring your worldmodel...${RESET2}
+`);
+    try {
+      const content = await structureWorldmodel2(answers, apiKey);
+      const dir2 = (0, import_path13.dirname)(outputPath);
+      if (!(0, import_fs12.existsSync)(dir2)) {
+        await (0, import_promises6.mkdir)(dir2, { recursive: true });
+      }
+      saveWorldmodel2(content, outputPath);
+      process.stderr.write(`
+${GREEN2}Created${RESET2} ${outputPath}
+`);
+      process.stderr.write(
+        `${DIM2}Review the file, then run: neuroverse worldmodel validate ${(0, import_path13.basename)(outputPath)}${RESET2}
+`
+      );
+      try {
+        const validateResult = parseWorldModel(content);
+        if (validateResult.model) {
+          const m = validateResult.model;
+          process.stderr.write(
+            `${DIM2}  Domains: ${m.geometry.domains.length}  Overlaps: ${m.geometry.overlapEffects.length}  Signals: ${m.evolution.signals.length}${RESET2}
+`
+          );
+        }
+        const errors = validateResult.issues.filter((i) => i.severity === "error");
+        if (errors.length > 0) {
+          process.stderr.write(
+            `
+${YELLOW2}Validation found ${errors.length} issue${errors.length > 1 ? "s" : ""} \u2014 review and fix:${RESET2}
+`
+          );
+          for (const issue of errors) {
+            process.stderr.write(`  ${formatIssue(issue)}
+`);
+          }
+        } else {
+          process.stderr.write(`${GREEN2}Validates cleanly!${RESET2}
+`);
+          try {
+            if (!validateResult.model) throw new Error("no model");
+            const { compileWorldModel: compileWorldModel2 } = await Promise.resolve().then(() => (init_worldmodel_compiler(), worldmodel_compiler_exports));
+            const compiled = compileWorldModel2(validateResult.model);
+            const outDir = (0, import_path13.dirname)(outputPath);
+            const baseName = (0, import_path13.basename)(outputPath).replace(/\.worldmodel\.md$/, "");
+            const worldPath = (0, import_path13.join)(outDir, `${baseName}.nv-world.md`);
+            await (0, import_promises6.writeFile)(worldPath, compiled.worldMarkdown, "utf-8");
+            const signalsPath = (0, import_path13.join)(outDir, "signals.json");
+            await (0, import_promises6.writeFile)(signalsPath, JSON.stringify(compiled.signalSchema, null, 2), "utf-8");
+            const overlapsPath = (0, import_path13.join)(outDir, "overlaps.json");
+            await (0, import_promises6.writeFile)(overlapsPath, JSON.stringify(compiled.overlapMap, null, 2), "utf-8");
+            const contextsPath = (0, import_path13.join)(outDir, "contexts.json");
+            await (0, import_promises6.writeFile)(contextsPath, JSON.stringify(compiled.contextsConfig, null, 2), "utf-8");
+            const lensesPath = (0, import_path13.join)(outDir, "lenses.json");
+            await (0, import_promises6.writeFile)(lensesPath, JSON.stringify(compiled.lensSuggestions, null, 2), "utf-8");
+            process.stderr.write(`
+${GREEN2}Compiled!${RESET2} Token-optimized artifacts:
+`);
+            process.stderr.write(`${DIM2}  ${worldPath}${RESET2}
+`);
+            process.stderr.write(`${DIM2}  ${signalsPath}${RESET2}
+`);
+            process.stderr.write(`${DIM2}  ${overlapsPath}${RESET2}
+`);
+            process.stderr.write(`${DIM2}  ${contextsPath}${RESET2}
+`);
+            process.stderr.write(`${DIM2}  ${lensesPath}${RESET2}
+`);
+            process.stderr.write(`
+${DIM2}Source: ${outputPath} (readable, editable)${RESET2}
+`);
+            process.stderr.write(`${DIM2}Compiled: ready for Radiant \u2014 token-optimized, no prose overhead.${RESET2}
+`);
+          } catch {
+            process.stderr.write(
+              `${DIM2}Auto-compile skipped \u2014 run 'neuroverse worldmodel build ${(0, import_path13.basename)(outputPath)}' manually.${RESET2}
+`
+            );
+          }
+        }
+      } catch {
+      }
+    } catch (err) {
+      process.stderr.write(`${RED}Error:${RESET2} ${err}
+`);
+      process.stderr.write(
+        `${DIM2}Falling back to template mode.${RESET2}
+
+`
+      );
+      const template2 = generateScaffold(modelName);
+      const dir2 = (0, import_path13.dirname)(outputPath);
+      if (!(0, import_fs12.existsSync)(dir2)) {
+        await (0, import_promises6.mkdir)(dir2, { recursive: true });
+      }
+      await (0, import_promises6.writeFile)(outputPath, template2, "utf-8");
+      process.stderr.write(`${GREEN2}Created${RESET2} ${outputPath} (template)
+`);
+    }
+    return;
+  }
+  if (!apiKey && !forceTemplate) {
+    process.stderr.write(
+      `${DIM2}Tip: Set ANTHROPIC_API_KEY for the guided experience \u2014 AI asks you questions and creates your worldmodel.${RESET2}
+
+`
+    );
+  }
   const template = generateScaffold(modelName);
-  const dir = (0, import_path12.dirname)(outputPath);
-  if (!(0, import_fs11.existsSync)(dir)) {
+  const dir = (0, import_path13.dirname)(outputPath);
+  if (!(0, import_fs12.existsSync)(dir)) {
     await (0, import_promises6.mkdir)(dir, { recursive: true });
   }
   await (0, import_promises6.writeFile)(outputPath, template, "utf-8");
   process.stderr.write(`${GREEN2}Created${RESET2} ${outputPath}
 `);
   process.stderr.write(
-    `${DIM2}Edit the template, then run: neuroverse worldmodel validate ${(0, import_path12.basename)(outputPath)}${RESET2}
+    `${DIM2}Edit the template, then run: neuroverse worldmodel validate ${(0, import_path13.basename)(outputPath)}${RESET2}
 `
   );
 }
@@ -19643,17 +19968,17 @@ async function cmdBuild(argv) {
     process.stderr.write("\n");
   }
   const output = compileWorldModel(model);
-  const outputDir = (0, import_path12.resolve)(
+  const outputDir = (0, import_path13.resolve)(
     args.output || `.neuroverse/worldmodels/${model.frontmatter.model_id}/`
   );
-  if (!(0, import_fs11.existsSync)(outputDir)) {
+  if (!(0, import_fs12.existsSync)(outputDir)) {
     await (0, import_promises6.mkdir)(outputDir, { recursive: true });
   }
-  const worldPath = (0, import_path12.join)(outputDir, `${model.frontmatter.model_id}.nv-world.md`);
-  const signalsPath = (0, import_path12.join)(outputDir, "signals.json");
-  const overlapsPath = (0, import_path12.join)(outputDir, "overlaps.json");
-  const contextsPath = (0, import_path12.join)(outputDir, "contexts.json");
-  const lensesPath = (0, import_path12.join)(outputDir, "lenses.json");
+  const worldPath = (0, import_path13.join)(outputDir, `${model.frontmatter.model_id}.nv-world.md`);
+  const signalsPath = (0, import_path13.join)(outputDir, "signals.json");
+  const overlapsPath = (0, import_path13.join)(outputDir, "overlaps.json");
+  const contextsPath = (0, import_path13.join)(outputDir, "contexts.json");
+  const lensesPath = (0, import_path13.join)(outputDir, "lenses.json");
   await Promise.all([
     (0, import_promises6.writeFile)(worldPath, output.worldMarkdown, "utf-8"),
     (0, import_promises6.writeFile)(signalsPath, JSON.stringify(output.signalSchema, null, 2) + "\n", "utf-8"),
@@ -19685,7 +20010,7 @@ async function cmdBuild(argv) {
 `);
     process.stderr.write(`  ${BOLD2}Output:${RESET2} ${outputDir}/
 `);
-    process.stderr.write(`    ${(0, import_path12.basename)(worldPath)}${DIM2}  \u2014 executable world${RESET2}
+    process.stderr.write(`    ${(0, import_path13.basename)(worldPath)}${DIM2}  \u2014 executable world${RESET2}
 `);
     process.stderr.write(`    signals.json${DIM2}     \u2014 signal schema${RESET2}
 `);
@@ -19721,9 +20046,9 @@ async function cmdEmitWorld(argv) {
   const { model } = await loadAndParse(args.inputPath);
   const markdown = emitWorldMarkdown(model);
   if (args.output) {
-    const dir = (0, import_path12.dirname)((0, import_path12.resolve)(args.output));
-    if (!(0, import_fs11.existsSync)(dir)) await (0, import_promises6.mkdir)(dir, { recursive: true });
-    await (0, import_promises6.writeFile)((0, import_path12.resolve)(args.output), markdown, "utf-8");
+    const dir = (0, import_path13.dirname)((0, import_path13.resolve)(args.output));
+    if (!(0, import_fs12.existsSync)(dir)) await (0, import_promises6.mkdir)(dir, { recursive: true });
+    await (0, import_promises6.writeFile)((0, import_path13.resolve)(args.output), markdown, "utf-8");
     process.stderr.write(`${GREEN2}Written${RESET2} ${args.output}
 `);
   } else {
@@ -19814,13 +20139,13 @@ async function main33(argv = process.argv.slice(2)) {
       process.exit(1);
   }
 }
-var import_promises6, import_fs11, import_path12, BOLD2, DIM2, CYAN2, GREEN2, YELLOW2, RED, MAGENTA2, RESET2, USAGE9;
+var import_promises6, import_fs12, import_path13, BOLD2, DIM2, CYAN2, GREEN2, YELLOW2, RED, MAGENTA2, RESET2, USAGE9;
 var init_worldmodel = __esm({
   "src/cli/worldmodel.ts"() {
     "use strict";
     import_promises6 = require("fs/promises");
-    import_fs11 = require("fs");
-    import_path12 = require("path");
+    import_fs12 = require("fs");
+    import_path13 = require("path");
     init_worldmodel_parser();
     init_worldmodel_compiler();
     BOLD2 = "\x1B[1m";
@@ -20292,13 +20617,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: () => getLens2,
-  listLenses: () => listLenses
+  listLenses: () => listLenses,
+  sovereignConduitLens: () => sovereignConduitLens
 });
 function getLens2(id) {
   return LENSES[id];
@@ -20311,102 +20923,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/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
-
-${questionsBlock}
-
-### Overlap emergent states
-
-${overlapsBlock}
-
-### 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})
-
-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}
+// 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";
+  }
+});
 
-### Output translation discipline
+// src/radiant/core/prompt.ts
+function composeSystemPrompt(worldmodelContent, lens) {
+  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)
 
-${lens.voice.output_translation}
+${compressedWorld}`,
+    // Section 2: Analytical frame (evaluation questions + rubric)
+    `## How to Think
 
-### Vocabulary
+${cl.scoringRubric}
 
-Proper nouns (use literally): ${vocabProperNouns}
+Questions:
+${cl.evaluationQuestions}
 
-Preferred term substitutions:
-${vocabPreferred}
+Overlaps: ${overlapsBlock}
+Center: ${lens.primary_frame.center_identity}
 
-Architecture vocabulary: ${vocabArchitecture}
+Translate before output: ${cl.jargonTranslations}`,
+    // Section 3: Voice (compressed — register + key rules only)
+    `## Voice: ${lens.name}
 
-### Strategic decision patterns
+Register: ${lens.voice.register}
+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}.
 
-When recommending action, these patterns reflect how this organization resolves tradeoffs:
+${lens.voice.output_translation}
 
-${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");
 }
 var init_prompt = __esm({
   "src/radiant/core/prompt.ts"() {
     "use strict";
+    init_compress();
   }
 });
 
@@ -20613,130 +21309,905 @@ function mapComment(comment, scope) {
   };
   return event;
 }
-function mapUser(ghUser, fallbackName) {
-  if (!ghUser) {
+function mapUser(ghUser, fallbackName) {
+  if (!ghUser) {
+    return {
+      id: fallbackName ?? "unknown",
+      kind: "unknown",
+      name: fallbackName
+    };
+  }
+  let kind = "human";
+  if (ghUser.type === "Bot" || ghUser.login.endsWith("[bot]")) {
+    kind = "bot";
+  }
+  if (KNOWN_AI_LOGINS.has(ghUser.login.toLowerCase())) {
+    kind = "bot";
+  }
+  return {
+    id: ghUser.login,
+    kind,
+    name: ghUser.login
+  };
+}
+function extractCoAuthors(message) {
+  const coAuthors = [];
+  const lines = message.split("\n");
+  for (const line of lines) {
+    const match = line.match(
+      /^Co-authored-by:\s*(.+?)\s*<([^>]*)>/i
+    );
+    if (match) {
+      const name = match[1].trim().toLowerCase();
+      const isAI = KNOWN_AI_CO_AUTHOR_NAMES.has(name) || [...KNOWN_AI_CO_AUTHOR_NAMES].some((ai) => name.includes(ai));
+      coAuthors.push({
+        id: match[2] || name,
+        kind: isAI ? "ai" : "human",
+        name: match[1].trim()
+      });
+    }
+  }
+  return coAuthors;
+}
+async function fetchJSON(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 404) return [];
+    if (res.status === 403) {
+      const body = await res.text();
+      if (body.includes("rate limit")) {
+        throw new Error(
+          `GitHub API rate limit exceeded. Wait or use a token with higher limits.`
+        );
+      }
+    }
+    throw new Error(
+      `GitHub API error ${res.status} for ${url}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  return await res.json();
+}
+async function fetchGitHubOrgActivity(scope, token, options = {}) {
+  const perPage = options.perPage ?? 100;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const repos = await fetchJSON(
+    `https://api.github.com/orgs/${scope.owner}/repos?sort=pushed&direction=desc&per_page=${perPage}`,
+    headers
+  );
+  const windowDays = options.windowDays ?? 14;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const activeRepos = repos.filter(
+    (r) => new Date(r.pushed_at) >= since
+  );
+  const cappedRepos = activeRepos.slice(0, 10);
+  const allEvents = [];
+  const repoNames = [];
+  for (const repo of cappedRepos) {
+    const [owner, repoName] = repo.full_name.split("/");
+    try {
+      const repoScope = { type: "repo", owner, repo: repoName };
+      const events = await fetchGitHubActivity(repoScope, token, options);
+      allEvents.push(...events);
+      if (events.length > 0) repoNames.push(repo.full_name);
+    } catch {
+    }
+  }
+  allEvents.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return { events: allEvents, repos: repoNames };
+}
+var KNOWN_AI_LOGINS, KNOWN_AI_CO_AUTHOR_NAMES;
+var init_github2 = __esm({
+  "src/radiant/adapters/github.ts"() {
+    "use strict";
+    init_scopes();
+    KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
+      "github-actions[bot]",
+      "dependabot[bot]",
+      "renovate[bot]",
+      "copilot"
+    ]);
+    KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
+      "claude",
+      "copilot",
+      "cursor",
+      "codeium",
+      "tabnine",
+      "codex"
+    ]);
+  }
+});
+
+// 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_path14.join)(repoDir, ".git");
+  if (!(0, import_fs13.existsSync)(dotGit)) return null;
+  try {
+    const stat = (0, import_fs13.statSync)(dotGit);
+    if (stat.isDirectory()) {
+      return (0, import_path14.join)(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs13.readFileSync)(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = (0, import_path14.resolve)(repoDir, match[1].trim());
+      const configPath = (0, import_path14.join)(gitDir, "config");
+      return (0, import_fs13.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_fs13.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_fs13, import_path14;
+var init_git_remote = __esm({
+  "src/radiant/core/git-remote.ts"() {
+    "use strict";
+    import_fs13 = require("fs");
+    import_path14 = require("path");
+  }
+});
+
+// src/radiant/core/extends.ts
+function loadExtendsConfig(repoDir) {
+  const configPath = (0, import_path15.join)(repoDir, ".neuroverse", "config.json");
+  if (!(0, import_fs14.existsSync)(configPath)) return null;
+  try {
+    const raw = (0, import_fs14.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 {
-      id: fallbackName ?? "unknown",
-      kind: "unknown",
-      name: fallbackName
+      raw: trimmed,
+      kind: "github",
+      owner: match[1],
+      repo: match[2],
+      ref: match[3] ?? "HEAD",
+      subpath: match[4] ?? ""
     };
   }
-  let kind = "human";
-  if (ghUser.type === "Bot" || ghUser.login.endsWith("[bot]")) {
-    kind = "bot";
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || (0, import_path15.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
   }
-  if (KNOWN_AI_LOGINS.has(ghUser.login.toLowerCase())) {
-    kind = "bot";
+  return null;
+}
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? (0, import_path15.join)((0, import_os5.homedir)(), ".neuroverse", "cache", "extends");
+  const key = (0, import_crypto4.createHash)("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return (0, import_path15.join)(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = (0, import_path15.join)(cacheDir, ".neuroverse-fetched");
+  if (!(0, import_fs14.existsSync)(stampPath)) return false;
+  try {
+    const stamp = (0, import_fs14.statSync)(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = (0, import_path15.join)(cacheDir, ".neuroverse-fetched");
+  try {
+    (0, import_fs14.mkdirSync)(cacheDir, { recursive: true });
+    (0, import_fs14.writeFileSync)(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = (0, import_path15.isAbsolute)(spec.path) ? spec.path : (0, import_path15.resolve)(repoDir, spec.path);
+    if (!(0, import_fs14.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_fs14.existsSync)(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if ((0, import_fs14.existsSync)(cacheDir) && (0, import_fs14.existsSync)((0, import_path15.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_fs14.existsSync)(cacheDir) && (0, import_fs14.existsSync)((0, import_path15.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_path15.join)(cacheDir, spec.subpath) : cacheDir;
+  if (!(0, import_fs14.existsSync)(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      (0, import_path15.join)(target, "worlds"),
+      (0, import_path15.join)(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if ((0, import_fs14.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 {
-    id: ghUser.login,
-    kind,
-    name: ghUser.login
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
   };
 }
-function extractCoAuthors(message) {
-  const coAuthors = [];
-  const lines = message.split("\n");
-  for (const line of lines) {
-    const match = line.match(
-      /^Co-authored-by:\s*(.+?)\s*<([^>]*)>/i
-    );
-    if (match) {
-      const name = match[1].trim().toLowerCase();
-      const isAI = KNOWN_AI_CO_AUTHOR_NAMES.has(name) || [...KNOWN_AI_CO_AUTHOR_NAMES].some((ai) => name.includes(ai));
-      coAuthors.push({
-        id: match[2] || name,
-        kind: isAI ? "ai" : "human",
-        name: match[1].trim()
+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 coAuthors;
+  return results;
 }
-async function fetchJSON(url, headers) {
-  const res = await fetch(url, { headers });
-  if (!res.ok) {
-    if (res.status === 404) return [];
-    if (res.status === 403) {
-      const body = await res.text();
-      if (body.includes("rate limit")) {
-        throw new Error(
-          `GitHub API rate limit exceeded. Wait or use a token with higher limits.`
-        );
+var import_fs14, import_path15, import_os5, import_crypto4, import_child_process2, DEFAULT_TTL_MS, defaultGitFetcher;
+var init_extends = __esm({
+  "src/radiant/core/extends.ts"() {
+    "use strict";
+    import_fs14 = require("fs");
+    import_path15 = require("path");
+    import_os5 = require("os");
+    import_crypto4 = require("crypto");
+    import_child_process2 = 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_path15.resolve)(destDir, "..");
+      (0, import_fs14.mkdirSync)(parent, { recursive: true });
+      if ((0, import_fs14.existsSync)(destDir)) {
+        (0, import_fs14.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_process2.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_path16.join)((0, import_os6.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs15.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"
+        });
       }
     }
-    throw new Error(
-      `GitHub API error ${res.status} for ${url}: ${(await res.text()).slice(0, 300)}`
-    );
+    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"));
+    }
   }
-  return await res.json();
+  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_path16.join)(options.repoDir, "worlds"),
+      (0, import_path16.join)(options.repoDir, ".neuroverse", "worlds")
+    ];
+    for (const p of repoPaths) {
+      if ((0, import_fs15.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 summary2 = worlds.length === 0 ? "no worlds discovered" : worlds.map((w) => `${w.name} (${w.source})`).join(", ");
+  return { worlds, combinedContent, summary: summary2, warnings };
 }
-async function fetchGitHubOrgActivity(scope, token, options = {}) {
-  const perPage = options.perPage ?? 100;
-  const headers = {
-    Authorization: `token ${token}`,
-    Accept: "application/vnd.github.v3+json",
-    "User-Agent": "neuroverseos-radiant"
-  };
-  const repos = await fetchJSON(
-    `https://api.github.com/orgs/${scope.owner}/repos?sort=pushed&direction=desc&per_page=${perPage}`,
-    headers
-  );
-  const windowDays = options.windowDays ?? 14;
-  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
-  const activeRepos = repos.filter(
-    (r) => new Date(r.pushed_at) >= since
-  );
-  const cappedRepos = activeRepos.slice(0, 10);
-  const allEvents = [];
-  const repoNames = [];
-  for (const repo of cappedRepos) {
-    const [owner, repoName] = repo.full_name.split("/");
+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_path16.resolve)(dirPath);
+  if (!(0, import_fs15.existsSync)(dir)) return [];
+  const stat = (0, import_fs15.statSync)(dir);
+  if (stat.isFile() && dir.endsWith(".md")) {
     try {
-      const repoScope = { type: "repo", owner, repo: repoName };
-      const events = await fetchGitHubActivity(repoScope, token, options);
-      allEvents.push(...events);
-      if (events.length > 0) repoNames.push(repo.full_name);
+      return [{
+        name: (0, import_path16.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        source,
+        path: dir,
+        content: (0, import_fs15.readFileSync)(dir, "utf-8")
+      }];
     } catch {
+      return [];
     }
   }
-  allEvents.sort(
-    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
-  );
-  return { events: allEvents, repos: repoNames };
+  if (!stat.isDirectory()) return [];
+  const files = (0, import_fs15.readdirSync)(dir).filter(
+    (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
+  ).sort();
+  return files.map((f) => {
+    const fullPath = (0, import_path16.join)(dir, f);
+    return {
+      name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+      source,
+      path: fullPath,
+      content: (0, import_fs15.readFileSync)(fullPath, "utf-8")
+    };
+  });
 }
-var KNOWN_AI_LOGINS, KNOWN_AI_CO_AUTHOR_NAMES;
-var init_github2 = __esm({
-  "src/radiant/adapters/github.ts"() {
+var import_fs15, import_path16, import_os6;
+var init_discovery = __esm({
+  "src/radiant/core/discovery.ts"() {
     "use strict";
-    init_scopes();
-    KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
-      "github-actions[bot]",
-      "dependabot[bot]",
-      "renovate[bot]",
-      "copilot"
-    ]);
-    KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
-      "claude",
-      "copilot",
-      "cursor",
-      "codeium",
-      "tabnine",
-      "codex"
-    ]);
+    import_fs15 = require("fs");
+    import_path16 = require("path");
+    import_os6 = require("os");
+    init_extends();
   }
 });
 
 // src/radiant/adapters/exocortex.ts
-function readExocortex(dirPath) {
-  const dir = (0, import_path13.resolve)(dirPath);
+function readExocortex(dirPath, repoName) {
+  const dir = (0, import_path17.resolve)(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = (0, import_path13.join)(dir, p);
-      if ((0, import_fs12.existsSync)(full)) {
+      const full = (0, import_path17.join)(dir, p);
+      if ((0, import_fs16.existsSync)(full)) {
         try {
-          const content = (0, import_fs12.readFileSync)(full, "utf-8").trim();
+          const content = (0, import_fs16.readFileSync)(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -20747,55 +22218,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
-
-${ctx.attention}`);
-  }
-  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
+  if (projectContext && ctx.sprint) {
+    ctx.sprint = `${ctx.sprint}
 
-${ctx.methods}`);
+---
+Project roadmap:
+${projectContext}`;
+  } else if (projectContext) {
+    ctx.sprint = `Project roadmap:
+${projectContext}`;
+    ctx.filesLoaded++;
   }
-  return sections.join("\n\n");
+  return ctx;
 }
 function summarizeExocortex(ctx) {
   if (ctx.filesLoaded === 0) return "no exocortex files found";
@@ -20808,33 +22289,33 @@ function summarizeExocortex(ctx) {
   if (ctx.methods) loaded.push("methods");
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
-var import_fs12, import_path13;
+var import_fs16, import_path17;
 var init_exocortex = __esm({
   "src/radiant/adapters/exocortex.ts"() {
     "use strict";
-    import_fs12 = require("fs");
-    import_path13 = require("path");
+    import_fs16 = require("fs");
+    import_path17 = require("path");
   }
 });
 
 // src/radiant/memory/palace.ts
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = (0, import_path14.resolve)(exocortexDir, "radiant", "reads");
-  (0, import_fs13.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path18.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs17.mkdirSync)(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = (0, import_path14.join)(dir, filename);
+  const filepath = (0, import_path18.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs13.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs17.writeFileSync)(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = (0, import_path14.resolve)(exocortexDir, "radiant");
-  (0, import_fs13.mkdirSync)(dir, { recursive: true });
-  const filepath = (0, import_path14.join)(dir, "knowledge.md");
+  const dir = (0, import_path18.resolve)(exocortexDir, "radiant");
+  (0, import_fs17.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path18.join)(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -20921,14 +22402,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs13.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  (0, import_fs17.writeFileSync)(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!(0, import_fs13.existsSync)(filepath)) return counts;
+  if (!(0, import_fs17.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs13.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs17.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -20946,13 +22427,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = (0, import_path14.resolve)(exocortexDir, "radiant", "reads");
-  if (!(0, import_fs13.existsSync)(dir)) return [];
-  const files = (0, import_fs13.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const dir = (0, import_path18.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs17.existsSync)(dir)) return [];
+  const files = (0, import_fs17.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = (0, import_path14.join)(dir, filename);
-    const content = (0, import_fs13.readFileSync)(filepath, "utf-8");
+    const filepath = (0, import_path18.join)(dir, filename);
+    const content = (0, import_fs17.readFileSync)(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -20986,33 +22467,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_fs13, import_path14;
+var import_fs17, import_path18;
 var init_palace = __esm({
   "src/radiant/memory/palace.ts"() {
     "use strict";
-    import_fs13 = require("fs");
-    import_path14 = require("path");
+    import_fs17 = require("fs");
+    import_path18 = require("path");
   }
 });
 
@@ -21365,15 +22825,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
 
@@ -21552,6 +23014,7 @@ function isPatternLike(x) {
 var init_patterns = __esm({
   "src/radiant/core/patterns.ts"() {
     "use strict";
+    init_compress();
   }
 });
 
@@ -21569,30 +23032,16 @@ Window: last ${input.windowDays} days \xB7 ${input.eventCount} events
 Lens:   ${input.lens.name}`
   );
   if (input.patterns.length > 0) {
-    const canonical = input.patterns.filter((p) => p.type === "canonical");
-    const candidates = input.patterns.filter((p) => p.type === "candidate");
     let emergentBlock = "EMERGENT\n";
-    if (canonical.length > 0) {
-      for (const p of canonical) {
-        emergentBlock += `
+    for (const p of input.patterns) {
+      emergentBlock += `
   ${p.name}
 `;
-        emergentBlock += `    ${p.description}
-`;
-      }
-    }
-    if (candidates.length > 0) {
-      emergentBlock += "\n  Emergent (candidates \u2014 not yet in worldmodel)\n";
-      for (const p of candidates) {
-        emergentBlock += `
-  ${p.name}  (candidate)
-`;
-        emergentBlock += `    ${p.description}
+      emergentBlock += `    ${p.description}
 `;
-        if (p.evidence.cited_invariant) {
-          emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
+      if (p.evidence.cited_invariant) {
+        emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
 `;
-        }
       }
     }
     sections.push(emergentBlock.trimEnd());
@@ -21811,16 +23260,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;
@@ -21838,6 +23300,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 !== "");
@@ -21848,7 +23344,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");
@@ -21897,7 +23393,9 @@ async function emergent(input) {
     voiceClean: voiceViolations.length === 0,
     signals,
     scores,
-    eventCount: events.length
+    eventCount: events.length,
+    activeAdapters,
+    worldStack
   };
 }
 function computeScores(signals, worldmodelLoaded) {
@@ -21952,8 +23450,13 @@ var init_emergent = __esm({
     "use strict";
     init_lenses();
     init_github2();
+    init_discord();
+    init_slack();
+    init_notion();
+    init_discovery();
     init_exocortex();
     init_palace();
+    init_compress();
     init_governance();
     init_signals();
     init_math();
@@ -22010,22 +23513,22 @@ __export(server_exports, {
   startRadiantMcp: () => startRadiantMcp
 });
 function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path15.resolve)(worldsPath);
-  if (!(0, import_fs14.existsSync)(resolved)) {
+  const resolved = (0, import_path19.resolve)(worldsPath);
+  if (!(0, import_fs18.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs14.statSync)(resolved);
+  const stat = (0, import_fs18.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs14.readFileSync)(resolved, "utf-8");
+    return (0, import_fs18.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs14.readdirSync)(resolved).filter(
-      (f) => (0, import_path15.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs18.readdirSync)(resolved).filter(
+      (f) => (0, import_path19.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_fs14.readFileSync)((0, import_path15.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
+    return files.map((f) => (0, import_fs18.readFileSync)((0, import_path19.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
   }
   throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
 }
@@ -22044,12 +23547,12 @@ async function startRadiantMcp(args) {
   const server = new RadiantMcpServer({ worldsPath, lensId, model });
   await server.start();
 }
-var import_fs14, import_path15, TOOLS, RadiantMcpServer;
+var import_fs18, import_path19, TOOLS, RadiantMcpServer;
 var init_server = __esm({
   "src/radiant/mcp/server.ts"() {
     "use strict";
-    import_fs14 = require("fs");
-    import_path15 = require("path");
+    import_fs18 = require("fs");
+    import_path19 = require("path");
     init_think();
     init_emergent();
     init_ai();
@@ -22338,17 +23841,17 @@ function parseArgs27(argv) {
   return result;
 }
 function loadWorldmodelContent2(worldsPath) {
-  const resolved = (0, import_path16.resolve)(worldsPath);
-  if (!(0, import_fs15.existsSync)(resolved)) {
+  const resolved = (0, import_path20.resolve)(worldsPath);
+  if (!(0, import_fs19.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs15.statSync)(resolved);
+  const stat = (0, import_fs19.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs15.readFileSync)(resolved, "utf-8");
+    return (0, import_fs19.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs15.readdirSync)(resolved).filter(
-      (f) => (0, import_path16.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs19.readdirSync)(resolved).filter(
+      (f) => (0, import_path20.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(
@@ -22356,27 +23859,55 @@ function loadWorldmodelContent2(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs15.readFileSync)((0, import_path16.join)(resolved, f), "utf-8");
+      const content = (0, import_fs19.readFileSync)((0, import_path20.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(
-      `${RED2}Error:${RESET3} --lens <id> or RADIANT_LENS required.
-${DIM3}Available lenses: ${listLenses().join(", ")}${RESET3}
+      `${RED2}Error:${RESET3} No worldmodel found.
+${DIM3}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.${RESET3}
 `
     );
     process.exit(1);
   }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
+  process.stderr.write(`${DIM3}${formatActiveWorlds(stack)}${RESET3}
+
+`);
+  for (const warning of stack.warnings) {
+    process.stderr.write(`${YELLOW3}\u26A0${RESET3}  ${warning}
+`);
+  }
+  return stack.combinedContent;
+}
+async function cmdThink(args) {
+  const lensId = args.lens ?? process.env.RADIANT_LENS;
+  if (!lensId) {
     process.stderr.write(
-      `${RED2}Error:${RESET3} --worlds <dir> or RADIANT_WORLDS required.
+      `${RED2}Error:${RESET3} --lens <id> or RADIANT_LENS required.
+${DIM3}Available lenses: ${listLenses().join(", ")}${RESET3}
 `
     );
     process.exit(1);
@@ -22395,7 +23926,7 @@ ${DIM3}Set it to your Anthropic API key to use Radiant's AI features.${RESET3}
     query = args.rest.join(" ");
   }
   if (!query && !process.stdin.isTTY) {
-    query = (0, import_fs15.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs19.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -22405,12 +23936,12 @@ ${DIM3}Use --query "...", pass as trailing args, or pipe via stdin.${RESET3}
     );
     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(
-    `${DIM3}Worlds: ${worldsPath}${RESET3}
-${DIM3}Lens:   ${lensId}${RESET3}
+    `${DIM3}Lens:   ${lensId}${RESET3}
 ${DIM3}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
 
 `
@@ -22469,14 +24000,6 @@ async function cmdEmergent(args) {
     process.stderr.write(
       `${RED2}Error:${RESET3} --lens <id> or RADIANT_LENS required.
 ${DIM3}Available lenses: ${listLenses().join(", ")}${RESET3}
-`
-    );
-    process.exit(1);
-  }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
-    process.stderr.write(
-      `${RED2}Error:${RESET3} --worlds <dir> or RADIANT_WORLDS required.
 `
     );
     process.exit(1);
@@ -22498,7 +24021,11 @@ ${DIM3}Set it to a GitHub PAT with repo read access.${RESET3}
     );
     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";
@@ -22672,18 +24199,19 @@ async function main34(argv) {
       process.exit(1);
   }
 }
-var import_fs15, import_path16, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
+var import_fs19, import_path20, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
 var init_radiant = __esm({
   "src/cli/radiant.ts"() {
     "use strict";
-    import_fs15 = require("fs");
-    import_path16 = require("path");
+    import_fs19 = require("fs");
+    import_path20 = require("path");
     init_think();
     init_emergent();
     init_ai();
     init_scopes();
     init_exocortex();
     init_lenses();
+    init_discovery();
     RED2 = "\x1B[31m";
     DIM3 = "\x1B[2m";
     BOLD3 = "\x1B[1m";
@@ -22709,6 +24237,18 @@ ${BOLD3}Usage:${RESET3}
   neuroverse radiant lenses list
   neuroverse radiant lenses describe auki-builder
 
+${BOLD3}Auto-discovery:${RESET3}
+  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.
+
 ${BOLD3}Environment:${RESET3}
   ANTHROPIC_API_KEY    Required for AI commands (think, emergent, decision)
   RADIANT_WORLDS       Default worlds directory (overridden by --worlds)