@neuroverseos/governance 0.8.1 → 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: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   const { readdirSync: readdirSync11 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join19(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 = join19(dirPath, "rules");
+    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(join19(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: join19, dirname: dirname4 } = await import("path");
-  const { existsSync: existsSync15 } = 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 = join19(thisFile, "..", "..");
+    packageRoot = join21(thisFile, "..", "..");
   } catch {
     packageRoot = process.cwd();
   }
   const candidates = [
-    join19(packageRoot, "dist", "worlds", filename),
-    join19(packageRoot, "src", "worlds", filename)
+    join21(packageRoot, "dist", "worlds", filename),
+    join21(packageRoot, "src", "worlds", filename)
   ];
   for (const candidate of candidates) {
-    if (existsSync15(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: join19 } = await import("path");
-  const guardsPath = join19(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,9 +2182,9 @@ async function addGuard(worldDir, input) {
 }
 async function addRule(worldDir, input) {
   const { readFile: readFile4, writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   const { readdirSync: readdirSync11 } = await import("fs");
-  const rulesDir = join19(worldDir, "rules");
+  const rulesDir = join21(worldDir, "rules");
   await mkdir3(rulesDir, { recursive: true });
   let nextNum = 1;
   try {
@@ -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 = join19(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: join19 } = await import("path");
-  const invariantsPath = join19(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");
@@ -3528,21 +3528,21 @@ function parseArgs2(argv) {
 }
 async function writeWorldFiles(outputDir, world) {
   const { writeFile: writeFile6, mkdir: mkdir3 } = await import("fs/promises");
-  const { join: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join19(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join19(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join19(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join19(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  await writeFile6(join19(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join19(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join19(outputDir, "metadata.json"), JSON.stringify(world.metadata, null, 2));
-  const rulesDir = join19(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(join19(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) {
@@ -3673,9 +3673,9 @@ World source written to: ${derivedPath}
     try {
       const emitResult = emitWorldDefinition(parseResult.world);
       await writeWorldFiles(outputDir, emitResult.world);
-      const { join: join19 } = await import("path");
+      const { join: join21 } = await import("path");
       const { copyFile } = await import("fs/promises");
-      const sourceDest = join19(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: existsSync15 } = await import("fs");
-    if (existsSync15(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: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   await mkdir3(outputDir, { recursive: true });
-  await writeFile6(join19(outputDir, "world.json"), JSON.stringify(world.world, null, 2));
-  await writeFile6(join19(outputDir, "invariants.json"), JSON.stringify({ invariants: world.invariants }, null, 2));
-  await writeFile6(join19(outputDir, "assumptions.json"), JSON.stringify(world.assumptions, null, 2));
-  await writeFile6(join19(outputDir, "state-schema.json"), JSON.stringify(world.stateSchema, null, 2));
-  const rulesDir = join19(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(join19(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(join19(outputDir, "gates.json"), JSON.stringify(world.gates, null, 2));
-  await writeFile6(join19(outputDir, "outcomes.json"), JSON.stringify(world.outcomes, null, 2));
-  await writeFile6(join19(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: join19 } = await import("path");
-  const dir = policiesDir ?? join19(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(join19(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: join19 } = 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(join19(dir, "world.json"), JSON.stringify(worldJson, null, 2)),
-    writeFile6(join19(dir, "kernel.json"), JSON.stringify(kernelJson, null, 2)),
-    writeFile6(join19(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((resolve12, reject) => {
+    return new Promise((resolve14, reject) => {
       const chunks = [];
       req.on("data", (chunk) => chunks.push(chunk));
-      req.on("end", () => resolve12(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: existsSync15 } = await import("fs");
-      const { join: join19 } = await import("path");
-      const hasWorld = existsSync15(join19(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: existsSync15 } = await import("fs");
-    const { join: join19 } = 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 (existsSync15(join19(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((resolve12, 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
 `
       );
-      resolve12();
+      resolve14();
     });
     process.stdin.on("error", reject);
   });
@@ -13310,8 +13310,8 @@ ${response.content}
   rl2.on("close", () => {
     session.stop();
   });
-  return new Promise((resolve12) => {
-    rl2.on("close", resolve12);
+  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: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const snapshotDir = join19(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(join19(worldPath, file), "utf-8");
-      await writeFile6(join19(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 = join19(worldPath, "rules");
+    const rulesDir = join21(worldPath, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join19(snapshotDir, "rules"), { recursive: true });
+    await mkdir3(join21(snapshotDir, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join19(rulesDir, file), "utf-8");
-        await writeFile6(join19(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: join19 } = await import("path");
-  const snapshotsDir = join19(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 = join19(snapshotsDir, latest);
+  const snapshotDir = join21(snapshotsDir, latest);
   const backupTimestamp = "pre-rollback-" + (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join19(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(join19(worldPath, file), "utf-8");
-      await writeFile6(join19(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(join19(snapshotDir, file), "utf-8");
-      await writeFile6(join19(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 = join19(snapshotDir, "rules");
+    const rulesDir = join21(snapshotDir, "rules");
     const ruleFiles = await readdir(rulesDir);
-    await mkdir3(join19(worldPath, "rules"), { recursive: true });
+    await mkdir3(join21(worldPath, "rules"), { recursive: true });
     for (const file of ruleFiles) {
       if (file.endsWith(".json")) {
-        const content = await readFile4(join19(rulesDir, file), "utf-8");
-        await writeFile6(join19(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((resolve12) => {
+  return new Promise((resolve14) => {
     getRL().question(`
   ${question}${suffix}: `, (answer) => {
       const val = answer.trim();
-      resolve12(val || defaultValue || "");
+      resolve14(val || defaultValue || "");
     });
   });
 }
 function confirm(question, defaultYes = true) {
   const hint = defaultYes ? "[Y/n]" : "[y/N]";
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     getRL().question(`
   ${question} ${hint}: `, (answer) => {
       const val = answer.trim().toLowerCase();
-      if (val === "") resolve12(defaultYes);
-      else resolve12(val === "y" || val === "yes");
+      if (val === "") resolve14(defaultYes);
+      else resolve14(val === "y" || val === "yes");
     });
   });
 }
 function choose(question, options) {
-  return new Promise((resolve12) => {
+  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) {
-        resolve12(options[idx]);
+        resolve14(options[idx]);
       } else {
-        resolve12(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: existsSync15 } = await import("fs");
+  const { mkdirSync: mkdirSync7, existsSync: existsSync17 } = await import("fs");
   const { writeFile: writeFile6 } = await import("fs/promises");
-  const { join: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   const files = [];
-  if (!existsSync15(outputDir)) mkdirSync6(outputDir, { recursive: true });
-  const rulesDir = join19(outputDir, "rules");
-  if (!existsSync15(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 = join19(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 = join19(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: join19 } = 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(
-      join19(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(
-          join19(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: join19 } = await import("path");
+  const { join: join21 } = await import("path");
   const possiblePaths = [
-    join19(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 = join19(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, "");
 }
@@ -19151,14 +19160,14 @@ async function askQuestions() {
   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((resolve12) => {
+    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");
-        resolve12(ans.trim());
+        resolve14(ans.trim());
       });
     });
     answers[q.id] = answer;
@@ -19450,6 +19459,46 @@ ${YELLOW2}Validation found ${errors.length} issue${errors.length > 1 ? "s" : ""}
         } 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 {
       }
@@ -20590,7 +20639,7 @@ function sovereignConduitRewrite(pattern) {
   return {
     ...pattern,
     framing: "what this means for the people in the system",
-    emphasis: "humanity + sovereignty + learning",
+    emphasis: "humanity + agency + learning",
     compress: false
   };
 }
@@ -20601,17 +20650,17 @@ var init_sovereign_conduit = __esm({
     SOVEREIGN_CONDUIT_FRAME = {
       domains: [
         "stewardship",
-        "sovereignty",
+        "agency",
         "integration"
       ],
       overlaps: [
         {
-          domains: ["stewardship", "sovereignty"],
+          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: ["sovereignty", "integration"],
+          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."
         },
@@ -20642,7 +20691,7 @@ var init_sovereign_conduit = __esm({
           "harm detection",
           "constraint design"
         ],
-        "sovereignty": [
+        "agency": [
           "independent thinking",
           "decision ownership",
           "self-trust",
@@ -20666,7 +20715,7 @@ var init_sovereign_conduit = __esm({
       output_translation: {
         never_surface_in_output: [
           "Stewardship",
-          "Sovereignty",
+          "Agency",
           "Integration"
         ],
         surface_freely: [
@@ -20681,7 +20730,7 @@ var init_sovereign_conduit = __esm({
             external_expression: "the boundaries are clear and the system feels safe to operate inside"
           },
           {
-            internal_reasoning: "Sovereignty is weakening",
+            internal_reasoning: "Agency is weakening",
             external_expression: "decision ownership is quietly shifting \u2014 the human is accepting AI output without engaging with it"
           },
           {
@@ -20764,12 +20813,12 @@ var init_sovereign_conduit = __esm({
       close_with_strategic_frame: "preferred",
       punchline_move: "sparing",
       honesty_about_failure: "required",
-      output_translation: `Reason internally through the three-domain frame (Stewardship, Sovereignty, Integration). Express externally through the skills inside each domain and the overlap feelings (Trust, Possibility, Responsibility). Do NOT surface the bucket names as labels. Readers understand "the boundaries feel safe" not "Stewardship is strong." Use everyday analogies \u2014 mom rules, friend's house rules, idea calculator. Name the emotion before the mechanism.`
+      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",
-      "sovereignty is",
+      "agency is",
       "integration is",
       // AI-assistant hedging
       "it may be beneficial to consider",
@@ -20805,7 +20854,7 @@ var init_sovereign_conduit = __esm({
       "Here's what's actually happening: [plain explanation].",
       "The question to ask yourself: [question].",
       "The difference between [A] and [B] matters here: [why].",
-      // Sovereignty checks
+      // 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.",
@@ -20816,7 +20865,7 @@ var init_sovereign_conduit = __esm({
     ]);
     SOVEREIGN_CONDUIT_STRATEGIC = Object.freeze([
       "Safety before expansion \u2014 always. No exception.",
-      "Sovereignty before convenience \u2014 the right to think for yourself is not a feature to optimize away.",
+      "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.",
@@ -20826,16 +20875,16 @@ var init_sovereign_conduit = __esm({
     ]);
     SOVEREIGN_CONDUIT_EXEMPLARS = Object.freeze([
       {
-        path: "neuroverseos-sovereign-conduit.worldmodel.md",
+        path: "src/radiant/examples/neuroverse-base/neuroverseos-sovereign-conduit.worldmodel.md",
         title: "The Sovereign Conduit Worldmodel",
-        exhibits: ["stewardship", "sovereignty", "integration"],
+        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), Sovereignty (authority over thinking), and Integration (AI as cognitive extension). Uses everyday analogies \u2014 mom rules, friend's house, idea calculator. Names emotions before mechanisms. If a non-technical person can't understand the output, the voice is wrong. Humanity first. In constant learning. In shared teaching.",
+      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,
@@ -21783,82 +21832,382 @@ var init_notion = __esm({
   }
 });
 
+// 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 {
+      raw: trimmed,
+      kind: "github",
+      owner: match[1],
+      repo: match[2],
+      ref: match[3] ?? "HEAD",
+      subpath: match[4] ?? ""
+    };
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || (0, import_path15.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  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 {
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
+  };
+}
+function resolveAllExtends(repoDir, options) {
+  const config = options?.config !== void 0 ? options.config : loadExtendsConfig(repoDir);
+  if (!config?.extends || config.extends.length === 0) return [];
+  const results = [];
+  for (const raw of config.extends) {
+    const spec = parseExtendsSpec(raw);
+    if (!spec) {
+      results.push({
+        spec: { raw, kind: "local" },
+        dir: null,
+        warning: `unparseable extends spec: ${raw}`
+      });
+      continue;
+    }
+    results.push(resolveExtendsSpec(spec, repoDir, options));
+  }
+  return results;
+}
+var import_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 userDir = options?.userWorldsDir ?? (0, import_path14.join)((0, import_os5.homedir)(), ".neuroverse", "worlds");
-  if ((0, import_fs13.existsSync)(userDir)) {
+  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"
+        });
+      }
+    }
+    const baseDir = options?.repoDir ?? process.cwd();
+    for (const spec of specs) {
+      const result = resolveExtendsSpec(spec, baseDir, {
+        cacheDir: options?.extendsCacheDir,
+        fetcher: options?.extendsFetcher,
+        ttlMs: options?.extendsTtlMs,
+        forceRefresh,
+        noFetch,
+        silentOnMissing: true
+      });
+      worlds.push(...loadExtendsWorlds(result, "org"));
+    }
+  }
+  if (options?.repoDir && !options.disableExtends && !options.explicitWorldsDir) {
+    const results = resolveAllExtends(options.repoDir, {
+      cacheDir: options.extendsCacheDir,
+      fetcher: options.extendsFetcher,
+      ttlMs: options.extendsTtlMs,
+      forceRefresh,
+      noFetch
+    });
+    for (const result of results) {
+      worlds.push(...loadExtendsWorlds(result, "extends"));
+      if (result.warning) warnings.push(result.warning);
+    }
+  }
   if (options?.explicitWorldsDir) {
     worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
   } else if (options?.repoDir) {
     const repoPaths = [
-      (0, import_path14.join)(options.repoDir, "worlds"),
-      (0, import_path14.join)(options.repoDir, ".neuroverse", "worlds")
+      (0, import_path16.join)(options.repoDir, "worlds"),
+      (0, import_path16.join)(options.repoDir, ".neuroverse", "worlds")
     ];
     for (const p of repoPaths) {
-      if ((0, import_fs13.existsSync)(p)) {
+      if ((0, import_fs15.existsSync)(p)) {
         worlds.push(...loadWorldsFromDir(p, "repo"));
         break;
       }
     }
   }
-  const combinedContent = worlds.map((w) => `<!-- world: ${w.name} (${w.source}) -->
-${w.content}`).join("\n\n---\n\n");
+  const 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 };
+  return { worlds, combinedContent, summary: summary2, warnings };
+}
+function formatActiveWorlds(stack) {
+  if (stack.worlds.length === 0) return "No worlds loaded.";
+  const lines = ["ACTIVE WORLDS", ""];
+  for (const w of stack.worlds) {
+    const sourceLabel = w.source === "base" ? "universal" : w.source === "user" ? "personal" : w.source === "org" ? `org (${w.extendsFrom ?? "auto"})` : w.source === "extends" ? `shared (${w.extendsFrom ?? "extends"})` : "this repo";
+    lines.push(`  ${w.name} (${sourceLabel})`);
+  }
+  if (stack.warnings.length > 0) {
+    lines.push("", "WARNINGS");
+    for (const w of stack.warnings) lines.push(`  ${w}`);
+  }
+  return lines.join("\n");
+}
+function loadExtendsWorlds(result, source) {
+  if (!result.dir) return [];
+  const loaded = loadWorldsFromDir(result.dir, source);
+  return loaded.map((w) => ({ ...w, extendsFrom: result.spec.raw }));
 }
 function loadWorldsFromDir(dirPath, source) {
-  const dir = (0, import_path14.resolve)(dirPath);
-  if (!(0, import_fs13.existsSync)(dir)) return [];
-  const stat = (0, import_fs13.statSync)(dir);
+  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 {
       return [{
-        name: (0, import_path14.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        name: (0, import_path16.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
         source,
         path: dir,
-        content: (0, import_fs13.readFileSync)(dir, "utf-8")
+        content: (0, import_fs15.readFileSync)(dir, "utf-8")
       }];
     } catch {
       return [];
     }
   }
   if (!stat.isDirectory()) return [];
-  const files = (0, import_fs13.readdirSync)(dir).filter(
+  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_path14.join)(dir, 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_fs13.readFileSync)(fullPath, "utf-8")
+      content: (0, import_fs15.readFileSync)(fullPath, "utf-8")
     };
   });
 }
-var import_fs13, import_path14, import_os5;
+var import_fs15, import_path16, import_os6;
 var init_discovery = __esm({
   "src/radiant/core/discovery.ts"() {
     "use strict";
-    import_fs13 = require("fs");
-    import_path14 = require("path");
-    import_os5 = require("os");
+    import_fs15 = require("fs");
+    import_path16 = require("path");
+    import_os6 = require("os");
+    init_extends();
   }
 });
 
 // src/radiant/adapters/exocortex.ts
 function readExocortex(dirPath, repoName) {
-  const dir = (0, import_path15.resolve)(dirPath);
+  const dir = (0, import_path17.resolve)(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = (0, import_path15.join)(dir, p);
-      if ((0, import_fs14.existsSync)(full)) {
+      const full = (0, import_path17.join)(dir, p);
+      if ((0, import_fs16.existsSync)(full)) {
         try {
-          const content = (0, import_fs14.readFileSync)(full, "utf-8").trim();
+          const content = (0, import_fs16.readFileSync)(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -21940,33 +22289,33 @@ function summarizeExocortex(ctx) {
   if (ctx.methods) loaded.push("methods");
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
-var import_fs14, import_path15;
+var import_fs16, import_path17;
 var init_exocortex = __esm({
   "src/radiant/adapters/exocortex.ts"() {
     "use strict";
-    import_fs14 = require("fs");
-    import_path15 = require("path");
+    import_fs16 = require("fs");
+    import_path17 = require("path");
   }
 });
 
 // src/radiant/memory/palace.ts
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = (0, import_path16.resolve)(exocortexDir, "radiant", "reads");
-  (0, import_fs15.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_path16.join)(dir, filename);
+  const filepath = (0, import_path18.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs15.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs17.writeFileSync)(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = (0, import_path16.resolve)(exocortexDir, "radiant");
-  (0, import_fs15.mkdirSync)(dir, { recursive: true });
-  const filepath = (0, import_path16.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 = [
@@ -22053,14 +22402,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs15.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_fs15.existsSync)(filepath)) return counts;
+  if (!(0, import_fs17.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs15.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs17.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -22078,13 +22427,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = (0, import_path16.resolve)(exocortexDir, "radiant", "reads");
-  if (!(0, import_fs15.existsSync)(dir)) return [];
-  const files = (0, import_fs15.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_path16.join)(dir, filename);
-    const content = (0, import_fs15.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] : "";
@@ -22118,12 +22467,12 @@ function computePersistence(priorReads, currentPatternNames) {
     dates: dates.sort()
   })).sort((a, b) => b.occurrences - a.occurrences);
 }
-var import_fs15, import_path16;
+var import_fs17, import_path18;
 var init_palace = __esm({
   "src/radiant/memory/palace.ts"() {
     "use strict";
-    import_fs15 = require("fs");
-    import_path16 = require("path");
+    import_fs17 = require("fs");
+    import_path18 = require("path");
   }
 });
 
@@ -23164,22 +23513,22 @@ __export(server_exports, {
   startRadiantMcp: () => startRadiantMcp
 });
 function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path17.resolve)(worldsPath);
-  if (!(0, import_fs16.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_fs16.statSync)(resolved);
+  const stat = (0, import_fs18.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs16.readFileSync)(resolved, "utf-8");
+    return (0, import_fs18.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs16.readdirSync)(resolved).filter(
-      (f) => (0, import_path17.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_fs16.readFileSync)((0, import_path17.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}`);
 }
@@ -23198,12 +23547,12 @@ async function startRadiantMcp(args) {
   const server = new RadiantMcpServer({ worldsPath, lensId, model });
   await server.start();
 }
-var import_fs16, import_path17, TOOLS, RadiantMcpServer;
+var import_fs18, import_path19, TOOLS, RadiantMcpServer;
 var init_server = __esm({
   "src/radiant/mcp/server.ts"() {
     "use strict";
-    import_fs16 = require("fs");
-    import_path17 = require("path");
+    import_fs18 = require("fs");
+    import_path19 = require("path");
     init_think();
     init_emergent();
     init_ai();
@@ -23492,17 +23841,17 @@ function parseArgs27(argv) {
   return result;
 }
 function loadWorldmodelContent2(worldsPath) {
-  const resolved = (0, import_path18.resolve)(worldsPath);
-  if (!(0, import_fs17.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_fs17.statSync)(resolved);
+  const stat = (0, import_fs19.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs17.readFileSync)(resolved, "utf-8");
+    return (0, import_fs19.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs17.readdirSync)(resolved).filter(
-      (f) => (0, import_path18.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(
@@ -23510,27 +23859,55 @@ function loadWorldmodelContent2(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs17.readFileSync)((0, import_path18.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);
@@ -23549,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_fs17.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs19.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -23559,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}
 
 `
@@ -23623,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);
@@ -23652,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";
@@ -23826,18 +24199,19 @@ async function main34(argv) {
       process.exit(1);
   }
 }
-var import_fs17, import_path18, 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_fs17 = require("fs");
-    import_path18 = 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";
@@ -23863,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)