@neuroverseos/governance 0.6.0 → 0.7.0

package/dist/chunk-T6EQ7ZBG.js

@@ -0,0 +1,1571 @@
+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) {
+  const sections = [];
+  sections.push(
+    `## Worldmodel
+
+You are operating inside a governed environment. The worldmodel below
+defines the invariants, signals, decision priorities, and behavioral
+expectations for this organization. Every response you produce must
+be grounded in this worldmodel.
+
+` + worldmodelContent
+  );
+  const frame = lens.primary_frame;
+  const questionsBlock = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+  const overlapsBlock = frame.overlaps.map(
+    (o) => `- ${o.domains[0]} + ${o.domains[1]} = **${o.emergent_state}**: ${o.description}`
+  ).join("\n");
+  sections.push(
+    `## How to Think (Analytical Frame: ${lens.name})
+
+${frame.scoring_rubric}
+
+### Evaluation questions to reason through
+
+${questionsBlock}
+
+### Overlap emergent states
+
+${overlapsBlock}
+
+### Center identity
+
+When all dimensions integrate fully: **${frame.center_identity}**. Surface this sparingly \u2014 only when the integration is genuinely complete.`
+  );
+  const vocabPreferred = Object.entries(lens.vocabulary.preferred).map(([generic, native]) => `- "${generic}" \u2192 **${native}**`).join("\n");
+  const vocabArchitecture = lens.vocabulary.architecture.map((t) => `\`${t}\``).join(", ");
+  const vocabProperNouns = lens.vocabulary.proper_nouns.map((n) => `**${n}**`).join(", ");
+  const strategicBlock = lens.strategic_patterns.map((p) => `- ${p}`).join("\n");
+  sections.push(
+    `## How to Speak (Voice: ${lens.name})
+
+Register: ${lens.voice.register}
+
+Rules:
+- Active voice: ${lens.voice.active_voice}
+- Named specificity (people, places, numbers): ${lens.voice.specificity}
+- Hype vocabulary: ${lens.voice.hype_vocabulary}
+- Hedging / qualified phrasing: ${lens.voice.hedging}
+- Playfulness: ${lens.voice.playfulness}
+- Close with strategic frame: ${lens.voice.close_with_strategic_frame}
+- Honesty about failure: ${lens.voice.honesty_about_failure}
+
+### Output translation discipline
+
+${lens.voice.output_translation}
+
+### Vocabulary
+
+Proper nouns (use literally): ${vocabProperNouns}
+
+Preferred term substitutions:
+${vocabPreferred}
+
+Architecture vocabulary: ${vocabArchitecture}
+
+### Strategic decision patterns
+
+When recommending action, these patterns reflect how this organization resolves tradeoffs:
+
+${strategicBlock}`
+  );
+  const forbiddenBlock = lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
+  sections.push(
+    `## Guardrails
+
+Do NOT use any of these phrases in your response. If you catch yourself
+reaching for one, rephrase in direct, active, specific language instead.
+
+${forbiddenBlock}
+
+If your response would violate a worldmodel invariant, state the conflict
+explicitly and propose an alternative that honors the invariant.`
+  );
+  return sections.join("\n\n---\n\n");
+}
+
+// src/radiant/core/voice-check.ts
+function checkForbiddenPhrases(lens, text) {
+  const lower = text.toLowerCase();
+  const violations = [];
+  for (const phrase of lens.forbidden_phrases) {
+    const phraseLower = phrase.toLowerCase();
+    let pos = 0;
+    while (true) {
+      const idx = lower.indexOf(phraseLower, pos);
+      if (idx === -1) break;
+      violations.push({ phrase, offset: idx });
+      pos = idx + phraseLower.length;
+    }
+  }
+  violations.sort((a, b) => a.offset - b.offset);
+  return violations;
+}
+
+// src/radiant/commands/think.ts
+async function think(input) {
+  const lens = resolveLens(input.lensId);
+  const systemPrompt = composeSystemPrompt(input.worldmodelContent, lens);
+  const response = await input.ai.complete(systemPrompt, input.query);
+  const voiceViolations = checkForbiddenPhrases(lens, response);
+  return {
+    response,
+    lens: lens.name,
+    voiceViolations,
+    voiceClean: voiceViolations.length === 0,
+    systemPrompt
+  };
+}
+function resolveLens(id) {
+  const lens = getLens(id);
+  if (!lens) {
+    const available = Object.keys(
+      // Inline import-free way to list. At runtime, getLens returns from
+      // the same LENSES record — we just need the keys for the error message.
+      // We re-import getLens from lenses/index which exposes listLenses, but
+      // since we already have lens===undefined we know the id was wrong.
+      {}
+    );
+    throw new Error(
+      `Lens "${id}" not found. Check the id or register the lens in src/radiant/lenses/index.ts.`
+    );
+  }
+  return lens;
+}
+
+// src/radiant/core/scopes.ts
+function parseRepoScope(scope) {
+  const cleaned = scope.replace(/^https?:\/\//, "").replace(/^github\.com\//, "").replace(/\.git$/, "").replace(/\/$/, "");
+  const parts = cleaned.split("/");
+  if (parts.length < 2 || !parts[0] || !parts[1]) {
+    throw new Error(
+      `Cannot parse repo scope: "${scope}". Expected "owner/repo" or a GitHub URL.`
+    );
+  }
+  return { owner: parts[0], repo: parts[1] };
+}
+function formatScope(scope) {
+  return `${scope.owner}/${scope.repo}`;
+}
+
+// src/radiant/adapters/github.ts
+async function fetchGitHubActivity(scope, token, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const perPage = options.perPage ?? 100;
+  const since = new Date(
+    Date.now() - windowDays * 24 * 60 * 60 * 1e3
+  ).toISOString();
+  const base = `https://api.github.com/repos/${formatScope(scope)}`;
+  const headers = {
+    Authorization: `token ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "neuroverseos-radiant"
+  };
+  const events = [];
+  const [commits, prs, comments] = await Promise.all([
+    fetchJSON(
+      `${base}/commits?since=${since}&per_page=${perPage}`,
+      headers
+    ),
+    fetchJSON(
+      `${base}/pulls?state=all&sort=updated&direction=desc&per_page=${perPage}`,
+      headers
+    ),
+    fetchJSON(
+      `${base}/issues/comments?since=${since}&per_page=${perPage}&sort=updated&direction=desc`,
+      headers
+    )
+  ]);
+  for (const c of commits) {
+    events.push(mapCommit(c, scope));
+  }
+  const sinceDate = new Date(since);
+  for (const pr of prs) {
+    if (new Date(pr.updated_at) >= sinceDate) {
+      events.push(mapPR(pr, scope));
+    }
+  }
+  for (const comment of comments) {
+    events.push(mapComment(comment, scope));
+  }
+  events.sort(
+    (a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)
+  );
+  return events;
+}
+function mapCommit(c, scope) {
+  const actor = mapUser(c.author, c.commit.author.name);
+  const coActors = extractCoAuthors(c.commit.message);
+  return {
+    id: `commit-${c.sha.slice(0, 8)}`,
+    timestamp: c.commit.author.date,
+    actor,
+    coActors: coActors.length > 0 ? coActors : void 0,
+    kind: "commit",
+    content: c.commit.message,
+    metadata: {
+      scope: formatScope(scope),
+      sha: c.sha
+    }
+  };
+}
+function mapPR(pr, scope) {
+  const event = {
+    id: `pr-${pr.number}`,
+    timestamp: pr.created_at,
+    actor: mapUser(pr.user),
+    kind: pr.merged_at ? "pr_merged" : pr.state === "open" ? "pr_opened" : "pr_closed",
+    content: `${pr.title}
+
+${pr.body ?? ""}`.trim(),
+    metadata: {
+      scope: formatScope(scope),
+      pr_number: pr.number,
+      state: pr.state,
+      merged_at: pr.merged_at
+    }
+  };
+  if (pr.merged_by && pr.merged_by.login !== pr.user.login) {
+    event.actor = mapUser(pr.merged_by);
+    event.kind = "pr_merged";
+    event.timestamp = pr.merged_at ?? pr.updated_at;
+    event.respondsTo = {
+      eventId: `pr-${pr.number}-opened`,
+      actor: mapUser(pr.user)
+    };
+  }
+  return event;
+}
+function mapComment(comment, scope) {
+  const issueMatch = comment.issue_url.match(/\/issues\/(\d+)$/);
+  const issueNumber = issueMatch ? issueMatch[1] : "unknown";
+  const event = {
+    id: `comment-${comment.id}`,
+    timestamp: comment.created_at,
+    actor: mapUser(comment.user),
+    kind: "comment",
+    content: comment.body,
+    respondsTo: {
+      eventId: `pr-${issueNumber}`,
+      actor: { id: "unknown", kind: "unknown" }
+    },
+    metadata: {
+      scope: formatScope(scope),
+      issue_number: issueNumber
+    }
+  };
+  return event;
+}
+var KNOWN_AI_LOGINS = /* @__PURE__ */ new Set([
+  "github-actions[bot]",
+  "dependabot[bot]",
+  "renovate[bot]",
+  "copilot"
+]);
+var KNOWN_AI_CO_AUTHOR_NAMES = /* @__PURE__ */ new Set([
+  "claude",
+  "copilot",
+  "cursor",
+  "codeium",
+  "tabnine",
+  "codex"
+]);
+function mapUser(ghUser, fallbackName) {
+  if (!ghUser) {
+    return {
+      id: fallbackName ?? "unknown",
+      kind: "unknown",
+      name: fallbackName
+    };
+  }
+  let kind = "human";
+  if (ghUser.type === "Bot" || ghUser.login.endsWith("[bot]")) {
+    kind = "bot";
+  }
+  if (KNOWN_AI_LOGINS.has(ghUser.login.toLowerCase())) {
+    kind = "bot";
+  }
+  return {
+    id: ghUser.login,
+    kind,
+    name: ghUser.login
+  };
+}
+function extractCoAuthors(message) {
+  const coAuthors = [];
+  const lines = message.split("\n");
+  for (const line of lines) {
+    const match = line.match(
+      /^Co-authored-by:\s*(.+?)\s*<([^>]*)>/i
+    );
+    if (match) {
+      const name = match[1].trim().toLowerCase();
+      const isAI = KNOWN_AI_CO_AUTHOR_NAMES.has(name) || [...KNOWN_AI_CO_AUTHOR_NAMES].some((ai) => name.includes(ai));
+      coAuthors.push({
+        id: match[2] || name,
+        kind: isAI ? "ai" : "human",
+        name: match[1].trim()
+      });
+    }
+  }
+  return coAuthors;
+}
+async function fetchJSON(url, headers) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) {
+    if (res.status === 404) return [];
+    if (res.status === 403) {
+      const body = await res.text();
+      if (body.includes("rate limit")) {
+        throw new Error(
+          `GitHub API rate limit exceeded. Wait or use a token with higher limits.`
+        );
+      }
+    }
+    throw new Error(
+      `GitHub API error ${res.status} for ${url}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  return await res.json();
+}
+function createMockGitHubAdapter(fixedEvents) {
+  return async () => fixedEvents;
+}
+
+// src/radiant/adapters/exocortex.ts
+import { readFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+function readExocortex(dirPath) {
+  const dir = resolve(dirPath);
+  let filesLoaded = 0;
+  function tryRead(...paths) {
+    for (const p of paths) {
+      const full = join(dir, p);
+      if (existsSync(full)) {
+        try {
+          const content = readFileSync(full, "utf-8").trim();
+          if (content) {
+            filesLoaded++;
+            return content;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  const ctx = {
+    attention: tryRead("attention.md"),
+    goals: tryRead("goals.md"),
+    identity: tryRead("identity.md"),
+    sprint: tryRead("sprint.md", "src/sprint.md"),
+    organization: tryRead("org/organization.md", "org/src/organization.md"),
+    methods: tryRead("org/methods.md", "org/src/methods.md"),
+    source: dir,
+    filesLoaded
+  };
+  return ctx;
+}
+function formatExocortexForPrompt(ctx) {
+  if (ctx.filesLoaded === 0) return "";
+  const sections = [];
+  sections.push(
+    "## Stated Intent (from exocortex)\n\nThe following is what the person/team SAYS they are doing, focused on, and working toward. Compare this against the ACTUAL activity from GitHub. Where stated intent and observed behavior diverge, that gap is the most valuable signal in this read. Name it directly."
+  );
+  if (ctx.attention) {
+    sections.push(`### Current attention
+
+${ctx.attention}`);
+  }
+  if (ctx.goals) {
+    sections.push(`### Goals
+
+${ctx.goals}`);
+  }
+  if (ctx.sprint) {
+    sections.push(`### Sprint focus
+
+${ctx.sprint}`);
+  }
+  if (ctx.identity) {
+    sections.push(`### Identity and values
+
+${ctx.identity}`);
+  }
+  if (ctx.organization) {
+    sections.push(`### Organization
+
+${ctx.organization}`);
+  }
+  if (ctx.methods) {
+    sections.push(`### Methods
+
+${ctx.methods}`);
+  }
+  return sections.join("\n\n");
+}
+function summarizeExocortex(ctx) {
+  if (ctx.filesLoaded === 0) return "no exocortex files found";
+  const loaded = [];
+  if (ctx.attention) loaded.push("attention");
+  if (ctx.goals) loaded.push("goals");
+  if (ctx.sprint) loaded.push("sprint");
+  if (ctx.identity) loaded.push("identity");
+  if (ctx.organization) loaded.push("org");
+  if (ctx.methods) loaded.push("methods");
+  return `${loaded.join(", ")} (${ctx.filesLoaded} files)`;
+}
+
+// src/radiant/memory/palace.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, readdirSync, 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 = readdirSync(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";
+}
+function isCyberSide(k) {
+  return k === "ai" || k === "bot";
+}
+function crossesBoundary(a, b) {
+  return isLifeSide(a) && isCyberSide(b) || isCyberSide(a) && isLifeSide(b);
+}
+function classifyActorDomain(event) {
+  const primaryKind = event.actor.kind;
+  const coKinds = (event.coActors ?? []).map((a) => a.kind);
+  const allKinds = [primaryKind, ...coKinds];
+  const hasLife = allKinds.some(isLifeSide);
+  const hasCyber = allKinds.some(isCyberSide);
+  if (hasLife && hasCyber) {
+    return "joint";
+  }
+  if (event.respondsTo && crossesBoundary(primaryKind, event.respondsTo.actor.kind)) {
+    return "joint";
+  }
+  return isCyberSide(primaryKind) ? "cyber" : "life";
+}
+
+// src/radiant/core/signals.ts
+function classifyEvents(events) {
+  return events.map((event) => ({
+    event,
+    domain: classifyActorDomain(event)
+  }));
+}
+function extractSignals(events, extractors = DEFAULT_SIGNAL_EXTRACTORS) {
+  const domains = ["life", "cyber", "joint"];
+  const out = [];
+  for (const extractor of extractors) {
+    for (const domain of domains) {
+      const r = extractor.extract(events, domain);
+      out.push({
+        id: extractor.id,
+        domain,
+        score: r.score,
+        eventCount: r.eventCount,
+        confidence: r.confidence
+      });
+    }
+  }
+  return out;
+}
+var ZERO = { score: 0, eventCount: 0, confidence: 0 };
+function inDomain(events, domain) {
+  return events.filter((e) => e.domain === domain);
+}
+function confidenceFromCount(count) {
+  return Math.min(1, count / 10);
+}
+function clamp100(n) {
+  if (n < 0) return 0;
+  if (n > 100) return 100;
+  return n;
+}
+var CLARITY_EXTRACTOR = {
+  id: "clarity",
+  description: "Informativeness of event content \u2014 commit messages, PR bodies, review text",
+  extract(events, domain) {
+    const sub = inDomain(events, domain);
+    if (sub.length === 0) return ZERO;
+    const totalScore = sub.reduce((acc, e) => {
+      const len = (e.event.content ?? "").length;
+      const norm = Math.min(len, 200) / 200;
+      return acc + norm * 100;
+    }, 0);
+    return {
+      score: clamp100(totalScore / sub.length),
+      eventCount: sub.length,
+      confidence: confidenceFromCount(sub.length)
+    };
+  }
+};
+var OWNERSHIP_EXTRACTOR = {
+  id: "ownership",
+  description: "Clarity of accountability \u2014 fraction of events with a known primary actor",
+  extract(events, domain) {
+    const sub = inDomain(events, domain);
+    if (sub.length === 0) return ZERO;
+    const attributed = sub.filter((e) => e.event.actor.kind !== "unknown").length;
+    return {
+      score: clamp100(attributed / sub.length * 100),
+      eventCount: sub.length,
+      confidence: confidenceFromCount(sub.length)
+    };
+  }
+};
+var FOLLOW_THROUGH_EXTRACTOR = {
+  id: "follow_through",
+  description: "Fraction of events that were followed up \u2014 i.e. referenced by a later event",
+  extract(events, domain) {
+    const sub = inDomain(events, domain);
+    if (sub.length === 0) return ZERO;
+    const referencedIds = /* @__PURE__ */ new Set();
+    for (const e of events) {
+      const ref = e.event.respondsTo?.eventId;
+      if (ref) referencedIds.add(ref);
+    }
+    const followedUp = sub.filter((e) => referencedIds.has(e.event.id)).length;
+    return {
+      score: clamp100(followedUp / sub.length * 100),
+      eventCount: sub.length,
+      confidence: confidenceFromCount(sub.length)
+    };
+  }
+};
+var ALIGNMENT_EXTRACTOR = {
+  id: "alignment",
+  description: "Coordination pressure \u2014 fraction of events that reference a prior event",
+  extract(events, domain) {
+    const sub = inDomain(events, domain);
+    if (sub.length === 0) return ZERO;
+    const referencing = sub.filter((e) => e.event.respondsTo !== void 0).length;
+    return {
+      score: clamp100(referencing / sub.length * 100),
+      eventCount: sub.length,
+      confidence: confidenceFromCount(sub.length)
+    };
+  }
+};
+var DECISION_MOMENTUM_EXTRACTOR = {
+  id: "decision_momentum",
+  description: "Rate of activity in this domain \u2014 events per day, capped at 10/day",
+  extract(events, domain) {
+    const sub = inDomain(events, domain);
+    if (sub.length === 0) return ZERO;
+    if (sub.length < 2) {
+      return {
+        score: 20,
+        // token non-zero score — single event = some motion
+        eventCount: sub.length,
+        confidence: confidenceFromCount(sub.length)
+      };
+    }
+    const ts = sub.map((e) => Date.parse(e.event.timestamp)).sort((a, b) => a - b);
+    const spanMs = ts[ts.length - 1] - ts[0];
+    const spanDays = Math.max(spanMs / (24 * 60 * 60 * 1e3), 1 / 24);
+    const perDay = sub.length / spanDays;
+    const normalized = Math.min(perDay, 10) / 10;
+    return {
+      score: clamp100(normalized * 100),
+      eventCount: sub.length,
+      confidence: confidenceFromCount(sub.length)
+    };
+  }
+};
+var DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
+  CLARITY_EXTRACTOR,
+  OWNERSHIP_EXTRACTOR,
+  FOLLOW_THROUGH_EXTRACTOR,
+  ALIGNMENT_EXTRACTOR,
+  DECISION_MOMENTUM_EXTRACTOR
+]);
+
+// src/radiant/types.ts
+var DEFAULT_EVIDENCE_GATE = { k: 3, c: 0.5 };
+function isScored(s) {
+  return typeof s === "number";
+}
+function isSentinel(s) {
+  return typeof s === "string";
+}
+
+// src/radiant/core/math.ts
+function isPresent(o, gate = DEFAULT_EVIDENCE_GATE) {
+  return o.eventCount >= gate.k && o.confidence >= gate.c;
+}
+function presenceAverage(items, gate = DEFAULT_EVIDENCE_GATE) {
+  const present = items.filter((i) => isPresent(i, gate));
+  if (present.length === 0) return "INSUFFICIENT_EVIDENCE";
+  const sum = present.reduce((acc, i) => acc + i.score, 0);
+  return sum / present.length;
+}
+function scoreLife(capability, gate = DEFAULT_EVIDENCE_GATE) {
+  return presenceAverage(capability.dimensions, gate);
+}
+function scoreCyber(capability, gate = DEFAULT_EVIDENCE_GATE) {
+  return presenceAverage(capability.dimensions, gate);
+}
+function scoreNeuroVerse(components, worldmodelLoaded, gate = DEFAULT_EVIDENCE_GATE) {
+  if (!worldmodelLoaded) return "UNAVAILABLE";
+  return presenceAverage(components, gate);
+}
+function scoreComposite(a_L, a_C, a_N) {
+  const available = [];
+  if (isScored(a_L)) available.push(a_L);
+  if (isScored(a_C)) available.push(a_C);
+  if (isScored(a_N)) available.push(a_N);
+  if (available.length === 0) return "INSUFFICIENT_EVIDENCE";
+  return available.reduce((a, b) => a + b, 0) / available.length;
+}
+
+// src/radiant/core/patterns.ts
+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 ?? []);
+  return {
+    patterns: parsed.patterns,
+    meaning: parsed.meaning,
+    move: parsed.move,
+    raw_ai_response: raw
+  };
+}
+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 frame = input.lens.primary_frame;
+  const evalQuestions = frame.evaluation_questions.map((q, i) => `${i + 1}. ${q}`).join("\n");
+  const forbiddenList = input.lens.forbidden_phrases.map((p) => `- "${p}"`).join("\n");
+  const jargonTable = Object.entries(input.lens.vocabulary.jargon_translations).map(([internal, plain]) => `  "${internal}" \u2192 "${plain}"`).join("\n");
+  return `You are a behavioral intelligence system reading team activity and producing a read for the reader who needs to act on it.
+
+## Context the reader has loaded
+
+${input.worldmodelContent}
+
+## What happened this window
+
+### Signal matrix (what Radiant measured)
+
+${signalSummary}
+
+### Recent events (sample)
+
+${eventSample}
+
+## How to reason
+
+Reason through these questions INTERNALLY \u2014 do not list them in your output:
+
+${evalQuestions}
+
+Scoring rubric: ${frame.scoring_rubric}
+
+${canonicalList}
+
+${input.statedIntent ? input.statedIntent + "\n" : ""}## Voice: speak like an Auki builder, not like a status report
+
+The reader wants to know **what this means and what to do**, not "what happened." Frame every observation as consequence + implication, not just description.
+
+Wrong voice (status report):
+  "Rapid deployment of complex technical architecture through composable commits."
+  "Signal extraction across life, cyber, and joint domains enables consistent behavioral analysis."
+  "Decision momentum scores suggest architectural delivery without corresponding strategic direction setting."
+
+Right voice (Auki builder):
+  "Shipping pace is high. The architecture is getting ahead of strategic decisions \u2014 velocity without a declared target."
+  "Every pattern is new. Nothing is being tracked by name yet. That's fine for now; it becomes a problem when patterns repeat and you still don't have vocabulary for them."
+  "The work is converging across three modules. The story of HOW they compose isn't being told yet."
+
+The difference: consequence in plain English, not observation in system vocabulary.
+
+## Translate internal jargon to plain English
+
+Readers don't know Radiant's vocabulary. Before ANY description appears in your output, translate these:
+
+${jargonTable}
+
+For example: don't say "update the worldmodel." Say "add a line to your strategy file."
+
+## 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:
+
+  "Nothing's broken. Keep shipping."
+  "This is what healthy looks like \u2014 the invariants are holding."
+  "Nothing here needs action."
+
+Only recommend a move when the evidence actually calls for one.
+
+## Output schema \u2014 JSON object
+
+\`\`\`json
+{
+  "patterns": [
+    {
+      "name": "pattern_name_snake_case",
+      "type": "canonical" | "candidate",
+      "description": "Consequence-framed, plain-English, 1-2 sentences. The reader understands why this matters, not just what you observed.",
+      "evidence": {
+        "signals": ["signal_id.domain", ...],
+        "events": ["event_id", ...],
+        "cited_invariant": "invariant_name_or_null"
+      },
+      "confidence": 0.0 to 1.0
+    }
+  ],
+  "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. 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."
+}
+\`\`\`
+
+## Hard rules
+
+- Every signal you cite MUST appear in the signal matrix above
+- Every event you cite MUST appear in the events sample above
+- Do not invent signals or events that aren't in the data
+- Candidate patterns must have type "candidate"
+- No hedging, no hype vocabulary
+- Apply jargon translation before output
+- Health-is-valid \u2014 don't invent problems
+- Return ONLY the JSON object, no other text
+
+Do NOT use these phrases anywhere in your output:
+${forbiddenList}`;
+}
+function formatSignalSummary(signals) {
+  const lines = [];
+  const domains = ["life", "cyber", "joint"];
+  for (const domain of domains) {
+    const domainSignals = signals.filter((s) => s.domain === domain);
+    if (domainSignals.length === 0) continue;
+    lines.push(`### ${domain}`);
+    for (const s of domainSignals) {
+      const gate = s.eventCount >= 3 && s.confidence >= 0.5 ? "\u2713" : "\u25CB";
+      lines.push(
+        `  ${gate} ${s.id}: score=${s.score.toFixed(1)}, events=${s.eventCount}, conf=${s.confidence.toFixed(2)}`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatEventSample(events, maxEvents) {
+  const sample = events.slice(-maxEvents);
+  return sample.map((e) => {
+    const content = (e.event.content ?? "").slice(0, 200);
+    const respondsTo = e.event.respondsTo ? ` (responds to ${e.event.respondsTo.eventId})` : "";
+    return `- [${e.domain}] ${e.event.id} | ${e.event.actor.kind}:${e.event.actor.id} | ${e.event.kind ?? "event"}${respondsTo}
+  "${content}"`;
+  }).join("\n");
+}
+function parseInterpretation(raw, canonicalNames) {
+  let meaning = "";
+  let move = "";
+  let patternsArray = [];
+  const objMatch = raw.match(/\{[\s\S]*"patterns"[\s\S]*\}/);
+  if (objMatch) {
+    try {
+      const obj = JSON.parse(objMatch[0]);
+      if (Array.isArray(obj.patterns)) {
+        patternsArray = obj.patterns;
+      }
+      if (typeof obj.meaning === "string") meaning = obj.meaning;
+      if (typeof obj.move === "string") move = obj.move;
+    } catch {
+    }
+  }
+  if (patternsArray.length === 0) {
+    const arrMatch = raw.match(/\[[\s\S]*\]/);
+    if (arrMatch) {
+      try {
+        const arr = JSON.parse(arrMatch[0]);
+        if (Array.isArray(arr)) patternsArray = arr;
+      } catch {
+      }
+    }
+  }
+  const canonicalSet = new Set(canonicalNames.map((n) => n.toLowerCase()));
+  const patterns = [];
+  for (const item of patternsArray) {
+    if (!isPatternLike(item)) continue;
+    const nameStr = String(item.name ?? "unnamed");
+    const ev = item.evidence;
+    const isCanonical = item.type === "canonical" || canonicalSet.has(nameStr.toLowerCase());
+    patterns.push({
+      name: nameStr,
+      type: isCanonical ? "canonical" : "candidate",
+      declaredAs: isCanonical ? nameStr : void 0,
+      description: String(item.description ?? ""),
+      evidence: {
+        signals: Array.isArray(ev?.signals) ? ev.signals.map(String) : [],
+        events: Array.isArray(ev?.events) ? ev.events.map(String) : [],
+        cited_invariant: ev?.cited_invariant ? String(ev.cited_invariant) : void 0
+      },
+      confidence: typeof item.confidence === "number" ? Math.max(0, Math.min(1, item.confidence)) : 0.5
+    });
+  }
+  return { patterns, meaning, move };
+}
+function isPatternLike(x) {
+  return typeof x === "object" && x !== null && "name" in x;
+}
+
+// src/radiant/core/renderer.ts
+function render(input) {
+  const text = renderText(input);
+  const frontmatter = renderFrontmatter(input);
+  return { text, frontmatter };
+}
+function renderText(input) {
+  const sections = [];
+  sections.push(
+    `Scope:  ${formatScope(input.scope)}
+Window: last ${input.windowDays} days \xB7 ${input.eventCount} events
+Lens:   ${input.lens.name}`
+  );
+  if (input.patterns.length > 0) {
+    const canonical = input.patterns.filter((p) => p.type === "canonical");
+    const candidates = input.patterns.filter((p) => p.type === "candidate");
+    let emergentBlock = "EMERGENT\n";
+    if (canonical.length > 0) {
+      for (const p of canonical) {
+        emergentBlock += `
+  ${p.name}
+`;
+        emergentBlock += `    ${p.description}
+`;
+      }
+    }
+    if (candidates.length > 0) {
+      emergentBlock += "\n  Emergent (candidates \u2014 not yet in worldmodel)\n";
+      for (const p of candidates) {
+        emergentBlock += `
+  ${p.name}  (candidate)
+`;
+        emergentBlock += `    ${p.description}
+`;
+        if (p.evidence.cited_invariant) {
+          emergentBlock += `    Cited invariant: ${p.evidence.cited_invariant}
+`;
+        }
+      }
+    }
+    sections.push(emergentBlock.trimEnd());
+  }
+  if (input.meaning) {
+    sections.push(`MEANING
+
+  ${input.meaning.split("\n").join("\n  ")}`);
+  }
+  if (input.move) {
+    sections.push(`MOVE
+
+  ${input.move.split("\n").join("\n  ")}`);
+  }
+  const alignBlock = [
+    "ALIGNMENT",
+    "",
+    `  Human work:                ${formatScore(input.scores.A_L)}`,
+    `  AI work:                   ${formatScore(input.scores.A_C)}`,
+    `  Human\u2013AI collaboration:    ${formatScore(input.scores.A_N)}`,
+    `  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");
+}
+function renderDepth(priorReads, windowDays) {
+  if (priorReads === 0) {
+    return [
+      "DEPTH",
+      "",
+      `  This is your first read. Radiant sees ${windowDays} days of activity`,
+      "  but has no prior baseline to compare against.",
+      "",
+      "  Available now:",
+      "    \u2713 Signal extraction across life / cyber / joint domains",
+      "    \u2713 Pattern identification (canonical + candidates)",
+      "    \u2713 Alignment scoring",
+      "",
+      "  Available after 2+ reads:",
+      "    \xB7 Drift detection (is alignment improving or degrading?)",
+      '    \xB7 Baselines (what does "normal" look like for this team?)',
+      "    \xB7 Pattern confidence (are these patterns persistent or noise?)",
+      "    \xB7 Evolution proposals (should the worldmodel adapt?)",
+      "",
+      "  Run again next week. The read gets sharper every time."
+    ].join("\n");
+  }
+  if (priorReads < 4) {
+    return [
+      "DEPTH",
+      "",
+      `  Read ${priorReads + 1} of this scope. Baseline forming.`,
+      "",
+      "  Available now:",
+      "    \u2713 Signal extraction + pattern identification + alignment scoring",
+      `    \u2713 Drift detection (comparing against ${priorReads} prior read${priorReads > 1 ? "s" : ""})`,
+      "    \xB7 Baselines stabilizing (need 4+ reads for reliable averages)",
+      "    \xB7 Pattern confidence accumulating",
+      "",
+      "  The read sharpens with each run."
+    ].join("\n");
+  }
+  return [
+    "DEPTH",
+    "",
+    `  Read ${priorReads + 1} of this scope. Baseline established.`,
+    "",
+    "  Available:",
+    "    \u2713 Signal extraction + pattern identification + alignment scoring",
+    "    \u2713 Drift detection against established baseline",
+    "    \u2713 Pattern confidence (persistent vs noise)",
+    "    \u2713 Evolution proposals (candidate patterns with enough history to evaluate)"
+  ].join("\n");
+}
+function formatScore(s) {
+  if (!isScored(s)) {
+    if (s === "UNAVAILABLE") return "not available (no worldmodel loaded)";
+    return "not enough signal to call yet";
+  }
+  const n = Math.round(s);
+  let label;
+  if (n >= 75) label = "STRONG";
+  else if (n >= 60) label = "STABLE";
+  else if (n >= 45) label = "needs attention";
+  else if (n >= 30) label = "concerning";
+  else label = "critical";
+  return `${n} \xB7 ${label}`;
+}
+function renderFrontmatter(input) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signalsByDomain = groupSignalsByDomain(input.signals);
+  const patternEntries = input.patterns.map((p) => {
+    const entry = {
+      name: p.name,
+      type: p.type,
+      conf: Number(p.confidence.toFixed(2)),
+      evidence_signals: p.evidence.signals,
+      evidence_events: p.evidence.events
+    };
+    if (p.evidence.cited_invariant) {
+      entry.cited_invariant = p.evidence.cited_invariant;
+    }
+    return entry;
+  });
+  const frontmatter = {
+    radiant_read: {
+      scope: formatScope(input.scope),
+      window: `${input.windowDays}d`,
+      timestamp: now,
+      lens: input.lens.name
+    },
+    events: {
+      total: input.eventCount
+    },
+    signals: signalsByDomain,
+    scores: {
+      A_L: isScored(input.scores.A_L) ? Math.round(input.scores.A_L) : String(input.scores.A_L),
+      A_C: isScored(input.scores.A_C) ? Math.round(input.scores.A_C) : String(input.scores.A_C),
+      A_N: isScored(input.scores.A_N) ? Math.round(input.scores.A_N) : String(input.scores.A_N),
+      R: isScored(input.scores.R) ? Math.round(input.scores.R) : String(input.scores.R)
+    },
+    patterns: patternEntries
+  };
+  return "---\n" + serializeYAML(frontmatter) + "---";
+}
+function groupSignalsByDomain(signals) {
+  const result = {};
+  for (const s of signals) {
+    if (!result[s.domain]) result[s.domain] = {};
+    result[s.domain][s.id] = {
+      score: Number(s.score.toFixed(1)),
+      n: s.eventCount,
+      conf: Number(s.confidence.toFixed(2))
+    };
+  }
+  return result;
+}
+function serializeYAML(obj, indent = 0) {
+  const pad = "  ".repeat(indent);
+  if (obj === null || obj === void 0) return "null\n";
+  if (typeof obj === "string") return `${JSON.stringify(obj)}
+`;
+  if (typeof obj === "number" || typeof obj === "boolean") return `${obj}
+`;
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]\n";
+    if (obj.every((item) => typeof item === "string" || typeof item === "number")) {
+      return `[${obj.map((item) => JSON.stringify(item)).join(", ")}]
+`;
+    }
+    let result = "\n";
+    for (const item of obj) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        result += `${pad}- ${entries[0][0]}: ${serializeYAML(entries[0][1], 0).trim()}
+`;
+        for (let i = 1; i < entries.length; i++) {
+          result += `${pad}  ${entries[i][0]}: ${serializeYAML(entries[i][1], indent + 2).trim()}
+`;
+        }
+      } else {
+        result += `${pad}- ${serializeYAML(item, indent + 1).trim()}
+`;
+      }
+    }
+    return result;
+  }
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}\n";
+    let result = "\n";
+    for (const [key, value] of entries) {
+      if (typeof value === "object" && value !== null) {
+        result += `${pad}${key}:${serializeYAML(value, indent + 1)}`;
+      } else {
+        result += `${pad}${key}: ${serializeYAML(value, indent).trim()}
+`;
+      }
+    }
+    return result;
+  }
+  return `${obj}
+`;
+}
+
+// src/radiant/commands/emergent.ts
+async function emergent(input) {
+  const lens = resolveLens2(input.lensId);
+  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);
+    }
+  }
+  const events = await fetchGitHubActivity(input.scope, input.githubToken, {
+    windowDays
+  });
+  const classified = classifyEvents(events);
+  const signals = extractSignals(classified);
+  const scores = computeScores(signals, input.worldmodelContent !== "");
+  const { patterns, meaning, move } = await interpretPatterns({
+    signals,
+    events: classified,
+    worldmodelContent: input.worldmodelContent,
+    lens,
+    ai: input.ai,
+    canonicalPatterns: input.canonicalPatterns,
+    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,
+    eventCount: events.length,
+    signals,
+    patterns: rewrittenPatterns,
+    scores,
+    lens,
+    meaning: meaning || 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,
+    voiceViolations,
+    voiceClean: voiceViolations.length === 0,
+    signals,
+    scores,
+    eventCount: events.length
+  };
+}
+function computeScores(signals, worldmodelLoaded) {
+  const gate = DEFAULT_EVIDENCE_GATE;
+  const lifeSignals = signals.filter((s) => s.domain === "life");
+  const A_L = scoreLife(
+    { dimensions: lifeSignals.map(signalToDimension) },
+    gate
+  );
+  const cyberSignals = signals.filter((s) => s.domain === "cyber");
+  const A_C = scoreCyber(
+    { dimensions: cyberSignals.map(signalToDimension) },
+    gate
+  );
+  const jointSignals = signals.filter((s) => s.domain === "joint");
+  const A_N = scoreNeuroVerse(
+    jointSignals.map(signalToBridging),
+    worldmodelLoaded,
+    gate
+  );
+  const R = scoreComposite(A_L, A_C, A_N);
+  return { A_L, A_C, A_N, R };
+}
+function signalToDimension(s) {
+  return {
+    id: s.id,
+    score: s.score,
+    eventCount: s.eventCount,
+    confidence: s.confidence
+  };
+}
+function signalToBridging(s) {
+  return {
+    component: "ALIGN",
+    // Proxy: joint signals → ALIGN component
+    score: s.score,
+    eventCount: s.eventCount,
+    confidence: s.confidence
+  };
+}
+function resolveLens2(id) {
+  const lens = getLens(id);
+  if (!lens) {
+    throw new Error(
+      `Lens "${id}" not found. Check the id or register the lens.`
+    );
+  }
+  return lens;
+}
+
+// src/radiant/core/ai.ts
+function createAnthropicAI(apiKey, model = "claude-sonnet-4-20250514", maxTokens = 4096) {
+  return {
+    async complete(systemPrompt, userQuery) {
+      const res = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          max_tokens: maxTokens,
+          system: systemPrompt,
+          messages: [{ role: "user", content: userQuery }]
+        })
+      });
+      if (!res.ok) {
+        const body = await res.text();
+        throw new Error(
+          `Anthropic API error ${res.status}: ${body.slice(0, 500)}`
+        );
+      }
+      const data = await res.json();
+      const text = data.content?.filter((c) => c.type === "text").map((c) => c.text ?? "").join("");
+      if (!text) {
+        throw new Error("Anthropic returned no text content");
+      }
+      return text;
+    }
+  };
+}
+function createMockAI(fixedResponse) {
+  return {
+    async complete() {
+      return fixedResponse;
+    }
+  };
+}
+
+export {
+  composeSystemPrompt,
+  checkForbiddenPhrases,
+  think,
+  parseRepoScope,
+  formatScope,
+  fetchGitHubActivity,
+  createMockGitHubAdapter,
+  readExocortex,
+  formatExocortexForPrompt,
+  summarizeExocortex,
+  writeRead,
+  updateKnowledge,
+  loadPriorReads,
+  computePersistence,
+  formatPriorReadsForPrompt,
+  auditGovernance,
+  classifyActorDomain,
+  classifyEvents,
+  extractSignals,
+  DEFAULT_SIGNAL_EXTRACTORS,
+  DEFAULT_EVIDENCE_GATE,
+  isScored,
+  isSentinel,
+  isPresent,
+  presenceAverage,
+  scoreLife,
+  scoreCyber,
+  scoreNeuroVerse,
+  scoreComposite,
+  interpretPatterns,
+  render,
+  emergent,
+  createAnthropicAI,
+  createMockAI
+};