@neuroverseos/governance 0.8.1 → 0.9.0

package/dist/cli/radiant.cjs

@@ -477,7 +477,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
   };
 }
@@ -488,17 +488,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."
         },
@@ -529,7 +529,7 @@ var init_sovereign_conduit = __esm({
           "harm detection",
           "constraint design"
         ],
-        "sovereignty": [
+        "agency": [
           "independent thinking",
           "decision ownership",
           "self-trust",
@@ -553,7 +553,7 @@ var init_sovereign_conduit = __esm({
       output_translation: {
         never_surface_in_output: [
           "Stewardship",
-          "Sovereignty",
+          "Agency",
           "Integration"
         ],
         surface_freely: [
@@ -568,7 +568,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"
           },
           {
@@ -651,12 +651,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",
@@ -692,7 +692,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.",
@@ -703,7 +703,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.",
@@ -713,16 +713,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,
@@ -1670,82 +1670,382 @@ var init_notion = __esm({
   }
 });
 
+// src/radiant/core/git-remote.ts
+function resolveGitConfigPath(repoDir) {
+  const dotGit = (0, import_path.join)(repoDir, ".git");
+  if (!(0, import_fs.existsSync)(dotGit)) return null;
+  try {
+    const stat = (0, import_fs.statSync)(dotGit);
+    if (stat.isDirectory()) {
+      return (0, import_path.join)(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs.readFileSync)(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = (0, import_path.resolve)(repoDir, match[1].trim());
+      const configPath = (0, import_path.join)(gitDir, "config");
+      return (0, import_fs.existsSync)(configPath) ? configPath : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readOriginRemote(repoDir) {
+  const configPath = resolveGitConfigPath(repoDir);
+  if (!configPath) return null;
+  try {
+    const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
+    const sectionRe = /\[remote "origin"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/;
+    const section = sectionRe.exec(raw);
+    if (!section) return null;
+    const urlRe = /^\s*url\s*=\s*(.+?)\s*$/m;
+    const url = urlRe.exec(section[1]);
+    return url ? url[1] : null;
+  } catch {
+    return null;
+  }
+}
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const ssh = /^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (ssh) return { host: ssh[1], owner: ssh[2], repo: ssh[3] };
+  const sshProto = /^ssh:\/\/git@([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (sshProto) return { host: sshProto[1], owner: sshProto[2], repo: sshProto[3] };
+  const https = /^https?:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (https) return { host: https[1], owner: https[2], repo: https[3] };
+  return null;
+}
+function getRepoOrigin(repoDir) {
+  const url = readOriginRemote(repoDir);
+  if (!url) return null;
+  return parseRemoteUrl(url);
+}
+var import_fs, import_path;
+var init_git_remote = __esm({
+  "src/radiant/core/git-remote.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+  }
+});
+
+// src/radiant/core/extends.ts
+function loadExtendsConfig(repoDir) {
+  const configPath = (0, import_path2.join)(repoDir, ".neuroverse", "config.json");
+  if (!(0, import_fs2.existsSync)(configPath)) return null;
+  try {
+    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseExtendsSpec(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("github:")) {
+    const rest = trimmed.slice("github:".length);
+    const match = /^([^/]+)\/([^@:]+)(?:@([^:]+))?(?::(.+))?$/.exec(rest);
+    if (!match) return null;
+    return {
+      raw: trimmed,
+      kind: "github",
+      owner: match[1],
+      repo: match[2],
+      ref: match[3] ?? "HEAD",
+      subpath: match[4] ?? ""
+    };
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || (0, import_path2.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  return null;
+}
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse", "cache", "extends");
+  const key = (0, import_crypto.createHash)("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return (0, import_path2.join)(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = (0, import_path2.join)(cacheDir, ".neuroverse-fetched");
+  if (!(0, import_fs2.existsSync)(stampPath)) return false;
+  try {
+    const stamp = (0, import_fs2.statSync)(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = (0, import_path2.join)(cacheDir, ".neuroverse-fetched");
+  try {
+    (0, import_fs2.mkdirSync)(cacheDir, { recursive: true });
+    (0, import_fs2.writeFileSync)(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = (0, import_path2.isAbsolute)(spec.path) ? spec.path : (0, import_path2.resolve)(repoDir, spec.path);
+    if (!(0, import_fs2.existsSync)(full)) {
+      return { spec, dir: null, warning: `local extends path not found: ${full}` };
+    }
+    return { spec, dir: full };
+  }
+  const cacheRoot = options?.cacheDir;
+  const ttl = options?.ttlMs ?? DEFAULT_TTL_MS;
+  const cacheDir = getCacheDir(spec, cacheRoot);
+  const fresh = isCacheFresh(cacheDir, ttl);
+  const needsFetch = options?.forceRefresh || !fresh || !(0, import_fs2.existsSync)(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if ((0, import_fs2.existsSync)(cacheDir) && (0, import_fs2.existsSync)((0, import_path2.join)(cacheDir, ".neuroverse-fetched"))) {
+      return resolveSubpath(spec, cacheDir);
+    }
+    return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `NEUROVERSE_NO_FETCH set and no cache for ${spec.raw}` };
+  }
+  if (needsFetch) {
+    const fetcher = options?.fetcher ?? defaultGitFetcher;
+    try {
+      fetcher(spec, cacheDir);
+      markCacheFresh(cacheDir);
+    } catch (err) {
+      if ((0, import_fs2.existsSync)(cacheDir) && (0, import_fs2.existsSync)((0, import_path2.join)(cacheDir, ".neuroverse-fetched"))) {
+        const result = resolveSubpath(spec, cacheDir);
+        return options?.silentOnMissing ? result : { ...result, warning: `fetch failed for ${spec.raw}, using stale cache: ${err.message}` };
+      }
+      return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `fetch failed for ${spec.raw}: ${err.message}` };
+    }
+  }
+  return resolveSubpath(spec, cacheDir);
+}
+function resolveSubpath(spec, cacheDir) {
+  const target = spec.subpath ? (0, import_path2.join)(cacheDir, spec.subpath) : cacheDir;
+  if (!(0, import_fs2.existsSync)(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      (0, import_path2.join)(target, "worlds"),
+      (0, import_path2.join)(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if ((0, import_fs2.existsSync)(c)) return { spec, dir: c };
+    }
+  }
+  return { spec, dir: target };
+}
+function detectOrgExtendsSpec(repoDir) {
+  const origin = getRepoOrigin(repoDir);
+  if (!origin) return null;
+  if (origin.host !== "github.com") return null;
+  if (origin.repo === "worlds") return null;
+  return {
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
+  };
+}
+function resolveAllExtends(repoDir, options) {
+  const config = options?.config !== void 0 ? options.config : loadExtendsConfig(repoDir);
+  if (!config?.extends || config.extends.length === 0) return [];
+  const results = [];
+  for (const raw of config.extends) {
+    const spec = parseExtendsSpec(raw);
+    if (!spec) {
+      results.push({
+        spec: { raw, kind: "local" },
+        dir: null,
+        warning: `unparseable extends spec: ${raw}`
+      });
+      continue;
+    }
+    results.push(resolveExtendsSpec(spec, repoDir, options));
+  }
+  return results;
+}
+var import_fs2, import_path2, import_os, import_crypto, import_child_process, DEFAULT_TTL_MS, defaultGitFetcher;
+var init_extends = __esm({
+  "src/radiant/core/extends.ts"() {
+    "use strict";
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    import_os = require("os");
+    import_crypto = require("crypto");
+    import_child_process = require("child_process");
+    init_git_remote();
+    DEFAULT_TTL_MS = 60 * 60 * 1e3;
+    defaultGitFetcher = (spec, destDir) => {
+      if (spec.kind !== "github") return;
+      const url = `https://github.com/${spec.owner}/${spec.repo}.git`;
+      const parent = (0, import_path2.resolve)(destDir, "..");
+      (0, import_fs2.mkdirSync)(parent, { recursive: true });
+      if ((0, import_fs2.existsSync)(destDir)) {
+        (0, import_fs2.rmSync)(destDir, { recursive: true, force: true });
+      }
+      const args = ["clone", "--depth", "1", "--filter=blob:none"];
+      if (spec.ref && spec.ref !== "HEAD") {
+        args.push("--branch", spec.ref);
+      }
+      args.push(url, destDir);
+      (0, import_child_process.execFileSync)("git", args, { stdio: "pipe" });
+    };
+  }
+});
+
 // src/radiant/core/discovery.ts
 function discoverWorlds(options) {
   const worlds = [];
-  const userDir = options?.userWorldsDir ?? (0, import_path.join)((0, import_os.homedir)(), ".neuroverse", "worlds");
-  if ((0, import_fs.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_path3.join)((0, import_os2.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs3.existsSync)(userDir)) {
     worlds.push(...loadWorldsFromDir(userDir, "user"));
   }
+  if (!noOrg && !options?.explicitWorldsDir) {
+    const specs = [];
+    if (options?.repoDir) {
+      const fromGit = detectOrgExtendsSpec(options.repoDir);
+      if (fromGit) specs.push(fromGit);
+    }
+    if (options?.scopeOwner) {
+      const already = specs.some(
+        (s) => s.owner?.toLowerCase() === options.scopeOwner.toLowerCase()
+      );
+      if (!already) {
+        specs.push({
+          raw: `github:${options.scopeOwner}/worlds`,
+          kind: "github",
+          owner: options.scopeOwner,
+          repo: "worlds"
+        });
+      }
+    }
+    const baseDir = options?.repoDir ?? process.cwd();
+    for (const spec of specs) {
+      const result = resolveExtendsSpec(spec, baseDir, {
+        cacheDir: options?.extendsCacheDir,
+        fetcher: options?.extendsFetcher,
+        ttlMs: options?.extendsTtlMs,
+        forceRefresh,
+        noFetch,
+        silentOnMissing: true
+      });
+      worlds.push(...loadExtendsWorlds(result, "org"));
+    }
+  }
+  if (options?.repoDir && !options.disableExtends && !options.explicitWorldsDir) {
+    const results = resolveAllExtends(options.repoDir, {
+      cacheDir: options.extendsCacheDir,
+      fetcher: options.extendsFetcher,
+      ttlMs: options.extendsTtlMs,
+      forceRefresh,
+      noFetch
+    });
+    for (const result of results) {
+      worlds.push(...loadExtendsWorlds(result, "extends"));
+      if (result.warning) warnings.push(result.warning);
+    }
+  }
   if (options?.explicitWorldsDir) {
     worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
   } else if (options?.repoDir) {
     const repoPaths = [
-      (0, import_path.join)(options.repoDir, "worlds"),
-      (0, import_path.join)(options.repoDir, ".neuroverse", "worlds")
+      (0, import_path3.join)(options.repoDir, "worlds"),
+      (0, import_path3.join)(options.repoDir, ".neuroverse", "worlds")
     ];
     for (const p of repoPaths) {
-      if ((0, import_fs.existsSync)(p)) {
+      if ((0, import_fs3.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 summary = worlds.length === 0 ? "no worlds discovered" : worlds.map((w) => `${w.name} (${w.source})`).join(", ");
-  return { worlds, combinedContent, summary };
+  return { worlds, combinedContent, summary, warnings };
+}
+function formatActiveWorlds(stack) {
+  if (stack.worlds.length === 0) return "No worlds loaded.";
+  const lines = ["ACTIVE WORLDS", ""];
+  for (const w of stack.worlds) {
+    const sourceLabel = w.source === "base" ? "universal" : w.source === "user" ? "personal" : w.source === "org" ? `org (${w.extendsFrom ?? "auto"})` : w.source === "extends" ? `shared (${w.extendsFrom ?? "extends"})` : "this repo";
+    lines.push(`  ${w.name} (${sourceLabel})`);
+  }
+  if (stack.warnings.length > 0) {
+    lines.push("", "WARNINGS");
+    for (const w of stack.warnings) lines.push(`  ${w}`);
+  }
+  return lines.join("\n");
+}
+function loadExtendsWorlds(result, source) {
+  if (!result.dir) return [];
+  const loaded = loadWorldsFromDir(result.dir, source);
+  return loaded.map((w) => ({ ...w, extendsFrom: result.spec.raw }));
 }
 function loadWorldsFromDir(dirPath, source) {
-  const dir = (0, import_path.resolve)(dirPath);
-  if (!(0, import_fs.existsSync)(dir)) return [];
-  const stat = (0, import_fs.statSync)(dir);
+  const dir = (0, import_path3.resolve)(dirPath);
+  if (!(0, import_fs3.existsSync)(dir)) return [];
+  const stat = (0, import_fs3.statSync)(dir);
   if (stat.isFile() && dir.endsWith(".md")) {
     try {
       return [{
-        name: (0, import_path.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        name: (0, import_path3.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
         source,
         path: dir,
-        content: (0, import_fs.readFileSync)(dir, "utf-8")
+        content: (0, import_fs3.readFileSync)(dir, "utf-8")
       }];
     } catch {
       return [];
     }
   }
   if (!stat.isDirectory()) return [];
-  const files = (0, import_fs.readdirSync)(dir).filter(
+  const files = (0, import_fs3.readdirSync)(dir).filter(
     (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
   ).sort();
   return files.map((f) => {
-    const fullPath = (0, import_path.join)(dir, f);
+    const fullPath = (0, import_path3.join)(dir, f);
     return {
       name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
       source,
       path: fullPath,
-      content: (0, import_fs.readFileSync)(fullPath, "utf-8")
+      content: (0, import_fs3.readFileSync)(fullPath, "utf-8")
     };
   });
 }
-var import_fs, import_path, import_os;
+var import_fs3, import_path3, import_os2;
 var init_discovery = __esm({
   "src/radiant/core/discovery.ts"() {
     "use strict";
-    import_fs = require("fs");
-    import_path = require("path");
-    import_os = require("os");
+    import_fs3 = require("fs");
+    import_path3 = require("path");
+    import_os2 = require("os");
+    init_extends();
   }
 });
 
 // src/radiant/adapters/exocortex.ts
 function readExocortex(dirPath, repoName) {
-  const dir = (0, import_path2.resolve)(dirPath);
+  const dir = (0, import_path4.resolve)(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = (0, import_path2.join)(dir, p);
-      if ((0, import_fs2.existsSync)(full)) {
+      const full = (0, import_path4.join)(dir, p);
+      if ((0, import_fs4.existsSync)(full)) {
         try {
-          const content = (0, import_fs2.readFileSync)(full, "utf-8").trim();
+          const content = (0, import_fs4.readFileSync)(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -1827,33 +2127,33 @@ function summarizeExocortex(ctx) {
   if (ctx.methods) loaded.push("methods");
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
-var import_fs2, import_path2;
+var import_fs4, import_path4;
 var init_exocortex = __esm({
   "src/radiant/adapters/exocortex.ts"() {
     "use strict";
-    import_fs2 = require("fs");
-    import_path2 = require("path");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
   }
 });
 
 // src/radiant/memory/palace.ts
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
-  (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = (0, import_path3.join)(dir, filename);
+  const filepath = (0, import_path5.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs3.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs5.writeFileSync)(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant");
-  (0, import_fs3.mkdirSync)(dir, { recursive: true });
-  const filepath = (0, import_path3.join)(dir, "knowledge.md");
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path5.join)(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -1940,14 +2240,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs3.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  (0, import_fs5.writeFileSync)(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!(0, import_fs3.existsSync)(filepath)) return counts;
+  if (!(0, import_fs5.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -1965,13 +2265,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
-  if (!(0, import_fs3.existsSync)(dir)) return [];
-  const files = (0, import_fs3.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs5.existsSync)(dir)) return [];
+  const files = (0, import_fs5.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = (0, import_path3.join)(dir, filename);
-    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
+    const filepath = (0, import_path5.join)(dir, filename);
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -2005,12 +2305,12 @@ function computePersistence(priorReads, currentPatternNames) {
     dates: dates.sort()
   })).sort((a, b) => b.occurrences - a.occurrences);
 }
-var import_fs3, import_path3;
+var import_fs5, import_path5;
 var init_palace = __esm({
   "src/radiant/memory/palace.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path3 = require("path");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
   }
 });
 
@@ -3119,10 +3419,10 @@ var init_guard_engine = __esm({
 // src/loader/world-loader.ts
 async function loadWorldFromDirectory(dirPath) {
   const { readFile } = await import("fs/promises");
-  const { join: join6 } = await import("path");
+  const { join: join8 } = await import("path");
   const { readdirSync: readdirSync6 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join6(dirPath, filename);
+    const filePath = join8(dirPath, filename);
     try {
       const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
@@ -3152,11 +3452,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join6(dirPath, "rules");
+    const rulesDir = join8(dirPath, "rules");
     const ruleFiles = readdirSync6(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile(join6(rulesDir, file), "utf-8");
+        const content = await readFile(join8(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -4251,22 +4551,22 @@ __export(server_exports, {
   startRadiantMcp: () => startRadiantMcp
 });
 function loadWorldmodelContent(worldsPath) {
-  const resolved = (0, import_path4.resolve)(worldsPath);
-  if (!(0, import_fs4.existsSync)(resolved)) {
+  const resolved = (0, import_path6.resolve)(worldsPath);
+  if (!(0, import_fs6.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs4.statSync)(resolved);
+  const stat = (0, import_fs6.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs4.readFileSync)(resolved, "utf-8");
+    return (0, import_fs6.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs4.readdirSync)(resolved).filter(
-      (f) => (0, import_path4.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs6.readdirSync)(resolved).filter(
+      (f) => (0, import_path6.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(`No worldmodel files found in ${resolved}`);
     }
-    return files.map((f) => (0, import_fs4.readFileSync)((0, import_path4.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
+    return files.map((f) => (0, import_fs6.readFileSync)((0, import_path6.join)(resolved, f), "utf-8")).join("\n\n---\n\n");
   }
   throw new Error(`Worlds path is neither a file nor directory: ${resolved}`);
 }
@@ -4285,12 +4585,12 @@ async function startRadiantMcp(args) {
   const server = new RadiantMcpServer({ worldsPath, lensId, model });
   await server.start();
 }
-var import_fs4, import_path4, TOOLS, RadiantMcpServer;
+var import_fs6, import_path6, TOOLS, RadiantMcpServer;
 var init_server = __esm({
   "src/radiant/mcp/server.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path4 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     init_think();
     init_emergent();
     init_ai();
@@ -4521,14 +4821,15 @@ __export(radiant_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(radiant_exports);
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 init_think();
 init_emergent();
 init_ai();
 init_scopes();
 init_exocortex();
 init_lenses();
+init_discovery();
 var RED = "\x1B[31m";
 var DIM = "\x1B[2m";
 var BOLD = "\x1B[1m";
@@ -4554,6 +4855,18 @@ ${BOLD}Usage:${RESET}
   neuroverse radiant lenses list
   neuroverse radiant lenses describe auki-builder
 
+${BOLD}Auto-discovery:${RESET}
+  You do not need to clone the target repo.
+
+    radiant emergent NeuroverseOS/       \u2192 probes github.com/NeuroverseOS/worlds
+    radiant emergent aukiverse/posemesh  \u2192 probes github.com/aukiverse/worlds
+
+  The scope argument itself is enough. Discovery also picks up
+  ~/.neuroverse/worlds/ (personal), the org from your current clone's
+  .git/config (if any), and ./worlds/ (this repo).
+
+  Set NEUROVERSE_NO_ORG=1 to disable org probing for a single run.
+
 ${BOLD}Environment:${RESET}
   ANTHROPIC_API_KEY    Required for AI commands (think, emergent, decision)
   RADIANT_WORLDS       Default worlds directory (overridden by --worlds)
@@ -4620,17 +4933,17 @@ function parseArgs(argv) {
   return result;
 }
 function loadWorldmodelContent2(worldsPath) {
-  const resolved = (0, import_path5.resolve)(worldsPath);
-  if (!(0, import_fs5.existsSync)(resolved)) {
+  const resolved = (0, import_path7.resolve)(worldsPath);
+  if (!(0, import_fs7.existsSync)(resolved)) {
     throw new Error(`Worlds path not found: ${resolved}`);
   }
-  const stat = (0, import_fs5.statSync)(resolved);
+  const stat = (0, import_fs7.statSync)(resolved);
   if (stat.isFile()) {
-    return (0, import_fs5.readFileSync)(resolved, "utf-8");
+    return (0, import_fs7.readFileSync)(resolved, "utf-8");
   }
   if (stat.isDirectory()) {
-    const files = (0, import_fs5.readdirSync)(resolved).filter(
-      (f) => (0, import_path5.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
+    const files = (0, import_fs7.readdirSync)(resolved).filter(
+      (f) => (0, import_path7.extname)(f) === ".md" && (f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md"))
     ).sort();
     if (files.length === 0) {
       throw new Error(
@@ -4638,27 +4951,55 @@ function loadWorldmodelContent2(worldsPath) {
       );
     }
     return files.map((f) => {
-      const content = (0, import_fs5.readFileSync)((0, import_path5.join)(resolved, f), "utf-8");
+      const content = (0, import_fs7.readFileSync)((0, import_path7.join)(resolved, f), "utf-8");
       return `<!-- worldmodel: ${f} -->
 ${content}`;
     }).join("\n\n---\n\n");
   }
   throw new Error(`Worlds path is neither a file nor a directory: ${resolved}`);
 }
-async function cmdThink(args) {
-  const lensId = args.lens ?? process.env.RADIANT_LENS;
-  if (!lensId) {
+function resolveWorldmodelContent(explicitPath, scopeOwner) {
+  if (explicitPath) {
+    return loadWorldmodelContent2(explicitPath);
+  }
+  const stack = discoverWorlds({
+    repoDir: process.cwd(),
+    scopeOwner
+  });
+  if (stack.worlds.length === 0) {
+    const scopeLine = scopeOwner ? `  3. github:${scopeOwner}/worlds (from scope arg)
+` : "";
+    const ext = scopeOwner ? 4 : 3;
+    const repo = scopeOwner ? 5 : 4;
     process.stderr.write(
-      `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
-${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
+      `${RED}Error:${RESET} No worldmodel found.
+${DIM}Tried (in order):
+  1. ~/.neuroverse/worlds/              (user tier)
+  2. github:<owner>/worlds              (org auto-detect from git remote)
+` + scopeLine + `  ${ext}. .neuroverse/config.json extends    (explicit shared worlds)
+  ${repo}. ./worlds/ or ./.neuroverse/worlds/ (repo tier)
+
+Pass --worlds <dir> or set RADIANT_WORLDS to specify explicitly.
+Or run against a <scope>/ where github.com/<scope>/worlds exists.${RESET}
 `
     );
     process.exit(1);
   }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
+  process.stderr.write(`${DIM}${formatActiveWorlds(stack)}${RESET}
+
+`);
+  for (const warning of stack.warnings) {
+    process.stderr.write(`${YELLOW}\u26A0${RESET}  ${warning}
+`);
+  }
+  return stack.combinedContent;
+}
+async function cmdThink(args) {
+  const lensId = args.lens ?? process.env.RADIANT_LENS;
+  if (!lensId) {
     process.stderr.write(
-      `${RED}Error:${RESET} --worlds <dir> or RADIANT_WORLDS required.
+      `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
+${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
 `
     );
     process.exit(1);
@@ -4677,7 +5018,7 @@ ${DIM}Set it to your Anthropic API key to use Radiant's AI features.${RESET}
     query = args.rest.join(" ");
   }
   if (!query && !process.stdin.isTTY) {
-    query = (0, import_fs5.readFileSync)(0, "utf-8").trim();
+    query = (0, import_fs7.readFileSync)(0, "utf-8").trim();
   }
   if (!query) {
     process.stderr.write(
@@ -4687,12 +5028,12 @@ ${DIM}Use --query "...", pass as trailing args, or pipe via stdin.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent2(worldsPath);
+  const explicitWorldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  const worldmodelContent = resolveWorldmodelContent(explicitWorldsPath);
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(apiKey, model || void 0);
   process.stderr.write(
-    `${DIM}Worlds: ${worldsPath}${RESET}
-${DIM}Lens:   ${lensId}${RESET}
+    `${DIM}Lens:   ${lensId}${RESET}
 ${DIM}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET}
 
 `
@@ -4751,14 +5092,6 @@ async function cmdEmergent(args) {
     process.stderr.write(
       `${RED}Error:${RESET} --lens <id> or RADIANT_LENS required.
 ${DIM}Available lenses: ${listLenses().join(", ")}${RESET}
-`
-    );
-    process.exit(1);
-  }
-  const worldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
-  if (!worldsPath) {
-    process.stderr.write(
-      `${RED}Error:${RESET} --worlds <dir> or RADIANT_WORLDS required.
 `
     );
     process.exit(1);
@@ -4780,7 +5113,11 @@ ${DIM}Set it to a GitHub PAT with repo read access.${RESET}
     );
     process.exit(1);
   }
-  const worldmodelContent = loadWorldmodelContent2(worldsPath);
+  const explicitWorldsPath = args.worlds ?? process.env.RADIANT_WORLDS;
+  const worldmodelContent = resolveWorldmodelContent(
+    explicitWorldsPath,
+    scope.owner
+  );
   const model = args.model ?? process.env.RADIANT_MODEL;
   const ai = createAnthropicAI(anthropicKey, model || void 0);
   const view = args.view ?? process.env.RADIANT_VIEW ?? "community";