@neuroverseos/governance 0.6.1 → 0.8.0

package/README.md

@@ -3,12 +3,51 @@
 [![npm version](https://img.shields.io/npm/v/@neuroverseos/governance)](https://www.npmjs.com/package/@neuroverseos/governance)
 [![license](https://img.shields.io/npm/l/@neuroverseos/governance)](LICENSE.md)
 
-**Control what AI can do — and how it behaves — across every app.**
+**Behavioral governance for AI systems.** Give meaning to behavior — meaning relative to the behavioral models that have been declared and governed.
 
-NeuroVerse is the governance layer for AI-powered devices. It gives users, developers, and organizations a single system to define permissions, behavioral personality, and role-based access — for smart glasses, phones, agents, or any AI-enabled product.
+Human intelligence and artificial intelligence are two different kinds of intelligence working together. All organizations, all systems, gather people around declared shared intent. NeuroverseOS tools help define those intentions into behaviors — and those behaviors become a constitution carried out at runtime.
 
-**Built for multi-agent systems:** when many agents are active, they all evaluate against the same deterministic governance model.  
-**Built for handoff:** governance is portable as world/plan artifacts, so teams can update policy quickly and hand it across agents, apps, and operators without rewriting core logic.
+NeuroverseOS is the universe where human and AI meet to work together, defined by the behaviors the organization has agreed upon. **Radiant** is the behavioral intelligence layer built on top: it reads what happened, compares it against what was declared, and tells you where the work aligns and where it drifts.
+
+Together they put you in a cocoon of behavior — not a cage, a cocoon. Something that holds your shape while you're becoming what you said you'd become.
+
+## Two products, one package
+
+| Layer | What it does | Who uses it |
+|---|---|---|
+| **NeuroverseOS** | Governance engine — worldmodel compiler, guard engine, lens system, plan enforcement | Developers building governed AI apps |
+| **Radiant** | Behavioral intelligence — reads activity, gives it meaning through the worldmodel, measures human-AI alignment | Teams and organizations (starting with Auki/ExoCortex) |
+
+Both ship in `@neuroverseos/governance`. Install once, use either or both.
+
+## Radiant — behavioral intelligence for collaboration
+
+Radiant gives meaning to behavior. It reads activity (GitHub commits, PRs, reviews), classifies each event by who did it (human, AI, or both together), extracts behavioral signals, identifies patterns through AI interpretation governed by the worldmodel, and produces a structured read:
+
+```bash
+npx @neuroverseos/governance radiant emergent aukiverse/posemesh \
+  --lens auki-builder --worlds ./worlds/
+```
+
+Output:
+
+```
+EMERGENT    — what patterns are visible in the team's work
+MEANING     — what it means against the worldmodel
+MOVE        — what to do about it (or "nothing's broken, keep shipping")
+ALIGNMENT   — L/C/N/R scores (human, AI, collaboration, composite)
+GOVERNANCE  — audit trail: which events triggered governance, on which side
+DEPTH       — what Radiant can see now vs what unlocks with more reads
+```
+
+Three scores nobody else measures:
+- **L** — is the human's work aligned with the declared model?
+- **C** — is the AI's output aligned with the declared model?
+- **N** — when human and AI work together, is shared meaning preserved through the worldmodel? This score only exists because the worldmodel exists.
+
+For the full Radiant documentation, see [`src/radiant/examples/auki/README.md`](src/radiant/examples/auki/README.md).
+
+## Governance engine — deterministic rules for AI
 
 ```
 What AI can do      →  Rules (permissions)
@@ -55,7 +94,6 @@ NeuroVerse gives you composable primitives:
 
 These blocks let you build robots/agents that can traverse heterogeneous spaces while remaining policy-compliant, auditable, and deterministic.
 
-<<<<<<< codex/review-open-source-repo-for-ai-architecture
 ### Mental Model: Layered Rules (World → Law → Situation)
 
 If you're explaining this to developers or non-technical stakeholders, use this:
@@ -202,8 +240,6 @@ Use this section to show real runtime behavior and response time.
 4. **Level 4 — Spatial + Multi-Actor Governance**  
    Add zone opt-in, handshake negotiation, and dynamic policy composition.
 
-=======
->>>>>>> main
 ---
 
 ## The Product: Three Screens

package/dist/{chunk-AEVT7DSZ.js → chunk-MC6O5GV5.js}

@@ -1,6 +1,12 @@
 import {
   getLens
 } from "./chunk-VGFDMPVB.js";
+import {
+  loadWorld
+} from "./chunk-I4RTIMLX.js";
+import {
+  evaluateGuard
+} from "./chunk-ZAF6JH23.js";
 
 // src/radiant/core/prompt.ts
 function composeSystemPrompt(worldmodelContent, lens) {
@@ -139,17 +145,30 @@ function resolveLens(id) {
 }
 
 // src/radiant/core/scopes.ts
-function parseRepoScope(scope) {
+function parseScope(scope) {
   const cleaned = scope.replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/$/, "");
-  const parts = cleaned.split("/");
-  if (parts.length < 2 || !parts[0] || !parts[1]) {
+  const parts = cleaned.split("/").filter(Boolean);
+  if (parts.length === 0 || !parts[0]) {
+    throw new Error(
+      `Cannot parse scope: "${scope}". Expected "owner/repo" or "owner".`
+    );
+  }
+  if (parts.length === 1) {
+    return { type: "org", owner: parts[0] };
+  }
+  return { type: "repo", owner: parts[0], repo: parts[1] };
+}
+function parseRepoScope(scope) {
+  const parsed = parseScope(scope);
+  if (parsed.type === "org") {
     throw new Error(
-      `Cannot parse repo scope: "${scope}". Expected "owner/repo" or a GitHub URL.`
+      `Expected "owner/repo" but got org-level scope "${parsed.owner}". Use parseScope() for org-level.`
     );
   }
-  return { owner: parts[0], repo: parts[1] };
+  return parsed;
 }
 function formatScope(scope) {
+  if (scope.type === "org") return `${scope.owner} (org)`;
   return `${scope.owner}/${scope.repo}`;
 }
 
@@ -333,12 +352,46 @@ async function fetchJSON(url, headers) {
   }
   return await res.json();
 }
+async function fetchGitHubOrgActivity(scope, token, options = {}) {
+  const perPage = options.perPage ?? 100;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const repos = await fetchJSON(
+    `https://api.github.com/orgs/${scope.owner}/repos?sort=pushed&direction=desc&per_page=${perPage}`,
+    headers
+  );
+  const windowDays = options.windowDays ?? 14;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const activeRepos = repos.filter(
+    (r) => new Date(r.pushed_at) >= since
+  );
+  const cappedRepos = activeRepos.slice(0, 10);
+  const allEvents = [];
+  const repoNames = [];
+  for (const repo of cappedRepos) {
+    const [owner, repoName] = repo.full_name.split("/");
+    try {
+      const repoScope = { type: "repo", owner, repo: repoName };
+      const events = await fetchGitHubActivity(repoScope, token, options);
+      allEvents.push(...events);
+      if (events.length > 0) repoNames.push(repo.full_name);
+    } catch {
+    }
+  }
+  allEvents.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return { events: allEvents, repos: repoNames };
+}
 function createMockGitHubAdapter(fixedEvents) {
   return async () => fixedEvents;
 }
 
 // src/radiant/adapters/exocortex.ts
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
 import { join, resolve } from "path";
 function readExocortex(dirPath) {
   const dir = resolve(dirPath);
@@ -409,6 +462,46 @@ ${ctx.methods}`);
   }
   return sections.join("\n\n");
 }
+function readTeamExocortices(teamDir) {
+  const dir = resolve(teamDir);
+  if (!existsSync(dir)) return [];
+  const entries = readdirSync(dir);
+  const results = [];
+  for (const entry of entries) {
+    const entryPath = join(dir, entry);
+    try {
+      const stat = statSync(entryPath);
+      if (stat.isDirectory()) {
+        const ctx = readExocortex(entryPath);
+        if (ctx.filesLoaded > 0) {
+          results.push({ name: entry, context: ctx });
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function formatTeamExocorticesForPrompt(team) {
+  if (team.length === 0) return "";
+  const sections = [
+    "## Team Intent (cross-exocortex read)",
+    "",
+    `Reading ${team.length} team members' exocortices. Compare each person's`,
+    "stated intent against the observed activity AND against each other.",
+    "Surface: duplicate focus, missing coverage, silent pivots,",
+    "and areas where no one is carrying the work.",
+    ""
+  ];
+  for (const { name, context } of team) {
+    sections.push(`### ${name}`);
+    if (context.attention) sections.push(`**Attention:** ${context.attention.split("\n")[0]}`);
+    if (context.goals) sections.push(`**Goals:** ${context.goals.split("\n").slice(0, 3).join("; ")}`);
+    if (context.sprint) sections.push(`**Sprint:** ${context.sprint.split("\n").slice(0, 3).join("; ")}`);
+    sections.push("");
+  }
+  return sections.join("\n");
+}
 function summarizeExocortex(ctx) {
   if (ctx.filesLoaded === 0) return "no exocortex files found";
   const loaded = [];
@@ -421,6 +514,305 @@ function summarizeExocortex(ctx) {
   return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
 }
 
+// src/radiant/memory/palace.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync as readdirSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+function writeRead(exocortexDir, frontmatter, text) {
+  const dir = resolve2(exocortexDir, "radiant", "reads");
+  mkdirSync(dir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const filename = `${date}.md`;
+  const filepath = join2(dir, filename);
+  const content = `${frontmatter}
+
+${text}
+`;
+  writeFileSync(filepath, content, "utf-8");
+  return filepath;
+}
+function updateKnowledge(exocortexDir, persistence, options) {
+  const dir = resolve2(exocortexDir, "radiant");
+  mkdirSync(dir, { recursive: true });
+  const filepath = join2(dir, "knowledge.md");
+  const totalReads = options?.totalReads ?? 0;
+  const existingUntriggered = loadUntriggeredCounts(filepath);
+  const lines = [
+    "# Radiant \u2014 Accumulated Behavioral Knowledge",
+    "",
+    `Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}`,
+    `Total reads: ${totalReads}`,
+    "",
+    "---",
+    "",
+    "## Evolution proposals",
+    ""
+  ];
+  const addCandidates = persistence.filter((p) => p.occurrences >= 3);
+  if (addCandidates.length > 0) {
+    lines.push("### Consider adding");
+    lines.push("");
+    lines.push("These candidate patterns keep recurring. They are not yet in the worldmodel.");
+    lines.push("If they represent real behavioral patterns worth tracking, add them.");
+    lines.push("If they were temporary, dismiss them.");
+    lines.push("");
+    for (const p of addCandidates) {
+      lines.push(
+        `- **${p.name}** \u2014 observed ${p.occurrences} times (${p.dates.join(", ")}). Add to auki-strategy.worldmodel.md \u2192 Evolution Layer \u2192 Drift Behaviors (if concerning) or Aligned Behaviors (if healthy).`
+      );
+    }
+    lines.push("");
+  }
+  if (options?.declaredItems && options.declaredItems.length > 0) {
+    const triggered = new Set(options.triggeredItems ?? []);
+    const removeCandidates = [];
+    for (const item of options.declaredItems) {
+      if (!triggered.has(item.name)) {
+        const prior = existingUntriggered.get(item.name) ?? 0;
+        const count = prior + 1;
+        existingUntriggered.set(item.name, count);
+        if (count >= 4) {
+          removeCandidates.push({ item, weeksSilent: count });
+        }
+      } else {
+        existingUntriggered.set(item.name, 0);
+      }
+    }
+    if (removeCandidates.length > 0) {
+      lines.push("### Consider removing");
+      lines.push("");
+      lines.push("These items are declared in the worldmodel but haven't triggered in multiple reads.");
+      lines.push("Either the team has internalized them (the rule is redundant) or they haven't been tested.");
+      lines.push("A lean worldmodel with 5 sharp invariants is stronger than a bloated one with 20.");
+      lines.push("");
+      for (const { item, weeksSilent } of removeCandidates) {
+        lines.push(
+          `- **${item.name}** (${item.type}) \u2014 hasn't triggered in ${weeksSilent} reads. Internalized or untested? Review whether it still earns its place.`
+        );
+      }
+      lines.push("");
+    }
+  }
+  if (options?.triggeredItems && options.triggeredItems.length > 0) {
+    lines.push("### Keep (recently active)");
+    lines.push("");
+    lines.push("These worldmodel items triggered governance in the most recent read. They're earning their place.");
+    lines.push("");
+    for (const name of options.triggeredItems) {
+      lines.push(`- **${name}** \u2014 triggered this read. Holding.`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## Pattern persistence (all observed)");
+  lines.push("");
+  for (const p of persistence) {
+    const status = p.occurrences >= 4 ? "**persistent**" : p.occurrences >= 2 ? "recurring" : "observed once";
+    lines.push(`### ${p.name}`);
+    lines.push(`- Status: ${status}`);
+    lines.push(`- Observed ${p.occurrences} time${p.occurrences > 1 ? "s" : ""}: ${p.dates.join(", ")}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("<!-- untriggered_counts (machine-readable, do not edit)");
+  for (const [name, count] of existingUntriggered.entries()) {
+    lines.push(`${name}=${count}`);
+  }
+  lines.push("-->");
+  writeFileSync(filepath, lines.join("\n"), "utf-8");
+  return filepath;
+}
+function loadUntriggeredCounts(filepath) {
+  const counts = /* @__PURE__ */ new Map();
+  if (!existsSync2(filepath)) return counts;
+  try {
+    const content = readFileSync2(filepath, "utf-8");
+    const match = content.match(
+      /<!-- untriggered_counts[\s\S]*?-->/
+    );
+    if (match) {
+      const lines = match[0].split("\n");
+      for (const line of lines) {
+        const eq = line.match(/^([^=]+)=(\d+)$/);
+        if (eq) {
+          counts.set(eq[1], parseInt(eq[2], 10));
+        }
+      }
+    }
+  } catch {
+  }
+  return counts;
+}
+function loadPriorReads(exocortexDir) {
+  const dir = resolve2(exocortexDir, "radiant", "reads");
+  if (!existsSync2(dir)) return [];
+  const files = readdirSync2(dir).filter((f) => f.endsWith(".md")).sort();
+  const reads = [];
+  for (const filename of files) {
+    const filepath = join2(dir, filename);
+    const content = readFileSync2(filepath, "utf-8");
+    const date = filename.replace(".md", "");
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    const frontmatter = fmMatch ? fmMatch[1] : "";
+    const patternNames = [];
+    const nameMatches = frontmatter.matchAll(/- name: ["']?([^"'\n]+)["']?/g);
+    for (const m of nameMatches) {
+      patternNames.push(m[1].trim());
+    }
+    reads.push({ date, filename, patternNames, frontmatter });
+  }
+  return reads;
+}
+function computePersistence(priorReads, currentPatternNames) {
+  const allPatterns = /* @__PURE__ */ new Map();
+  for (const read of priorReads) {
+    for (const name of read.patternNames) {
+      const dates = allPatterns.get(name) ?? [];
+      if (!dates.includes(read.date)) dates.push(read.date);
+      allPatterns.set(name, dates);
+    }
+  }
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  for (const name of currentPatternNames) {
+    const dates = allPatterns.get(name) ?? [];
+    if (!dates.includes(today)) dates.push(today);
+    allPatterns.set(name, dates);
+  }
+  return Array.from(allPatterns.entries()).map(([name, dates]) => ({
+    name,
+    occurrences: dates.length,
+    dates: dates.sort()
+  })).sort((a, b) => b.occurrences - a.occurrences);
+}
+function formatPriorReadsForPrompt(priorReads) {
+  if (priorReads.length === 0) return "";
+  const lines = [
+    "## Prior Radiant reads (history)",
+    "",
+    `Radiant has run ${priorReads.length} time${priorReads.length > 1 ? "s" : ""} before on this scope.`,
+    "If you see patterns that appeared in prior reads, note their persistence.",
+    "Patterns that recur across 3+ reads are strong candidates for declaration in the strategy file.",
+    ""
+  ];
+  for (const read of priorReads.slice(-4)) {
+    lines.push(`### Read from ${read.date}`);
+    if (read.patternNames.length > 0) {
+      lines.push(`Patterns observed: ${read.patternNames.join(", ")}`);
+    } else {
+      lines.push("No patterns extracted from frontmatter.");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/radiant/core/governance.ts
+async function auditGovernance(events, worldPath) {
+  let world;
+  try {
+    world = await loadWorld(worldPath);
+  } catch {
+    return emptyAudit(events.length, "Could not load compiled worldmodel for governance audit.");
+  }
+  const verdicts = [];
+  for (const ce of events) {
+    const intent = ce.event.content?.slice(0, 500) || ce.event.kind || "activity";
+    const scope = ce.event.metadata?.scope || void 0;
+    try {
+      const result = evaluateGuard(
+        {
+          intent,
+          scope,
+          actionCategory: mapKindToCategory(ce.event.kind)
+        },
+        world
+      );
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: result.status,
+        reason: result.reason,
+        ruleId: result.ruleId,
+        warning: result.warning
+      });
+    } catch {
+      verdicts.push({
+        eventId: ce.event.id,
+        domain: ce.domain,
+        status: "ALLOW",
+        reason: "guard evaluation skipped (error)"
+      });
+    }
+  }
+  const human = bucketVerdicts(verdicts.filter((v) => v.domain === "life"));
+  const cyber = bucketVerdicts(verdicts.filter((v) => v.domain === "cyber"));
+  const joint = bucketVerdicts(verdicts.filter((v) => v.domain === "joint"));
+  const summary = buildSummary(human, cyber, joint, events.length);
+  return {
+    totalEvents: events.length,
+    human,
+    cyber,
+    joint,
+    summary
+  };
+}
+function bucketVerdicts(verdicts) {
+  const nonAllow = verdicts.filter((v) => v.status !== "ALLOW");
+  return {
+    allow: verdicts.filter((v) => v.status === "ALLOW").length,
+    modify: verdicts.filter((v) => v.status === "MODIFY").length,
+    block: verdicts.filter((v) => v.status === "BLOCK").length,
+    details: nonAllow
+  };
+}
+function buildSummary(human, cyber, joint, total) {
+  const humanTriggered = human.modify + human.block;
+  const cyberTriggered = cyber.modify + cyber.block;
+  const jointTriggered = joint.modify + joint.block;
+  const totalTriggered = humanTriggered + cyberTriggered + jointTriggered;
+  if (totalTriggered === 0) {
+    return `${total} events evaluated. All passed. The cocoon held \u2014 no governance triggered.`;
+  }
+  const parts = [];
+  parts.push(`${total} events evaluated. ${totalTriggered} triggered governance.`);
+  if (humanTriggered > 0) {
+    parts.push(`Human side: ${humanTriggered} (${human.block} blocked, ${human.modify} modified).`);
+  }
+  if (cyberTriggered > 0) {
+    parts.push(`AI side: ${cyberTriggered} (${cyber.block} blocked, ${cyber.modify} modified).`);
+  }
+  if (jointTriggered > 0) {
+    parts.push(`Joint work: ${jointTriggered} (${joint.block} blocked, ${joint.modify} modified).`);
+  }
+  if (humanTriggered > 0 && cyberTriggered > 0) {
+    const ratio = humanTriggered / cyberTriggered;
+    if (ratio > 2) {
+      parts.push("Human side is testing the frame more than AI. Either the worldmodel needs calibrating for human workflows, or humans are genuinely drifting.");
+    } else if (ratio < 0.5) {
+      parts.push("AI side is testing the frame more than humans. Check whether the AI's output patterns match the declared invariants.");
+    } else {
+      parts.push("Roughly balanced between human and AI \u2014 both sides are testing the frame.");
+    }
+  }
+  return parts.join(" ");
+}
+function mapKindToCategory(kind) {
+  if (!kind) return "other";
+  if (kind.includes("commit") || kind.includes("merge")) return "write";
+  if (kind.includes("review") || kind.includes("comment")) return "read";
+  return "other";
+}
+function emptyAudit(total, reason) {
+  return {
+    totalEvents: total,
+    human: { allow: 0, modify: 0, block: 0, details: [] },
+    cyber: { allow: 0, modify: 0, block: 0, details: [] },
+    joint: { allow: 0, modify: 0, block: 0, details: [] },
+    summary: reason
+  };
+}
+
 // src/radiant/core/domain.ts
 function isLifeSide(k) {
   return k === "human" || k === "unknown";
@@ -690,6 +1082,14 @@ ${jargonTable}
 
 For example: don't say "update the worldmodel." Say "add a line to your strategy file."
 
+## When the same invariant keeps firing
+
+If the prior read history or the current evidence shows the same worldmodel invariant being triggered repeatedly (by the same side \u2014 human or AI), name it in MEANING and ask the real question:
+
+  "This invariant has been tested N times across M reads. Always on the [human/AI] side. Either the team needs alignment on WHY this rule exists \u2014 or the team is telling you something the worldmodel hasn't absorbed yet."
+
+Don't just say "invariant held." Say what it means that people keep pushing against the same wall.
+
 ## Health is a valid read
 
 If the activity is healthy and aligned with the worldmodel, SAY SO. Don't fabricate problems. Over-prescription is a voice failure. Legitimate outputs include:
@@ -718,7 +1118,7 @@ Only recommend a move when the evidence actually calls for one.
     }
   ],
   "meaning": "3-5 sentences. Weave the patterns into ONE strategic thesis. Compress. The reader should finish this paragraph and understand the one thing that matters most in this read. Plain English \u2014 no system jargon.",
-  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. Examples: 'Force cross-module ownership this sprint.' / 'Nothing's broken. Keep shipping.' / 'If you want future reads to track this pattern by name, add a line to your strategy file.'"
+  "move": "1-3 direct imperatives, OR explicit 'nothing to act on' if the read is healthy. Do not fabricate urgency. When a candidate pattern has high confidence (>0.6), tell the reader EXACTLY where to declare it: 'If you want Radiant to track [pattern_name] over time, add it to auki-strategy.worldmodel.md under Evolution Layer \u2192 Drift Behaviors (or Aligned Behaviors if it is positive). If you don't, Radiant will rediscover it from scratch next run.' Be specific about the file and section \u2014 don't make them guess."
 }
 \`\`\`
 
@@ -874,6 +1274,27 @@ Lens:   ${input.lens.name}`
     `  Composite:                 ${formatScore(input.scores.R)}`
   ].join("\n");
   sections.push(alignBlock);
+  if (input.governance && input.governance.totalEvents > 0) {
+    const gov = input.governance;
+    const govLines = ["GOVERNANCE", "", `  ${gov.summary}`];
+    const showSide = (label, side) => {
+      if (side.allow + side.modify + side.block === 0) return;
+      govLines.push("");
+      govLines.push(`  ${label}:`);
+      govLines.push(`    ${side.allow} ALLOW \xB7 ${side.modify} MODIFY \xB7 ${side.block} BLOCK`);
+      for (const d of side.details.slice(0, 3)) {
+        const reason = d.reason ? ` \u2192 ${d.reason}` : "";
+        govLines.push(`    ${d.status}: ${d.eventId}${reason}`);
+      }
+      if (side.details.length > 3) {
+        govLines.push(`    ... and ${side.details.length - 3} more`);
+      }
+    };
+    showSide("Human side", gov.human);
+    showSide("AI side", gov.cyber);
+    showSide("Human\u2013AI joint", gov.joint);
+    sections.push(govLines.join("\n"));
+  }
   sections.push(renderDepth(input.priorReadCount ?? 0, input.windowDays));
   return sections.join("\n\n");
 }
@@ -1043,14 +1464,31 @@ async function emergent(input) {
   const windowDays = input.windowDays ?? 14;
   let statedIntent;
   let exocortexContext;
+  let priorReadContext = "";
   if (input.exocortexPath) {
     exocortexContext = readExocortex(input.exocortexPath);
     const formatted = formatExocortexForPrompt(exocortexContext);
     if (formatted) statedIntent = formatted;
+    const priorReads = loadPriorReads(input.exocortexPath);
+    if (priorReads.length > 0) {
+      priorReadContext = formatPriorReadsForPrompt(priorReads);
+    }
+  }
+  let events;
+  let orgRepos;
+  if (input.scope.type === "org") {
+    const orgResult = await fetchGitHubOrgActivity(
+      input.scope,
+      input.githubToken,
+      { windowDays }
+    );
+    events = orgResult.events;
+    orgRepos = orgResult.repos;
+  } else {
+    events = await fetchGitHubActivity(input.scope, input.githubToken, {
+      windowDays
+    });
   }
-  const events = await fetchGitHubActivity(input.scope, input.githubToken, {
-    windowDays
-  });
   const classified = classifyEvents(events);
   const signals = extractSignals(classified);
   const scores = computeScores(signals, input.worldmodelContent !== "");
@@ -1061,11 +1499,18 @@ async function emergent(input) {
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
-    statedIntent
+    statedIntent: statedIntent ? statedIntent + (priorReadContext ? "\n\n" + priorReadContext : "") : priorReadContext || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
   const allDescriptions = rewrittenPatterns.map((p) => p.description).join("\n");
   const voiceViolations = checkForbiddenPhrases(lens, allDescriptions);
+  let governance;
+  if (input.worldPath) {
+    try {
+      governance = await auditGovernance(classified, input.worldPath);
+    } catch {
+    }
+  }
   const rendered = render({
     scope: input.scope,
     windowDays,
@@ -1075,8 +1520,27 @@ async function emergent(input) {
     scores,
     lens,
     meaning: meaning || void 0,
-    move: move || void 0
+    move: move || void 0,
+    governance
   });
+  if (input.exocortexPath) {
+    try {
+      const readPath = writeRead(input.exocortexPath, rendered.frontmatter, rendered.text);
+      const priorReads = loadPriorReads(input.exocortexPath);
+      const currentPatternNames = rewrittenPatterns.map((p) => p.name);
+      const persistence = computePersistence(priorReads, currentPatternNames);
+      const triggeredItems = governance ? [
+        ...governance.human.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.cyber.details.map((d) => d.ruleId).filter(Boolean),
+        ...governance.joint.details.map((d) => d.ruleId).filter(Boolean)
+      ] : [];
+      updateKnowledge(input.exocortexPath, persistence, {
+        triggeredItems,
+        totalReads: priorReads.length + 1
+      });
+    } catch {
+    }
+  }
   return {
     text: rendered.text,
     frontmatter: rendered.frontmatter,
@@ -1180,13 +1644,23 @@ export {
   composeSystemPrompt,
   checkForbiddenPhrases,
   think,
+  parseScope,
   parseRepoScope,
   formatScope,
   fetchGitHubActivity,
+  fetchGitHubOrgActivity,
   createMockGitHubAdapter,
   readExocortex,
   formatExocortexForPrompt,
+  readTeamExocortices,
+  formatTeamExocorticesForPrompt,
   summarizeExocortex,
+  writeRead,
+  updateKnowledge,
+  loadPriorReads,
+  computePersistence,
+  formatPriorReadsForPrompt,
+  auditGovernance,
   classifyActorDomain,
   classifyEvents,
   extractSignals,