@neuroverseos/governance 0.8.1 → 0.10.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: mkdirSync8 } = await import("fs");
+  mkdirSync8(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: mkdirSync8, 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)) mkdirSync8(outputDir, { recursive: true });
+  const rulesDir = join21(outputDir, "rules");
+  if (!existsSync17(rulesDir)) mkdirSync8(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"
         );
@@ -17155,7 +17155,7 @@ function previewLens(lens) {
   const DIM4 = "\x1B[2m";
   const CYAN3 = "\x1B[36m";
   const YELLOW4 = "\x1B[33m";
-  const GREEN3 = "\x1B[32m";
+  const GREEN4 = "\x1B[32m";
   const RESET4 = "\x1B[0m";
   const lines = [];
   lines.push("");
@@ -17166,7 +17166,7 @@ function previewLens(lens) {
     if (d.example) {
       lines.push(`  ${BOLD4}${d.id}${RESET4}`);
       lines.push(`  ${YELLOW4}Without:${RESET4} ${DIM4}${d.example.without}${RESET4}`);
-      lines.push(`  ${GREEN3}With:${RESET4}    ${d.example.with}`);
+      lines.push(`  ${GREEN4}With:${RESET4}    ${d.example.with}`);
       lines.push("");
     }
   }
@@ -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,638 @@ var init_notion = __esm({
   }
 });
 
