@neuroverseos/governance 0.8.1 → 0.9.0

package/AGENTS.md

@@ -4,6 +4,14 @@
 
 Runtime containment for AI agents. Define what an agent can and cannot do, then enforce it at every action. Deterministic — same event + same rules = same verdict. No LLM in the evaluation loop.
 
+> **Where the NeuroverseOS worldmodel lives.** The canonical Sovereign Conduit
+> worldmodel is at [github.com/NeuroverseOS/Worlds](https://github.com/NeuroverseOS/Worlds).
+> Every NeuroverseOS repo — including this one — auto-loads it via the
+> org-detect discovery tier. A reference sample sits at
+> `src/radiant/examples/neuroverse-base/` (alongside `src/radiant/examples/auki/`)
+> for developers who want to see the format. Do not edit the sample — edit the
+> source.
+
 ## Quick Start for Agents
 
 ### Install

package/README.md

@@ -548,7 +548,7 @@ A World is a `.nv-world.md` file. It contains everything:
 | **Guards** | Domain-specific enforcement |
 | **Gates** | Viability classification |
 
-Three ways to create a world. All produce the same `WorldDefinition` object:
+Four ways to create a world. All produce the same `WorldDefinition` object:
 
 ```
 Path 1: Configurator (12 questions)
@@ -559,6 +559,9 @@ Path 2: CLI
 
 Path 3: Code
   defineWorld({...}) → WorldDefinition
+
+Path 4: World Model Builder (mission + skills + values + overlaps)
+  .worldmodel.md → neuroverse worldmodel build → .nv-world.md → WorldDefinition
 ```
 
 All three work with the same runtime. A world created through the configurator works identically to one written by hand.
@@ -747,6 +750,7 @@ const verdict = evaluatePlan({ intent: 'buy billboard ads' }, plan);
 | `neuroverse mcp` | MCP governance server |
 | `neuroverse plan` | Plan enforcement commands |
 | `neuroverse lens` | Manage behavioral lenses (list, preview, compile) |
+| `neuroverse worldmodel` | Behavioral world model builder (init, validate, build, explain) |
 
 ### Lens CLI
 
@@ -770,6 +774,120 @@ neuroverse lens compare --input "I'm stressed" --lenses stoic,coach,calm
 neuroverse lens add --world ./world/ --name "Support" --tagline "Patient and clear" --emotion warm
 ```
 
+### World Model CLI
+
+Build behavioral world models from mission, skills, values, and emergent overlap effects.
+
+A `.worldmodel.md` file defines three layers:
+
+1. **Core Model Geometry** — mission, domains (each carrying skills + values), overlap effects, center identity
+2. **Contextual Modifiers** — authority layers, spatial contexts, interpretation rules
+3. **Evolution Layer** — aligned/drift behaviors, signals, decision priorities, evolution conditions
+
+The compiler transforms this into executable governance artifacts:
+
+```bash
+# Scaffold a new behavioral model
+neuroverse worldmodel init --name "My Model"
+
+# Validate structure and completeness
+neuroverse worldmodel validate ./my-model.worldmodel.md
+
+# Human-readable model summary
+neuroverse worldmodel explain ./my-model.worldmodel.md
+
+# Compile to .nv-world.md + signals + overlaps + contexts + lenses
+neuroverse worldmodel build ./my-model.worldmodel.md --output ./world/
+
+# Emit individual artifacts
+neuroverse worldmodel emit-world ./my-model.worldmodel.md
+neuroverse worldmodel emit-signals ./my-model.worldmodel.md
+neuroverse worldmodel emit-lenses ./my-model.worldmodel.md
+neuroverse worldmodel emit-contexts ./my-model.worldmodel.md
+neuroverse worldmodel emit-overlaps ./my-model.worldmodel.md
+```
+
+Example `.worldmodel.md`:
+
+```markdown
+---
+name: Auki Vanguard
+version: 1.0.0
+---
+
+# Core Model Geometry
+
+## Mission
+Build the real world web while preserving long-term mission alignment.
+
+## Domains
+
+### Future Foresight
+#### Skills
+- Strategic Thinking
+- Systems Design
+#### Values
+- Long-term thinking
+- Intellectual honesty
+
+### Narrative Dynamics
+#### Skills
+- Storytelling
+- Communication Design
+#### Values
+- Authenticity
+- Clarity
+
+## Overlap Effects
+- Future Foresight + Narrative Dynamics = Inspiration
+
+## Center Identity
+Collective Vanguard Leader
+
+# Contextual Modifiers
+
+## Authority Layers
+- founder
+- contributor
+- agent
+
+## Spatial Contexts
+- strategy
+- execution
+- deployment
+
+## Interpretation Rules
+- ambiguity from a founder carries more system-wide risk than from a contributor
+
+# Evolution Layer
+
+## Aligned Behaviors
+- communicates future direction in ways others can act on
+
+## Drift Behaviors
+- mission language disconnected from execution
+
+## Signals
+- clarity
+- ownership
+- follow_through
+
+## Decision Priorities
+- long_term_ecosystem > short_term_convenience
+
+## Evolution Conditions
+- propose model updates when repeated behavior contradicts a current assumption
+```
+
+The deterministic compiler produces:
+- **`.nv-world.md`** — executable world file (thesis, invariants, state, rules, gates, outcomes, lenses)
+- **`signals.json`** — signal schema for behavioral tracking
+- **`overlaps.json`** — overlap map with pairwise domain effects and matrix view
+- **`contexts.json`** — contextual modifiers for interpretation shaping
+- **`lenses.json`** — lens suggestions derived from overlap effects
+
+Two bundled examples ship with the package: `auki-vanguard.worldmodel.md` and `neuroverse-governance.worldmodel.md`.
+
 ---
 
 ## Architecture

package/dist/{chunk-ETDIEVAX.js → chunk-3ZWU7C43.js}

@@ -1,6 +1,6 @@
 import {
   getLens
-} from "./chunk-F2LWMOM5.js";
+} from "./chunk-TCGGED4G.js";
 import {
   loadWorld
 } from "./chunk-I4RTIMLX.js";
@@ -859,55 +859,332 @@ async function fetchNotionAPI(url, headers, init) {
   return await res.json();
 }
 
-// src/radiant/core/discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { join, resolve, basename } from "path";
+// src/radiant/core/git-remote.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join, resolve } from "path";
+function resolveGitConfigPath(repoDir) {
+  const dotGit = join(repoDir, ".git");
+  if (!existsSync(dotGit)) return null;
+  try {
+    const stat = statSync(dotGit);
+    if (stat.isDirectory()) {
+      return join(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = readFileSync(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = resolve(repoDir, match[1].trim());
+      const configPath = join(gitDir, "config");
+      return existsSync(configPath) ? configPath : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readOriginRemote(repoDir) {
+  const configPath = resolveGitConfigPath(repoDir);
+  if (!configPath) return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const sectionRe = /\[remote "origin"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/;
+    const section = sectionRe.exec(raw);
+    if (!section) return null;
+    const urlRe = /^\s*url\s*=\s*(.+?)\s*$/m;
+    const url = urlRe.exec(section[1]);
+    return url ? url[1] : null;
+  } catch {
+    return null;
+  }
+}
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const ssh = /^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (ssh) return { host: ssh[1], owner: ssh[2], repo: ssh[3] };
+  const sshProto = /^ssh:\/\/git@([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (sshProto) return { host: sshProto[1], owner: sshProto[2], repo: sshProto[3] };
+  const https = /^https?:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (https) return { host: https[1], owner: https[2], repo: https[3] };
+  return null;
+}
+function getRepoOrigin(repoDir) {
+  const url = readOriginRemote(repoDir);
+  if (!url) return null;
+  return parseRemoteUrl(url);
+}
+
+// src/radiant/core/extends.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, statSync as statSync2, writeFileSync } from "fs";
+import { join as join2, resolve as resolve2, isAbsolute } from "path";
 import { homedir } from "os";
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
+function loadExtendsConfig(repoDir) {
+  const configPath = join2(repoDir, ".neuroverse", "config.json");
+  if (!existsSync2(configPath)) return null;
+  try {
+    const raw = readFileSync2(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("../") || isAbsolute(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  return null;
+}
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? join2(homedir(), ".neuroverse", "cache", "extends");
+  const key = createHash("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return join2(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = join2(cacheDir, ".neuroverse-fetched");
+  if (!existsSync2(stampPath)) return false;
+  try {
+    const stamp = statSync2(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = join2(cacheDir, ".neuroverse-fetched");
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+var defaultGitFetcher = (spec, destDir) => {
+  if (spec.kind !== "github") return;
+  const url = `https://github.com/${spec.owner}/${spec.repo}.git`;
+  const parent = resolve2(destDir, "..");
+  mkdirSync(parent, { recursive: true });
+  if (existsSync2(destDir)) {
+    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);
+  execFileSync("git", args, { stdio: "pipe" });
+};
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = isAbsolute(spec.path) ? spec.path : resolve2(repoDir, spec.path);
+    if (!existsSync2(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 || !existsSync2(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if (existsSync2(cacheDir) && existsSync2(join2(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 (existsSync2(cacheDir) && existsSync2(join2(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 ? join2(cacheDir, spec.subpath) : cacheDir;
+  if (!existsSync2(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      join2(target, "worlds"),
+      join2(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if (existsSync2(c)) return { spec, dir: c };
+    }
+  }
+  return { spec, dir: target };
+}
+function detectOrgExtendsSpec(repoDir) {
+  const origin = getRepoOrigin(repoDir);
+  if (!origin) return null;
+  if (origin.host !== "github.com") return null;
+  if (origin.repo === "worlds") return null;
+  return {
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
+  };
+}
+function resolveAllExtends(repoDir, options) {
+  const config = options?.config !== void 0 ? options.config : loadExtendsConfig(repoDir);
+  if (!config?.extends || config.extends.length === 0) return [];
+  const results = [];
+  for (const raw of config.extends) {
+    const spec = parseExtendsSpec(raw);
+    if (!spec) {
+      results.push({
+        spec: { raw, kind: "local" },
+        dir: null,
+        warning: `unparseable extends spec: ${raw}`
+      });
+      continue;
+    }
+    results.push(resolveExtendsSpec(spec, repoDir, options));
+  }
+  return results;
+}
+
+// src/radiant/core/discovery.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { join as join3, resolve as resolve3, basename } from "path";
+import { homedir as homedir2 } from "os";
 function discoverWorlds(options) {
   const worlds = [];
-  const userDir = options?.userWorldsDir ?? join(homedir(), ".neuroverse", "worlds");
-  if (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 ?? join3(homedir2(), ".neuroverse", "worlds");
+  if (existsSync3(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 = [
-      join(options.repoDir, "worlds"),
-      join(options.repoDir, ".neuroverse", "worlds")
+      join3(options.repoDir, "worlds"),
+      join3(options.repoDir, ".neuroverse", "worlds")
     ];
     for (const p of repoPaths) {
-      if (existsSync(p)) {
+      if (existsSync3(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" : "this repo";
+    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 = resolve(dirPath);
-  if (!existsSync(dir)) return [];
-  const stat = statSync(dir);
+  const dir = resolve3(dirPath);
+  if (!existsSync3(dir)) return [];
+  const stat = statSync3(dir);
   if (stat.isFile() && dir.endsWith(".md")) {
     try {
       return [{
         name: basename(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
         source,
         path: dir,
-        content: readFileSync(dir, "utf-8")
+        content: readFileSync3(dir, "utf-8")
       }];
     } catch {
       return [];
@@ -918,28 +1195,28 @@ function loadWorldsFromDir(dirPath, source) {
     (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
   ).sort();
   return files.map((f) => {
-    const fullPath = join(dir, f);
+    const fullPath = join3(dir, f);
     return {
       name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
       source,
       path: fullPath,
-      content: readFileSync(fullPath, "utf-8")
+      content: readFileSync3(fullPath, "utf-8")
     };
   });
 }
 
 // src/radiant/adapters/exocortex.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { join as join4, resolve as resolve4 } from "path";
 function readExocortex(dirPath, repoName) {
-  const dir = resolve2(dirPath);
+  const dir = resolve4(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = join2(dir, p);
-      if (existsSync2(full)) {
+      const full = join4(dir, p);
+      if (existsSync4(full)) {
         try {
-          const content = readFileSync2(full, "utf-8").trim();
+          const content = readFileSync4(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -1049,14 +1326,14 @@ ${ctx.methods}`);
   return sections.join("\n\n");
 }
 function readTeamExocortices(teamDir) {
-  const dir = resolve2(teamDir);
-  if (!existsSync2(dir)) return [];
+  const dir = resolve4(teamDir);
+  if (!existsSync4(dir)) return [];
   const entries = readdirSync2(dir);
   const results = [];
   for (const entry of entries) {
-    const entryPath = join2(dir, entry);
+    const entryPath = join4(dir, entry);
     try {
-      const stat = statSync2(entryPath);
+      const stat = statSync4(entryPath);
       if (stat.isDirectory()) {
         const ctx = readExocortex(entryPath);
         if (ctx.filesLoaded > 0) {
@@ -1101,25 +1378,25 @@ function summarizeExocortex(ctx) {
 }
 
 // src/radiant/memory/palace.ts
-import { readFileSync as readFileSync3, writeFileSync, mkdirSync, readdirSync as readdirSync3, existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3, existsSync as existsSync5 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = resolve3(exocortexDir, "radiant", "reads");
-  mkdirSync(dir, { recursive: true });
+  const dir = resolve5(exocortexDir, "radiant", "reads");
+  mkdirSync2(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = join3(dir, filename);
+  const filepath = join5(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  writeFileSync(filepath, content, "utf-8");
+  writeFileSync2(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = resolve3(exocortexDir, "radiant");
-  mkdirSync(dir, { recursive: true });
-  const filepath = join3(dir, "knowledge.md");
+  const dir = resolve5(exocortexDir, "radiant");
+  mkdirSync2(dir, { recursive: true });
+  const filepath = join5(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -1206,14 +1483,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  writeFileSync(filepath, lines.join("\n"), "utf-8");
+  writeFileSync2(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!existsSync3(filepath)) return counts;
+  if (!existsSync5(filepath)) return counts;
   try {
-    const content = readFileSync3(filepath, "utf-8");
+    const content = readFileSync5(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -1231,13 +1508,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = resolve3(exocortexDir, "radiant", "reads");
-  if (!existsSync3(dir)) return [];
+  const dir = resolve5(exocortexDir, "radiant", "reads");
+  if (!existsSync5(dir)) return [];
   const files = readdirSync3(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = join3(dir, filename);
-    const content = readFileSync3(filepath, "utf-8");
+    const filepath = join5(dir, filename);
+    const content = readFileSync5(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -2283,6 +2560,15 @@ export {
   formatSlackSignalsForPrompt,
   fetchNotionActivity,
   formatNotionSignalsForPrompt,
+  readOriginRemote,
+  parseRemoteUrl,
+  getRepoOrigin,
+  loadExtendsConfig,
+  parseExtendsSpec,
+  getCacheDir,
+  resolveExtendsSpec,
+  detectOrgExtendsSpec,
+  resolveAllExtends,
   discoverWorlds,
   formatActiveWorlds,
   readExocortex,