+// src/radiant/adapters/linear.ts
+async function fetchLinearActivity(apiKey, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const maxIssues = options.maxIssues ?? 200;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const sinceIso = since.toISOString();
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const teamFilter = options.teamIds && options.teamIds.length > 0 ? `team: { id: { in: [${options.teamIds.map((t) => JSON.stringify(t)).join(", ")}] } }` : "";
+  const issuesQuery = `
+    query RadiantIssues($since: DateTimeOrDuration!, $first: Int!) {
+      issues(
+        filter: {
+          updatedAt: { gte: $since }
+          ${teamFilter}
+        }
+        first: $first
+        orderBy: updatedAt
+      ) {
+        nodes {
+          id
+          identifier
+          title
+          url
+          createdAt
+          updatedAt
+          completedAt
+          canceledAt
+          state { name type }
+          assignee { id name email }
+          creator { id name }
+          team { id name }
+          project { id name }
+          cycle { id number startsAt endsAt }
+          comments(first: 20) {
+            nodes { id body createdAt user { id name } }
+          }
+        }
+      }
+    }
+  `;
+  const cyclesQuery = `
+    query RadiantCycles($since: DateTimeOrDuration!, $now: DateTimeOrDuration!) {
+      cycles(
+        filter: { endsAt: { gte: $since, lte: $now } }
+        first: 20
+      ) {
+        nodes {
+          id
+          number
+          startsAt
+          endsAt
+          issueCountHistory
+          completedIssueCountHistory
+          team { id name }
+        }
+      }
+    }
+  `;
+  const [issuesResponse, cyclesResponse] = await Promise.all([
+    fetchLinearGraphQL(apiKey, issuesQuery, {
+      since: sinceIso,
+      first: maxIssues
+    }),
+    fetchLinearGraphQL(apiKey, cyclesQuery, {
+      since: sinceIso,
+      now: nowIso
+    })
+  ]);
+  const rawIssues = issuesResponse.issues?.nodes ?? [];
+  const rawCycles = cyclesResponse.cycles?.nodes ?? [];
+  const events = [];
+  const assignees = /* @__PURE__ */ new Set();
+  const projects = /* @__PURE__ */ new Map();
+  let issuesCreated = 0;
+  let issuesCompleted = 0;
+  let issuesOpen = 0;
+  let issuesStalled = 0;
+  let commentsTotal = 0;
+  const now = Date.now();
+  const stallThresholdMs = 14 * 24 * 60 * 60 * 1e3;
+  for (const issue of rawIssues) {
+    const created = new Date(issue.createdAt);
+    const updated = new Date(issue.updatedAt);
+    const completed = issue.completedAt ? new Date(issue.completedAt) : null;
+    const assigneeId = issue.assignee?.id ?? "unassigned";
+    if (assigneeId !== "unassigned") assignees.add(assigneeId);
+    if (issue.project) {
+      projects.set(issue.project.name, (projects.get(issue.project.name) ?? 0) + 1);
+    }
+    const actor = {
+      id: assigneeId,
+      kind: "human",
+      name: issue.assignee?.name ?? "unassigned"
+    };
+    if (created >= since) {
+      issuesCreated++;
+      events.push({
+        id: `linear-created-${issue.id}`,
+        timestamp: issue.createdAt,
+        actor: {
+          id: issue.creator?.id ?? "unknown",
+          kind: "human",
+          name: issue.creator?.name ?? "unknown"
+        },
+        kind: "issue_created",
+        content: `[${issue.identifier}] ${issue.title}`,
+        metadata: {
+          issueId: issue.id,
+          url: issue.url,
+          team: issue.team?.name,
+          project: issue.project?.name,
+          state: issue.state?.name
+        }
+      });
+    }
+    if (completed && completed >= since) {
+      issuesCompleted++;
+      events.push({
+        id: `linear-completed-${issue.id}`,
+        timestamp: issue.completedAt,
+        actor,
+        kind: "issue_completed",
+        content: `[${issue.identifier}] ${issue.title}`,
+        metadata: {
+          issueId: issue.id,
+          url: issue.url,
+          team: issue.team?.name,
+          project: issue.project?.name,
+          cycleDays: issue.cycle?.startsAt && issue.completedAt ? Math.round(
+            (new Date(issue.completedAt).getTime() - new Date(issue.cycle.startsAt).getTime()) / (24 * 60 * 60 * 1e3)
+          ) : null
+        }
+      });
+    }
+    if (!completed && !issue.canceledAt) {
+      issuesOpen++;
+      const isInProgress = issue.state?.type === "started";
+      const idleMs = now - updated.getTime();
+      if (isInProgress && idleMs > stallThresholdMs) issuesStalled++;
+    }
+    for (const comment of issue.comments?.nodes ?? []) {
+      const commentedAt = new Date(comment.createdAt);
+      if (commentedAt < since) continue;
+      commentsTotal++;
+      events.push({
+        id: `linear-comment-${comment.id}`,
+        timestamp: comment.createdAt,
+        actor: {
+          id: comment.user?.id ?? "unknown",
+          kind: "human",
+          name: comment.user?.name ?? "unknown"
+        },
+        kind: "issue_comment",
+        content: comment.body.slice(0, 280),
+        metadata: {
+          issueId: issue.id,
+          issueIdentifier: issue.identifier,
+          url: issue.url
+        }
+      });
+    }
+  }
+  let cycleCompletionRate = null;
+  if (rawCycles.length > 0) {
+    const rates = [];
+    for (const cycle of rawCycles) {
+      const committed = cycle.issueCountHistory?.at(0) ?? 0;
+      const completed = cycle.completedIssueCountHistory?.at(-1) ?? 0;
+      if (committed > 0) rates.push(completed / committed);
+    }
+    if (rates.length > 0) {
+      cycleCompletionRate = Math.round(rates.reduce((a, b) => a + b, 0) / rates.length * 100) / 100;
+    }
+  }
+  const topProjects = [...projects.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name]) => name);
+  const signals = {
+    issuesCreated,
+    issuesCompleted,
+    issuesOpen,
+    issuesStalled,
+    cycleCompletionRate,
+    uniqueAssignees: assignees.size,
+    commentsTotal,
+    topProjects
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatLinearSignalsForPrompt(signals) {
+  if (signals.issuesCreated === 0 && signals.issuesCompleted === 0 && signals.issuesOpen === 0) {
+    return "";
+  }
+  const lines = [
+    "## Linear Activity (planned work vs. shipped outcome)",
+    "",
+    `${signals.issuesCreated} issues created, ${signals.issuesCompleted} completed in window.`,
+    `${signals.issuesOpen} issues still open.`
+  ];
+  if (signals.issuesStalled > 0) {
+    lines.push(
+      `${signals.issuesStalled} in-progress issues haven't moved in 14+ days (stalled).`
+    );
+  }
+  if (signals.cycleCompletionRate !== null) {
+    const pct = Math.round(signals.cycleCompletionRate * 100);
+    lines.push(`Cycles ended in window completed ${pct}% of what was committed.`);
+  }
+  if (signals.uniqueAssignees > 0) {
+    lines.push(`${signals.uniqueAssignees} unique assignees active.`);
+  }
+  if (signals.commentsTotal > 0) {
+    lines.push(`${signals.commentsTotal} comments across issues in window.`);
+  }
+  if (signals.topProjects.length > 0) {
+    lines.push(`Most active projects: ${signals.topProjects.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Linear is where the team states what it will build.");
+  lines.push("GitHub is where the team reveals what actually got built.");
+  lines.push("Low completion rate + high creation rate = planning faster than shipping.");
+  lines.push("High stalled count = commitments made but not honored.");
+  lines.push("Compare Linear signals against GitHub to find the stated-vs-shipped gap.");
+  return lines.join("\n");
+}
+async function fetchLinearGraphQL(apiKey, query, variables) {
+  const res = await fetch("https://api.linear.app/graphql", {
+    method: "POST",
+    headers: {
+      // Linear accepts the raw API key in Authorization with no "Bearer" prefix.
+      Authorization: apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Linear API error ${res.status}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  const json = await res.json();
+  if (json.errors && json.errors.length > 0) {
+    throw new Error(
+      `Linear GraphQL errors: ${json.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (!json.data) {
+    throw new Error("Linear API returned no data");
+  }
+  return json.data;
+}
+var init_linear = __esm({
+  "src/radiant/adapters/linear.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 {
+      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 +22545,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 +22658,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 +22683,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 +22723,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");
   }
 });
 
@@ -22412,6 +23017,144 @@ var init_signals = __esm({
   }
 });
 
+// src/radiant/core/vocabulary.ts
+function extractDeclaredVocabulary(worldmodelContent) {
+  const aligned = extractSection(worldmodelContent, "Aligned Behaviors").map(
+    (b) => parseBehavior(b, "aligned")
+  );
+  const drift = extractSection(worldmodelContent, "Drift Behaviors").map(
+    (b) => parseBehavior(b, "drift")
+  );
+  const allNames = [...aligned, ...drift].map((p) => p.name);
+  return { aligned, drift, allNames };
+}
+function extractSection(content, header) {
+  const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`,
+    "i"
+  );
+  const match = content.match(pattern);
+  if (!match) return [];
+  const body = match[1];
+  const bullets = body.match(/^[-*]\s+.+$/gm);
+  if (!bullets) return [];
+  return bullets.map((b) => b.replace(/^[-*]\s+/, "").trim()).filter((b) => b.length > 0 && !b.startsWith("<!--"));
+}
+function parseBehavior(bullet, kind) {
+  const explicit = bullet.match(
+    /^`?([a-z][a-z0-9_]*)`?\s+[—\u2014-]\s+(.+)$/i
+  );
+  if (explicit && isSnakeCase(explicit[1])) {
+    return {
+      name: explicit[1].toLowerCase(),
+      prose: explicit[2].trim(),
+      kind
+    };
+  }
+  return { name: snakeCaseName(bullet), prose: bullet, kind };
+}
+function isSnakeCase(s) {
+  return /^[a-z][a-z0-9_]*$/.test(s);
+}
+function snakeCaseName(s) {
+  const base = s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (base.length <= 60) return base;
+  const truncated = base.slice(0, 60);
+  const lastUnderscore = truncated.lastIndexOf("_");
+  return lastUnderscore > 20 ? truncated.slice(0, lastUnderscore) : truncated;
+}
+function matchDeclaredPattern(candidateName, candidateDescription, vocabulary) {
+  const candidateText = `${candidateName.replace(/_/g, " ")} ${candidateDescription}`;
+  const candidateWords = contentWords(candidateText);
+  if (candidateWords.size === 0) return null;
+  let best = null;
+  for (const pattern of [...vocabulary.aligned, ...vocabulary.drift]) {
+    const proseWords = contentWords(pattern.prose);
+    if (proseWords.size === 0) continue;
+    let shared = 0;
+    for (const w of proseWords) {
+      if (candidateWords.has(w)) shared++;
+    }
+    const coverage = shared / proseWords.size;
+    if (shared >= 2 && coverage >= 0.3) {
+      if (!best || coverage > best.score) {
+        best = { pattern, score: coverage };
+      }
+    }
+  }
+  return best?.pattern ?? null;
+}
+function contentWords(text) {
+  const words = text.toLowerCase().match(/[a-z][a-z0-9_]+/g) ?? [];
+  return new Set(words.filter((w) => w.length > 3 && !STOPWORDS.has(w)));
+}
+var STOPWORDS;
+var init_vocabulary = __esm({
+  "src/radiant/core/vocabulary.ts"() {
+    "use strict";
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "about",
+      "after",
+      "against",
+      "among",
+      "around",
+      "because",
+      "been",
+      "before",
+      "being",
+      "between",
+      "both",
+      "could",
+      "does",
+      "doing",
+      "during",
+      "each",
+      "from",
+      "further",
+      "have",
+      "having",
+      "into",
+      "itself",
+      "most",
+      "nor",
+      "only",
+      "other",
+      "over",
+      "same",
+      "should",
+      "some",
+      "such",
+      "than",
+      "that",
+      "their",
+      "them",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "those",
+      "through",
+      "under",
+      "until",
+      "very",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "will",
+      "with",
+      "without",
+      "would",
+      "your",
+      "yours"
+    ]);
+  }
+});
+
 // src/radiant/types.ts
 function isScored(s) {
   return typeof s === "number";
@@ -22463,7 +23206,11 @@ var init_math = __esm({
 async function interpretPatterns(input) {
   const prompt = buildInterpretationPrompt(input);
   const raw = await input.ai.complete(prompt, "Analyze the activity and produce the read.");
-  const parsed = parseInterpretation(raw, input.canonicalPatterns ?? []);
+  const canonicalNames = [
+    ...input.canonicalPatterns ?? [],
+    ...input.declaredVocabulary?.allNames ?? []
+  ];
+  const parsed = parseInterpretation(raw, canonicalNames, input.declaredVocabulary);
   return {
     patterns: parsed.patterns,
     meaning: parsed.meaning,
@@ -22474,8 +23221,10 @@ async function interpretPatterns(input) {
 function buildInterpretationPrompt(input) {
   const signalSummary = formatSignalSummary(input.signals);
   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 canonicalList = formatDeclaredVocabulary(
+    input.declaredVocabulary,
+    input.canonicalPatterns ?? []
+  );
   const compressedWorld = compressWorldmodel(input.worldmodelContent);
   const cl = compressLens(input.lens);
   const frame = input.lens.primary_frame;
@@ -22586,6 +23335,44 @@ Only recommend a move when the evidence actually calls for one.
 Do NOT use these phrases anywhere in your output:
 ${forbiddenList}`;
 }
+function formatDeclaredVocabulary(vocabulary, extraNames) {
+  const aligned = vocabulary?.aligned ?? [];
+  const drift = vocabulary?.drift ?? [];
+  if (aligned.length === 0 && drift.length === 0 && extraNames.length === 0) {
+    return 'No patterns have been named yet. Everything you observe is new \u2014 mark it type: "candidate".';
+  }
+  const parts = [];
+  parts.push("## Declared vocabulary (use these names when you see matching evidence)");
+  parts.push("");
+  parts.push(
+    'The worldmodel declares the patterns below. If your observation matches one of these, use the EXACT snake_case name shown and mark type: "canonical" \u2014 do not invent a new name for something that already has one.'
+  );
+  parts.push("");
+  if (aligned.length > 0) {
+    parts.push("### Aligned behaviors (positive patterns)");
+    for (const p of aligned) {
+      parts.push(`- \`${p.name}\` \u2014 ${p.prose}`);
+    }
+    parts.push("");
+  }
+  if (drift.length > 0) {
+    parts.push("### Drift behaviors (negative patterns)");
+    for (const p of drift) {
+      parts.push(`- \`${p.name}\` \u2014 ${p.prose}`);
+    }
+    parts.push("");
+  }
+  if (extraNames.length > 0) {
+    parts.push(
+      `Additional canonical names (from prior runs or caller): ${extraNames.join(", ")}`
+    );
+    parts.push("");
+  }
+  parts.push(
+    'If you observe something genuinely new that matches NO declared pattern, mark it type: "candidate" with a freshly-invented snake_case name.'
+  );
+  return parts.join("\n");
+}
 function formatSignalSummary(signals) {
   const lines = [];
   const domains = ["life", "cyber", "joint"];
@@ -22611,7 +23398,7 @@ function formatEventSample(events, maxEvents) {
   "${content}"`;
   }).join("\n");
 }
-function parseInterpretation(raw, canonicalNames) {
+function parseInterpretation(raw, canonicalNames, vocabulary) {
   let meaning = "";
   let move = "";
   let patternsArray = [];
@@ -22641,14 +23428,23 @@ function parseInterpretation(raw, canonicalNames) {
   const patterns = [];
   for (const item of patternsArray) {
     if (!isPatternLike(item)) continue;
-    const nameStr = String(item.name ?? "unnamed");
+    const rawName = String(item.name ?? "unnamed");
+    const description = String(item.description ?? "");
     const ev = item.evidence;
-    const isCanonical = item.type === "canonical" || canonicalSet.has(nameStr.toLowerCase());
+    let name = rawName;
+    let isCanonical = item.type === "canonical" || canonicalSet.has(rawName.toLowerCase());
+    if (!isCanonical && vocabulary) {
+      const matched = matchDeclaredPattern(rawName, description, vocabulary);
+      if (matched) {
+        name = matched.name;
+        isCanonical = true;
+      }
+    }
     patterns.push({
-      name: nameStr,
+      name,
       type: isCanonical ? "canonical" : "candidate",
-      declaredAs: isCanonical ? nameStr : void 0,
-      description: String(item.description ?? ""),
+      declaredAs: isCanonical ? name : void 0,
+      description,
       evidence: {
         signals: Array.isArray(ev?.signals) ? ev.signals.map(String) : [],
         events: Array.isArray(ev?.events) ? ev.events.map(String) : [],
@@ -22666,6 +23462,7 @@ var init_patterns = __esm({
   "src/radiant/core/patterns.ts"() {
     "use strict";
     init_compress();
+    init_vocabulary();
   }
 });
 
@@ -22984,10 +23781,24 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     } catch {
     }
   }
+  const linearKey = process.env.LINEAR_API_KEY;
+  if (linearKey) {
+    try {
+      const linear = await fetchLinearActivity(linearKey, { windowDays });
+      events.push(...linear.events);
+      adapterSignals += "\n\n" + formatLinearSignalsForPrompt(linear.signals);
+      activeAdapters.push("linear");
+    } catch {
+    }
+  }
   events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  if (input.personalUser) {
+    events = filterEventsByUser(events, input.personalUser);
+  }
   const classified = classifyEvents(events);
   const signals = extractSignals(classified);
   const scores = computeScores(signals, input.worldmodelContent !== "");
+  const declaredVocabulary = extractDeclaredVocabulary(worldmodelContent);
   const { patterns, meaning, move } = await interpretPatterns({
     signals,
     events: classified,
@@ -22995,6 +23806,7 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
+    declaredVocabulary,
     statedIntent: [statedIntent, adapterSignals, priorReadContext].filter(Boolean).join("\n\n") || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
@@ -23049,6 +23861,10 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     worldStack
   };
 }
+function filterEventsByUser(events, username) {
+  const target = username.toLowerCase();
+  return events.filter((e) => e.actor.id.toLowerCase() === target);
+}
 function computeScores(signals, worldmodelLoaded) {
   const gate = DEFAULT_EVIDENCE_GATE;
   const lifeSignals = signals.filter((s) => s.domain === "life");
@@ -23104,12 +23920,14 @@ var init_emergent = __esm({
     init_discord();
     init_slack();
     init_notion();
+    init_linear();
     init_discovery();
     init_exocortex();
     init_palace();
     init_compress();
     init_governance();
     init_signals();
+    init_vocabulary();
     init_math();
     init_patterns();
     init_renderer();
@@ -23164,22 +23982,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 +24016,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();
@@ -23431,7 +24249,9 @@ var init_server = __esm({
 // src/cli/radiant.ts
 var radiant_exports = {};
 __export(radiant_exports, {
-  main: () => main34
+  checkScopeConsent: () => checkScopeConsent,
+  main: () => main34,
+  parseArgs: () => parseArgs27
 });
 function parseArgs27(argv) {
   const result = {
@@ -23443,8 +24263,12 @@ function parseArgs27(argv) {
     exocortex: void 0,
     teamExocortex: void 0,
     view: void 0,
+    user: void 0,
+    personal: false,
+    entireOrg: false,
     json: false,
     help: false,
+    force: false,
     rest: []
   };
   let i = 0;
@@ -23476,9 +24300,22 @@ function parseArgs27(argv) {
       case "--view":
         result.view = argv[++i];
         break;
+      case "--user":
+        result.user = argv[++i];
+        break;
+      case "--personal":
+        result.personal = true;
+        break;
+      case "--entire-org":
+        result.entireOrg = true;
+        break;
       case "--json":
         result.json = true;
         break;
+      case "--force":
+      case "-f":
+        result.force = true;
+        break;
       case "--help":
       case "-h":
         result.help = true;
@@ -23492,17 +24329,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 +24347,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 +24414,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 +24424,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}
 
 `
@@ -23608,6 +24473,15 @@ ${DIM3}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
     process.exit(2);
   }
 }
+function checkScopeConsent(input) {
+  if (input.personal && !input.resolvedUser) {
+    return { ok: false, reason: "personal_requires_user" };
+  }
+  if (input.scope.type === "org" && !input.entireOrg && !input.personal) {
+    return { ok: false, reason: "org_requires_opt_in" };
+  }
+  return { ok: true };
+}
 async function cmdEmergent(args) {
   const scopeStr = args.rest[0];
   if (!scopeStr) {
@@ -23618,19 +24492,48 @@ async function cmdEmergent(args) {
     process.exit(1);
   }
   const scope = parseScope(scopeStr);
+  const personalUser = args.user ?? process.env.RADIANT_USER;
+  const consent = checkScopeConsent({
+    scope,
+    personal: args.personal,
+    entireOrg: args.entireOrg,
+    resolvedUser: personalUser
+  });
+  if (!consent.ok) {
+    if (consent.reason === "personal_requires_user") {
+      process.stderr.write(
+        `${RED2}Error:${RESET3} --personal requires a GitHub username.
+${DIM3}Pass --user <login> or set RADIANT_USER. Radiant will read
+only that user's activity \u2014 no one else is observed.${RESET3}
+`
+      );
+    } else {
+      process.stderr.write(
+        `${YELLOW3}\u26A0${RESET3}  ${BOLD3}"${scope.owner}" is an org-wide scope.${RESET3}
+
+${DIM3}This reads activity across ALL repos in the org \u2014 a global-observer
+pattern that some teams consider offside with decentralization and
+cognitive-liberty principles. It's opt-in for that reason.${RESET3}
+
+Three ways forward:
+  ${GREEN3}1.${RESET3} Scope to a single repo (recommended default):
+       radiant emergent ${scope.owner}/<repo>
+
+  ${GREEN3}2.${RESET3} Read only your own activity (personal mode):
+       radiant emergent ${scope.owner}/ --personal --user <your-login>
+
+  ${GREEN3}3.${RESET3} Explicitly opt in to org-wide observation:
+       radiant emergent ${scope.owner}/ --entire-org
+`
+      );
+    }
+    process.exit(1);
+  }
   const lensId = args.lens ?? process.env.RADIANT_LENS;
   if (!lensId) {
     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 +24555,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";
@@ -23670,8 +24577,11 @@ ${DIM3}Set it to a GitHub PAT with repo read access.${RESET3}
     const ctx = readExocortex(exocortexPath);
     exocortexStatus = summarizeExocortex(ctx);
   }
+  const scopeLabel = scope.type === "org" ? scope.owner + " (entire org)" : scope.owner + "/" + scope.repo;
+  const modeLabel = args.personal ? `personal \u2014 only ${personalUser}'s activity` : "team \u2014 all contributors";
   process.stderr.write(
-    `${DIM3}Scope:      ${scope.type === "org" ? scope.owner + " (entire org)" : scope.owner + "/" + scope.repo}${RESET3}
+    `${DIM3}Scope:      ${scopeLabel}${RESET3}
+${DIM3}Mode:       ${modeLabel}${RESET3}
 ${DIM3}View:       ${view}${RESET3}
 ${DIM3}Lens:       ${lensId}${RESET3}
 ${DIM3}Model:      ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET3}
@@ -23687,7 +24597,8 @@ ${DIM3}Fetching activity...${RESET3}
     lensId,
     ai,
     windowDays: 14,
-    exocortexPath: exocortexPath || void 0
+    exocortexPath: exocortexPath || void 0,
+    personalUser: args.personal ? personalUser : void 0
   });
   if (!result.voiceClean) {
     process.stderr.write(
@@ -23789,6 +24700,43 @@ ${DIM3}Use: lenses list | lenses describe <id>${RESET3}
   );
   process.exit(1);
 }
+async function cmdInit2(args) {
+  const targetDir = (0, import_path20.resolve)(args.rest[0] ?? "./mind-palace");
+  const existed = (0, import_fs19.existsSync)(targetDir);
+  if (existed && !args.force) {
+    const entries = (0, import_fs19.readdirSync)(targetDir);
+    if (entries.length > 0) {
+      process.stderr.write(
+        `${RED2}Error:${RESET3} ${targetDir} already exists and is not empty.
+${DIM3}Use --force to write into it anyway (existing files will be overwritten).${RESET3}
+`
+      );
+      process.exit(1);
+    }
+  }
+  (0, import_fs19.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs19.mkdirSync)((0, import_path20.join)(targetDir, "reads"), { recursive: true });
+  (0, import_fs19.mkdirSync)((0, import_path20.join)(targetDir, "worldmodels"), { recursive: true });
+  for (const [relPath, content] of Object.entries(MIND_PALACE_FILES)) {
+    const fullPath = (0, import_path20.join)(targetDir, relPath);
+    (0, import_fs19.mkdirSync)((0, import_path20.resolve)(fullPath, ".."), { recursive: true });
+    (0, import_fs19.writeFileSync)(fullPath, content, "utf-8");
+  }
+  process.stdout.write(
+    `${GREEN3}\u2713${RESET3} Mind Palace scaffolded at ${BOLD3}${targetDir}${RESET3}
+
+${DIM3}Next steps:${RESET3}
+  1. Edit ${targetDir}/attention.md \u2014 what you're focused on right now
+  2. Edit ${targetDir}/worldmodels/starter.worldmodel.md \u2014 add a few
+     aligned and drift behaviors
+  3. Run: neuroverse radiant emergent <owner/repo> \\
+           --worlds ${targetDir}/worldmodels \\
+           --exocortex ${targetDir}
+
+${DIM3}Files are yours. Edit freely.${RESET3}
+`
+  );
+}
 async function main34(argv) {
   const args = parseArgs27(argv);
   if (args.help || !args.subcommand) {
@@ -23796,6 +24744,8 @@ async function main34(argv) {
     return;
   }
   switch (args.subcommand) {
+    case "init":
+      return cmdInit2(args);
     case "think":
       return cmdThink(args);
     case "lenses":
@@ -23826,19 +24776,21 @@ async function main34(argv) {
       process.exit(1);
   }
 }
-var import_fs17, import_path18, RED2, DIM3, BOLD3, YELLOW3, RESET3, USAGE10;
+var import_fs19, import_path20, RED2, GREEN3, DIM3, BOLD3, YELLOW3, RESET3, USAGE10, MIND_PALACE_FILES;
 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";
+    GREEN3 = "\x1B[32m";
     DIM3 = "\x1B[2m";
     BOLD3 = "\x1B[1m";
     YELLOW3 = "\x1B[33m";
@@ -23846,6 +24798,9 @@ var init_radiant = __esm({
     USAGE10 = `
 ${BOLD3}neuroverse radiant${RESET3} \u2014 behavioral intelligence for collaboration systems
 
+${BOLD3}Setup:${RESET3}
+  init           Scaffold a Mind Palace in the current directory
+
 ${BOLD3}Stage A (voice layer):${RESET3}
   think          Send a query through the worldmodel + lens \u2192 AI-framed response
 
@@ -23856,20 +24811,208 @@ ${BOLD3}Stage B (behavioral analysis, coming soon):${RESET3}
   lenses         List or describe available rendering lenses
 
 ${BOLD3}Usage:${RESET3}
+  neuroverse radiant init                      (scaffolds ./mind-palace/)
+  neuroverse radiant init ./my-palace          (custom path)
   neuroverse radiant think --lens auki-builder --worlds ./worlds/ --query "What is our biggest risk?"
   neuroverse radiant think --lens auki-builder --worlds ./worlds/ < prompt.txt
   neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/
   neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/ --exocortex ~/exocortex/
+  neuroverse radiant emergent aukilabs/posemesh --personal --user alice
+  neuroverse radiant emergent aukilabs/ --entire-org --lens auki-builder --worlds ./worlds/
   neuroverse radiant lenses list
   neuroverse radiant lenses describe auki-builder
 
+${BOLD3}Read modes:${RESET3}
+  ${BOLD3}Default (team):${RESET3} reads all contributors in the given scope.
+  ${BOLD3}--personal --user <login>:${RESET3} reads ONLY that user's activity.
+    A local, private facilitator \u2014 no one else is observed. Works against
+    any scope; an org scope with --personal is fine.
+  ${BOLD3}--entire-org (gated):${RESET3} org-wide scope observes every contributor
+    across every repo. This is a global-observer stance and is opt-in.
+    \`radiant emergent <org>/\` without --entire-org will refuse and show
+    you the three choices (single repo, --personal, or explicit opt-in).
+
+${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)
   RADIANT_LENS         Default lens id (overridden by --lens)
   RADIANT_MODEL        AI model override (default: claude-sonnet-4-20250514)
   RADIANT_EXOCORTEX    Default exocortex directory (overridden by --exocortex)
+  RADIANT_USER         Default personal-mode user (overridden by --user)
 `.trim();
+    MIND_PALACE_FILES = {
+      "README.md": `# Mind Palace
+
+This is your Mind Palace \u2014 structured external memory that gives Radiant
+(and any agent you wire into it) persistent context about who you are,
+what you're working on, and what "on track" means for you.
+
+Radiant reads these files before every run and writes each read back into
+\`reads/\`. Over time, \`knowledge.md\` accumulates what's persisted and what
+hasn't \u2014 the feedback loop that turns raw activity into named behavior.
+
+## Files
+
+- \`attention.md\` \u2014 what you're focused on **right now**
+- \`goals.md\` \u2014 what you're working toward
+- \`sprint.md\` \u2014 this week's focus
+- \`identity.md\` \u2014 who you are, what you value
+- \`worldmodels/\` \u2014 your thinking constitutions (drift + aligned behaviors)
+- \`reads/\` \u2014 dated Radiant reads (written by \`radiant emergent\`)
+- \`knowledge.md\` \u2014 accumulated pattern persistence across reads
+
+## How to use
+
+1. Fill in \`attention.md\`, \`goals.md\`, \`sprint.md\`, \`identity.md\` with
+   your own words. A sentence each is enough to start \u2014 the files grow
+   with you.
+2. Edit \`worldmodels/starter.worldmodel.md\`: add a few aligned behaviors
+   (what on-track looks like) and drift behaviors (what off-track looks
+   like). The sharper these are, the sharper Radiant's reads.
+3. Run \`neuroverse radiant emergent <owner/repo> --mind-palace .\` against
+   the repo you want read. Radiant compares your stated intent (these
+   files) to your observed activity (GitHub) and names the gap.
+
+Edit freely. These files are yours.
+`,
+      "attention.md": `# Attention
+
+<!--
+What are you focused on RIGHT NOW? One paragraph. Updated as you shift.
+This is the file an AI agent reads at the start of a session to know
+what to help with today.
+-->
+
+`,
+      "goals.md": `# Goals
+
+<!--
+What are you working toward? Bullet points welcome.
+Longer horizon than attention \u2014 months, not days.
+-->
+
+-
+`,
+      "sprint.md": `# Sprint
+
+<!--
+This week's focus. What do you want to ship or finish?
+Keep it short \u2014 five bullets max.
+-->
+
+-
+`,
+      "identity.md": `# Identity
+
+<!--
+Who are you, what do you value, how do you work?
+This is the context an agent needs to not treat you like a stranger
+every time. Write it in your own voice.
+-->
+
+`,
+      "knowledge.md": `# Knowledge
+
+<!--
+Radiant writes accumulated pattern persistence here across reads.
+Leave this file empty on day one \u2014 it fills up as \`radiant emergent\`
+runs accumulate.
+-->
+
+`,
+      "reads/.gitkeep": "",
+      "worldmodels/starter.worldmodel.md": `# Starter Worldmodel
+
+<!--
+Your thinking constitution. Radiant reads this to understand what
+"aligned" and "drift" mean for your work.
+
+The sharper the Aligned/Drift Behaviors, the sharper Radiant's reads.
+When Radiant detects something matching a drift behavior below, it
+labels it with THAT name \u2014 it doesn't invent new ones.
+-->
+
+## Mission
+
+<!-- One sentence. What are you doing in the world? -->
+
+
+## Invariants
+
+<!--
+Non-negotiable rules. If a decision violates one, it's blocked.
+Keep this list short \u2014 3 to 6 items. Each should be a hard no.
+-->
+
+-
+
+## Aligned Behaviors
+
+<!--
+What "on track" looks like. One per line, phrased as a behavior.
+Radiant will use these as canonical pattern names when it sees
+matching evidence in your activity.
+
+Example:
+  - ships partial-but-working features rather than waiting for the full stack
+  - writes decisions down before acting on them
+-->
+
+-
+
+## Drift Behaviors
+
+<!--
+What "off track" looks like. Same format as Aligned.
+When Radiant detects drift, it will label it with these names \u2014 not
+make up new ones.
+
+Example:
+  - shipping pace outruns strategic decision-making
+  - architecture decisions surface without context about why
+-->
+
+-
+
+## Signals
+
+<!--
+Observable quantities you care about. Radiant scores activity
+against these \u2014 5 to 7 is the sweet spot.
+
+Example:
+  - shipping_velocity
+  - decision_ownership
+  - storytelling_cadence
+-->
+
+-
+
+## Decision Priorities
+
+<!--
+When tradeoffs appear, these resolve them. Format: "A > B".
+
+Example:
+  - correctness > speed
+  - clarity > cleverness
+-->
+
+-
+`
+    };
   }
 });