@neuroverseos/governance 0.8.1 → 0.10.0

package/dist/radiant/index.d.ts

@@ -584,7 +584,7 @@ declare const sovereignConduitLens: RenderingLens;
  * Current registry:
  *   - auki-builder — Auki's vanguard leadership lens.
  *   - sovereign-conduit — NeuroVerseOS base lens. Warm, accessible,
- *     teaching. Stewardship / Sovereignty / Integration.
+ *     teaching. Stewardship / Agency / Integration.
  *
  * To add a new lens:
  *   1. Create src/radiant/lenses/<name>.ts exporting a `RenderingLens`.
@@ -1168,6 +1168,137 @@ declare function fetchNotionActivity(token: string, options?: NotionFetchOptions
  */
 declare function formatNotionSignalsForPrompt(signals: NotionSignals): string;
 
+/**
+ * @neuroverseos/governance/radiant — Linear adapter
+ *
+ * Reads planned work from Linear and surfaces the gap between what the team
+ * said it would ship (issues, cycles, projects) and what actually got built
+ * (signals from the GitHub adapter).
+ *
+ * The behavioral signal Linear uniquely provides:
+ *   stated intent (issues planned, cycle committed) vs.
+ *   shipped outcome (PRs merged, features delivered)
+ *
+ * That gap is the clearest "agency drift" signal a team can produce — and
+ * none of the dev-productivity tools (LinearB, Swarmia, Jellyfish) read
+ * Linear and GitHub together through a worldmodel lens.
+ *
+ * What it captures:
+ *   - Issues created (planning velocity)
+ *   - Issues completed (shipping velocity)
+ *   - Issues stalled (in-progress > N days without movement)
+ *   - Cycle commitment vs. completion (did we finish what we committed to?)
+ *   - Comments (how much the team debates vs. ships)
+ *   - Project-level updates (direction signals above the issue layer)
+ *
+ * Uses Linear GraphQL v1 via raw fetch (no @linear/sdk dependency,
+ * matching the shape of notion.ts / slack.ts / discord.ts).
+ * Requires a Linear personal API key with read access.
+ */
+
+interface LinearFetchOptions {
+    /** Restrict to specific team IDs. If empty, reads all accessible teams. */
+    teamIds?: string[];
+    /** How many days of history to fetch. Default: 14. */
+    windowDays?: number;
+    /** Max issues to fetch. Default: 200. */
+    maxIssues?: number;
+}
+interface LinearSignals {
+    /** Issues created in window. */
+    issuesCreated: number;
+    /** Issues completed (moved to a "completed" state) in window. */
+    issuesCompleted: number;
+    /** Issues still open at window end. */
+    issuesOpen: number;
+    /** Issues in an in-progress state for > 14 days with no update. */
+    issuesStalled: number;
+    /** Ratio of completed / committed for cycles that ended in window. */
+    cycleCompletionRate: number | null;
+    /** Unique assignees active in window. */
+    uniqueAssignees: number;
+    /** Total comments across issues in window. */
+    commentsTotal: number;
+    /** Top project titles active in window. */
+    topProjects: string[];
+}
+/**
+ * Fetch Linear activity and return Radiant Events + compressed signals.
+ *
+ * Shape mirrors fetchNotionActivity / fetchSlackActivity so the radiant
+ * pipeline composes uniformly. Call from commands/emergent.ts the same way
+ * as the other adapters.
+ */
+declare function fetchLinearActivity(apiKey: string, options?: LinearFetchOptions): Promise<{
+    events: Event[];
+    signals: LinearSignals;
+}>;
+/**
+ * Format Linear signals for the AI interpretation prompt.
+ * Emphasizes the stated-intent-vs-shipped-outcome framing so the lens
+ * can pick up agency drift without the adapter naming it directly.
+ */
+declare function formatLinearSignalsForPrompt(signals: LinearSignals): string;
+
+/**
+ * @neuroverseos/governance/radiant — declared vocabulary extraction
+ *
+ * Pulls Aligned Behaviors and Drift Behaviors from a worldmodel markdown
+ * file and turns them into canonical snake_case pattern names that the AI
+ * must use when it sees matching evidence.
+ *
+ * Why this exists: Radiant's AI was inventing names like
+ * `velocity_without_declared_target` when the worldmodel already declared
+ * `dependency_on_ai_presenting_as_integration` for the same observation.
+ * The prompt told the AI to "use canonical names if you see them" — but
+ * no one was extracting canonical names from the worldmodel. This module
+ * closes that loop: Radiant now governs its own output against the
+ * vocabulary it claims to read.
+ *
+ * Supported bullet formats (under `## Aligned Behaviors` / `## Drift Behaviors`):
+ *   - `` `canonical_name` — prose description ``  (explicit, preferred)
+ *   - `canonical_name — prose description`         (explicit, no backticks)
+ *   - `prose description only`                     (auto-snake-cased)
+ *
+ * Empty sections, missing sections, and HTML comments are silently ignored
+ * — partial vocabulary is better than no vocabulary, and falling back to
+ * candidate-only behavior is the correct failure mode.
+ */
+interface DeclaredPattern {
+    /** snake_case canonical identifier (stable across reads). */
+    name: string;
+    /** Human-readable prose for keyword matching against AI output. */
+    prose: string;
+    /** Which section this came from. */
+    kind: 'aligned' | 'drift';
+}
+interface DeclaredVocabulary {
+    aligned: DeclaredPattern[];
+    drift: DeclaredPattern[];
+    /** All canonical names (aligned + drift) for quick membership checks. */
+    allNames: string[];
+}
+declare function extractDeclaredVocabulary(worldmodelContent: string): DeclaredVocabulary;
+/**
+ * Given a pattern description + name the AI emitted, find a declared
+ * pattern whose prose has enough keyword overlap to be "the same thing."
+ *
+ * Matching is deterministic keyword overlap over content words (lowercased,
+ * >3 chars, punctuation stripped, common stopwords removed). A match
+ * requires at least 2 shared words AND at least 30% coverage of the
+ * declared prose's content words. When multiple declared patterns match,
+ * the one with highest coverage wins.
+ *
+ * This is intentionally a simple deterministic pass, not an LLM call:
+ *   - no extra token cost
+ *   - testable and reproducible
+ *   - easy to tune thresholds without retraining
+ *
+ * Returns null when nothing matches well enough. The pattern stays a
+ * candidate.
+ */
+declare function matchDeclaredPattern(candidateName: string, candidateDescription: string, vocabulary: DeclaredVocabulary): DeclaredPattern | null;
+
 /**
  * @neuroverseos/governance/radiant — AI pattern interpretation
  *
@@ -1201,8 +1332,15 @@ interface InterpretInput {
     lens: RenderingLens;
     /** AI adapter to call for interpretation. */
     ai: RadiantAI;
-    /** Known canonical pattern names from the worldmodel (optional). */
+    /** Known canonical pattern names from the worldmodel (optional).
+     *  Kept for backward compatibility — new callers should pass
+     *  declaredVocabulary instead, which carries both names and prose. */
     canonicalPatterns?: readonly string[];
+    /** Declared vocabulary extracted from the worldmodel's Aligned/Drift
+     *  Behaviors. When present, the AI is told the exact canonical names
+     *  to use, and any candidate whose description matches declared prose
+     *  is reclassified to the declared name. */
+    declaredVocabulary?: DeclaredVocabulary;
     /** Stated intent from the exocortex (optional). When present, the AI
      *  compares stated intent against observed behavior and surfaces gaps. */
     statedIntent?: string;
@@ -1291,7 +1429,7 @@ declare function auditGovernance(events: readonly ClassifiedEvent[], worldPath:
  * Takes signals + patterns + scores + lens metadata and produces the
  * structured output Nils reads. Two output modes:
  *   - text: the EMERGENT / MEANING / MOVE structure for terminal display
- *   - yaml+text: Memory Palace coded read file (YAML frontmatter + prose)
+ *   - yaml+text: Mind Palace coded read file (YAML frontmatter + prose)
  *
  * The renderer enforces the lens's voice rules: forbidden phrases are
  * checked, bucket names are never leaked, vocabulary is Auki-native.
@@ -1321,35 +1459,117 @@ interface RenderInput {
 interface RenderOutput {
     /** The human-readable text output for terminal display. */
     text: string;
-    /** The Memory Palace coded YAML frontmatter (Tier 2 structured signals). */
+    /** The Mind Palace coded YAML frontmatter (Tier 2 structured signals). */
     frontmatter: string;
 }
 declare function render(input: RenderInput): RenderOutput;
 
+/**
+ * @neuroverseos/governance/radiant — extends (org-wide world sharing)
+ *
+ * Lets a repo declare worldmodels that live in another repo, so one
+ * source of truth can govern many repos. Auki has 51 repos — one
+ * `aukiNetwork/worlds` repo holds the canonical worldmodel, every
+ * other repo declares `extends: ["github:aukiNetwork/worlds"]`.
+ *
+ * Spec grammar:
+ *   github:OWNER/REPO               — latest default branch, repo root
+ *   github:OWNER/REPO@REF           — specific ref (branch, tag, or sha)
+ *   github:OWNER/REPO@REF:SUBPATH   — subpath inside the cloned repo
+ *   ./relative/path                 — local dir relative to repo root
+ *   /absolute/path                  — absolute local dir
+ *
+ * github: sources are shallow-cloned into ~/.neuroverse/cache/extends/<hash>/
+ * Cache is reused for 1 hour; set NEUROVERSE_REFRESH=1 to force refetch,
+ * or NEUROVERSE_NO_FETCH=1 to forbid network access (cache-or-nothing).
+ */
+interface ExtendsSpec {
+    raw: string;
+    kind: 'github' | 'local';
+    owner?: string;
+    repo?: string;
+    ref?: string;
+    subpath?: string;
+    path?: string;
+}
+interface ExtendsConfig {
+    extends?: string[];
+}
+interface ResolveResult {
+    spec: ExtendsSpec;
+    dir: string | null;
+    warning?: string;
+}
+type Fetcher = (spec: ExtendsSpec, destDir: string) => void;
+declare function loadExtendsConfig(repoDir: string): ExtendsConfig | null;
+declare function parseExtendsSpec(raw: string): ExtendsSpec | null;
+declare function getCacheDir(spec: ExtendsSpec, baseCacheDir?: string): string;
+declare function resolveExtendsSpec(spec: ExtendsSpec, repoDir: string, options?: {
+    cacheDir?: string;
+    fetcher?: Fetcher;
+    ttlMs?: number;
+    forceRefresh?: boolean;
+    noFetch?: boolean;
+    /** Suppress warnings when the remote source doesn't exist.
+     * Used by the org tier, where a missing <org>/worlds repo is the
+     * common case and should silently skip. */
+    silentOnMissing?: boolean;
+}): ResolveResult;
+/**
+ * Detect the conventional org-level worldmodel source from the current
+ * repo's git remote. Returns an ExtendsSpec pointing at `<owner>/worlds`
+ * on the same host, or null if:
+ *   - no git repo / no origin remote
+ *   - remote is on a non-GitHub host (v1 only supports github.com)
+ *   - the current repo IS the worlds repo (avoid self-loop)
+ *
+ * Example: in a repo with origin github.com/NeuroverseOS/foo, this
+ * returns a spec for `github:NeuroverseOS/worlds`. If that repo doesn't
+ * exist on GitHub, discovery's silentOnMissing flag swallows the failure
+ * so nothing noisy surfaces.
+ */
+declare function detectOrgExtendsSpec(repoDir: string): ExtendsSpec | null;
+declare function resolveAllExtends(repoDir: string, options?: {
+    cacheDir?: string;
+    fetcher?: Fetcher;
+    ttlMs?: number;
+    forceRefresh?: boolean;
+    noFetch?: boolean;
+    config?: ExtendsConfig | null;
+}): ResolveResult[];
+
 /**
  * @neuroverseos/governance/radiant — world discovery
  *
- * Automatically discovers and loads worldmodels from three sources,
- * in precedence order:
+ * Automatically discovers and loads worldmodels from five sources,
+ * in precedence order (later tiers override earlier ones):
  *
  *   1. NeuroVerse base (built-in, universal — always loaded)
  *   2. User worlds (~/.neuroverse/worlds/ — your personal model)
- *   3. Repo worlds (./worlds/ in the current repo — local authority)
+ *   3. Org worlds (github:<owner>/worlds for current repo's GitHub org — zero config)
+ *   4. Extends (declared in .neuroverse/config.json — explicit overrides)
+ *   5. Repo worlds (./worlds/ in the current repo — local authority)
  *
  * Worlds live where the work lives. You don't switch between them —
  * you walk into them. Open an Auki repo → Auki's worlds load.
  * Leave → they disappear. No toggle, no config, no removal.
  *
- * Precedence: repo > user > base. When you're in someone else's
- * system, their worlds take authority. Your personal world stays
- * as your baseline perspective. The NeuroVerse base is the universal
- * foundation both sit on top of.
+ * The org tier piggybacks on GitHub's existing org structure: discovery
+ * reads .git/config, extracts the owner from the origin remote, and
+ * probes `github:<owner>/worlds`. If the repo exists, its worldmodels
+ * load automatically — no per-repo config needed. Missing silently.
+ *
+ * The extends tier is the explicit override for non-conventional sources
+ * (private mirrors, local paths, alternate orgs).
  */
+
 interface DiscoveredWorld {
     name: string;
-    source: 'base' | 'user' | 'repo';
+    source: 'base' | 'user' | 'org' | 'extends' | 'repo';
     path: string;
     content: string;
+    /** For extends- and org-sourced worlds: the resolved spec. */
+    extendsFrom?: string;
 }
 interface WorldStack {
     worlds: DiscoveredWorld[];
@@ -1357,6 +1577,8 @@ interface WorldStack {
     combinedContent: string;
     /** Human-readable list of what's loaded. */
     summary: string;
+    /** Non-fatal warnings (e.g. failed extends fetch, stale cache). */
+    warnings: string[];
 }
 /**
  * Discover and load worldmodels from all three sources.
@@ -1367,11 +1589,27 @@ interface WorldStack {
  *   Default: ~/.neuroverse/worlds/
  * @param explicitWorldsDir — explicit --worlds flag (overrides discovery).
  *   When provided, this is used AS the repo-level source.
+ * @param scopeOwner — GitHub org/owner hint derived from a CLI scope
+ *   argument (e.g. the "NeuroverseOS" in `radiant emergent NeuroverseOS/`).
+ *   When provided, discovery also probes `github:<scopeOwner>/worlds`
+ *   in the org tier. This lets the command work without a local clone —
+ *   the scope itself tells us which org's worlds to load.
  */
 declare function discoverWorlds(options?: {
     repoDir?: string;
     userWorldsDir?: string;
     explicitWorldsDir?: string;
+    scopeOwner?: string;
+    /** Override the extends cache location (default ~/.neuroverse/cache/extends/). */
+    extendsCacheDir?: string;
+    /** Inject a fetcher (tests use this to avoid real network calls). */
+    extendsFetcher?: Fetcher;
+    /** Cache TTL for github: extends (default 1 hour). */
+    extendsTtlMs?: number;
+    /** Disable extends resolution entirely. */
+    disableExtends?: boolean;
+    /** Disable org auto-detect tier. Also disabled by NEUROVERSE_NO_ORG=1. */
+    disableOrg?: boolean;
 }): WorldStack;
 /**
  * Format the active worlds list for display in the output header.
@@ -1379,13 +1617,48 @@ declare function discoverWorlds(options?: {
 declare function formatActiveWorlds(stack: WorldStack): string;
 
 /**
- * @neuroverseos/governance/radiant — Memory Palace file operations
+ * @neuroverseos/governance/radiant — git remote introspection
+ *
+ * Reads the current repo's origin remote and parses out the host/owner/repo.
+ * Used by the org-level discovery tier to ask "what GitHub org owns this
+ * repo?" and then look for a conventional <org>/worlds source of truth.
+ *
+ * Works for both `.git/` directories and `.git` files (git worktrees /
+ * submodules, which store a `gitdir: <path>` pointer instead of a full dir).
+ */
+interface ParsedRemote {
+    host: string;
+    owner: string;
+    repo: string;
+}
+/**
+ * Read the `origin` remote URL from a repo's git config.
+ * Returns null if no repo, no remote, or read fails.
+ */
+declare function readOriginRemote(repoDir: string): string | null;
+/**
+ * Parse a git remote URL into host/owner/repo.
+ *
+ * Supported forms:
+ *   https://github.com/OWNER/REPO(.git)
+ *   http://github.com/OWNER/REPO(.git)
+ *   git@github.com:OWNER/REPO(.git)
+ *   ssh://git@github.com/OWNER/REPO(.git)
+ */
+declare function parseRemoteUrl(url: string): ParsedRemote | null;
+/**
+ * One-shot: read origin and parse it.
+ */
+declare function getRepoOrigin(repoDir: string): ParsedRemote | null;
+
+/**
+ * @neuroverseos/governance/radiant — Mind Palace file operations
  *
  * Writes Radiant reads to the exocortex as dated markdown files (with
  * YAML frontmatter for structured signal data). Reads prior files to
  * detect pattern persistence across runs.
  *
- * The exocortex directory IS the Memory Palace. Files are the tiers:
+ * The exocortex directory IS the Mind Palace. Files are the tiers:
  *   - reads/YYYY-MM-DD.md = Tier 2 (structured signals) + Tier 3 (narrative)
  *   - knowledge.md = accumulated pattern facts with persistence counts
  *
@@ -1458,7 +1731,7 @@ declare function computePersistence(priorReads: PriorRead[], currentPatternNames
 declare function formatPriorReadsForPrompt(priorReads: PriorRead[]): string;
 
 /**
- * @neuroverseos/governance/radiant — Memory Palace compression
+ * @neuroverseos/governance/radiant — Mind Palace compression
  *
  * Applies the three-tier principle to everything that enters the AI
  * prompt: raw data is not the memory; structured signals are.
@@ -1594,11 +1867,16 @@ interface EmergentInput {
      *  When present, each event is evaluated through evaluateGuard
      *  and the GOVERNANCE section appears in the output. */
     worldPath?: string;
+    /** When set, filter events to only this GitHub login's activity.
+     *  Turns Radiant into a local, personal facilitator — reads your
+     *  own drift, not the team's. No one else is observed. Leave
+     *  undefined for the default team-wide read. */
+    personalUser?: string;
 }
 interface EmergentResult {
     /** The rendered text output (EMERGENT / MEANING / MOVE). */
     text: string;
-    /** The YAML frontmatter for Memory Palace coding. */
+    /** The YAML frontmatter for Mind Palace coding. */
     frontmatter: string;
     /** Voice violations detected in AI output. */
     voiceViolations: VoiceViolation[];
@@ -1620,6 +1898,13 @@ interface EmergentResult {
     worldStack?: WorldStack;
 }
 declare function emergent(input: EmergentInput): Promise<EmergentResult>;
+/**
+ * Keep only events whose actor login matches `username` (case-insensitive).
+ * Used by personal mode to narrow a read to a single contributor — Radiant
+ * as a local facilitator reading one person's own drift, not a global
+ * observer of the team. Pure function, testable in isolation.
+ */
+declare function filterEventsByUser(events: readonly Event[], username: string): Event[];
 
 /**
  * @neuroverseos/governance/radiant
@@ -1641,12 +1926,12 @@ declare function emergent(input: EmergentInput): Promise<EmergentResult>;
  *     before the renderer sees them — deterministic shaping, no LLM in path
  *   - Stateless commands: emergent, decision
  *   - Stateful (via MemoryProvider) commands: drift, evolve
- *   - Memory Palace 4-layer coding standard (compression / baselines /
+ *   - Mind Palace 4-layer coding standard (compression / baselines /
  *     knowledge / synthesis) with a SQLite reference implementation
  *   - CLI entry (bin/radiant.ts) and MCP server entry (bin/radiant-mcp.ts)
  *
  * Build state: Phase 1 complete — voice layer, behavioral dashboard,
- * MCP server, Memory Palace write-back, governance audit, ExoCortex
+ * MCP server, Mind Palace write-back, governance audit, ExoCortex
  * handshake. See radiant/PROJECT-PLAN.md for the full roadmap.
  *
  * Usage:
@@ -1657,4 +1942,4 @@ declare function emergent(input: EmergentInput): Promise<EmergentResult>;
  */
 declare const RADIANT_PACKAGE_VERSION = "0.0.0";
 
-export { type Actor, type ActorDomain, type ActorKind, type AlignmentStatus, type BridgingComponent, type BridgingComponentScore, type ClassifiedEvent, type CyberCapability, type CyberDimension, DEFAULT_EVIDENCE_GATE, DEFAULT_SIGNAL_EXTRACTORS, type DiscordFetchOptions, type DiscordSignals, type DiscoveredWorld, type EmergentInput, type EmergentResult, type Event, type EventReference, type EvidenceGate, type ExemplarRef, type ExocortexContext, type ExtractionResult, type GitHubFetchOptions, type GovernanceAudit, type GovernanceVerdict, type InterpretInput, type InterpretResult, LENSES, type LensVocabulary, type LifeCapability, type LifeDimension, type NotionFetchOptions, type NotionSignals, type ObservedPattern, type OrgScope, type OverlapDef, type PatternEvidence, type PatternPersistence, type PrimaryFrame, type PriorRead, RADIANT_PACKAGE_VERSION, type RadiantAI, type RenderInput, type RenderOutput, type RenderingLens, type RepoScope, type Scope, type Score, type ScoreSentinel, type ScoredObservation, type Signal, type SignalExtractor, type SignalMatrix, type SlackFetchOptions, type SlackSignals, type ThinkInput, type ThinkResult, type ViewLevel, type VoiceDirectives, type VoiceViolation, type WorldStack, type WorldmodelItem, auditGovernance, aukiBuilderLens, checkForbiddenPhrases, classifyActorDomain, classifyEvents, composeSystemPrompt, compressExocortex, compressLens, compressPriorReads, compressWorldmodel, computePersistence, createAnthropicAI, createMockAI, createMockGitHubAdapter, discoverWorlds, emergent, extractSignals, fetchDiscordActivity, fetchGitHubActivity, fetchGitHubOrgActivity, fetchNotionActivity, fetchSlackActivity, formatActiveWorlds, formatDiscordSignalsForPrompt, formatExocortexForPrompt, formatNotionSignalsForPrompt, formatPriorReadsForPrompt, formatScope, formatSlackSignalsForPrompt, formatTeamExocorticesForPrompt, getLens, interpretPatterns, isPresent, isScored, isSentinel, listLenses, loadPriorReads, parseRepoScope, parseScope, presenceAverage, readExocortex, readTeamExocortices, render, scoreComposite, scoreCyber, scoreLife, scoreNeuroVerse, sovereignConduitLens, summarizeExocortex, think, updateKnowledge, writeRead };
+export { type Actor, type ActorDomain, type ActorKind, type AlignmentStatus, type BridgingComponent, type BridgingComponentScore, type ClassifiedEvent, type CyberCapability, type CyberDimension, DEFAULT_EVIDENCE_GATE, DEFAULT_SIGNAL_EXTRACTORS, type DeclaredPattern, type DeclaredVocabulary, type DiscordFetchOptions, type DiscordSignals, type DiscoveredWorld, type EmergentInput, type EmergentResult, type Event, type EventReference, type EvidenceGate, type ExemplarRef, type ExocortexContext, type ExtendsConfig, type ExtendsSpec, type ExtractionResult, type Fetcher, type GitHubFetchOptions, type GovernanceAudit, type GovernanceVerdict, type InterpretInput, type InterpretResult, LENSES, type LensVocabulary, type LifeCapability, type LifeDimension, type LinearFetchOptions, type LinearSignals, type NotionFetchOptions, type NotionSignals, type ObservedPattern, type OrgScope, type OverlapDef, type ParsedRemote, type PatternEvidence, type PatternPersistence, type PrimaryFrame, type PriorRead, RADIANT_PACKAGE_VERSION, type RadiantAI, type RenderInput, type RenderOutput, type RenderingLens, type RepoScope, type ResolveResult, type Scope, type Score, type ScoreSentinel, type ScoredObservation, type Signal, type SignalExtractor, type SignalMatrix, type SlackFetchOptions, type SlackSignals, type ThinkInput, type ThinkResult, type ViewLevel, type VoiceDirectives, type VoiceViolation, type WorldStack, type WorldmodelItem, auditGovernance, aukiBuilderLens, checkForbiddenPhrases, classifyActorDomain, classifyEvents, composeSystemPrompt, compressExocortex, compressLens, compressPriorReads, compressWorldmodel, computePersistence, createAnthropicAI, createMockAI, createMockGitHubAdapter, detectOrgExtendsSpec, discoverWorlds, emergent, extractDeclaredVocabulary, extractSignals, fetchDiscordActivity, fetchGitHubActivity, fetchGitHubOrgActivity, fetchLinearActivity, fetchNotionActivity, fetchSlackActivity, filterEventsByUser, formatActiveWorlds, formatDiscordSignalsForPrompt, formatExocortexForPrompt, formatLinearSignalsForPrompt, formatNotionSignalsForPrompt, formatPriorReadsForPrompt, formatScope, formatSlackSignalsForPrompt, formatTeamExocorticesForPrompt, getCacheDir, getLens, getRepoOrigin, interpretPatterns, isPresent, isScored, isSentinel, listLenses, loadExtendsConfig, loadPriorReads, matchDeclaredPattern, parseExtendsSpec, parseRemoteUrl, parseRepoScope, parseScope, presenceAverage, readExocortex, readOriginRemote, readTeamExocortices, render, resolveAllExtends, resolveExtendsSpec, scoreComposite, scoreCyber, scoreLife, scoreNeuroVerse, sovereignConduitLens, summarizeExocortex, think, updateKnowledge, writeRead };

package/dist/radiant/index.js

@@ -14,33 +14,47 @@ import {
   createAnthropicAI,
   createMockAI,
   createMockGitHubAdapter,
+  detectOrgExtendsSpec,
   discoverWorlds,
   emergent,
+  extractDeclaredVocabulary,
   extractSignals,
   fetchDiscordActivity,
   fetchGitHubActivity,
   fetchGitHubOrgActivity,
+  fetchLinearActivity,
   fetchNotionActivity,
   fetchSlackActivity,
+  filterEventsByUser,
   formatActiveWorlds,
   formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
   formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt,
+  getCacheDir,
+  getRepoOrigin,
   interpretPatterns,
   isPresent,
   isScored,
   isSentinel,
+  loadExtendsConfig,
   loadPriorReads,
+  matchDeclaredPattern,
+  parseExtendsSpec,
+  parseRemoteUrl,
   parseRepoScope,
   parseScope,
   presenceAverage,
   readExocortex,
+  readOriginRemote,
   readTeamExocortices,
   render,
+  resolveAllExtends,
+  resolveExtendsSpec,
   scoreComposite,
   scoreCyber,
   scoreLife,
@@ -49,14 +63,14 @@ import {
   think,
   updateKnowledge,
   writeRead
-} from "../chunk-ETDIEVAX.js";
+} from "../chunk-BZYQHJDM.js";
 import {
   LENSES,
   aukiBuilderLens,
   getLens,
   listLenses,
   sovereignConduitLens
-} from "../chunk-F2LWMOM5.js";
+} from "../chunk-TCGGED4G.js";
 import "../chunk-I4RTIMLX.js";
 import "../chunk-ZAF6JH23.js";
 import "../chunk-QLPTHTVB.js";
@@ -83,35 +97,49 @@ export {
   createAnthropicAI,
   createMockAI,
   createMockGitHubAdapter,
+  detectOrgExtendsSpec,
   discoverWorlds,
   emergent,
+  extractDeclaredVocabulary,
   extractSignals,
   fetchDiscordActivity,
   fetchGitHubActivity,
   fetchGitHubOrgActivity,
+  fetchLinearActivity,
   fetchNotionActivity,
   fetchSlackActivity,
+  filterEventsByUser,
   formatActiveWorlds,
   formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
   formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt,
+  getCacheDir,
   getLens,
+  getRepoOrigin,
   interpretPatterns,
   isPresent,
   isScored,
   isSentinel,
   listLenses,
+  loadExtendsConfig,
   loadPriorReads,
+  matchDeclaredPattern,
+  parseExtendsSpec,
+  parseRemoteUrl,
   parseRepoScope,
   parseScope,
   presenceAverage,
   readExocortex,
+  readOriginRemote,
   readTeamExocortices,
   render,
+  resolveAllExtends,
+  resolveExtendsSpec,
   scoreComposite,
   scoreCyber,
   scoreLife,

package/dist/{server-ZSQ6DRSN.js → server-EI5JCIBU.js}

@@ -3,8 +3,8 @@ import {
   emergent,
   parseRepoScope,
   think
-} from "./chunk-ETDIEVAX.js";
-import "./chunk-F2LWMOM5.js";
+} from "./chunk-BZYQHJDM.js";
+import "./chunk-TCGGED4G.js";
 import "./chunk-I4RTIMLX.js";
 import "./chunk-ZAF6JH23.js";
 import "./chunk-QLPTHTVB.js";

package/examples/radiant-weekly-workflow.yml

@@ -0,0 +1,84 @@
+# Weekly Radiant Read — GitHub Actions workflow template
+#
+# Copy this file into your org's exocortex repo at:
+#   .github/workflows/radiant-weekly.yml
+#
+# Every Monday at 9am UTC it:
+#   1. Checks out this repo (the exocortex — where reads persist)
+#   2. Runs `radiant emergent <your-org>/` against the latest 14 days of activity
+#   3. Writes the read to radiant/reads/YYYY-MM-DD.md
+#   4. Commits and pushes the new file
+#
+# Each run extends the palace history. Week over week, Radiant gains the
+# baselines / drift detection / pattern confidence promised in the DEPTH
+# section of the output.
+#
+# Required repo secrets:
+#   ANTHROPIC_API_KEY    — for the MEANING/MOVE interpretation step
+#
+# Required repo settings:
+#   Settings → Actions → General → Workflow permissions → "Read and write"
+#   (so the job can push its own commit)
+#
+# Optional:
+#   Replace the hardcoded org (NeuroverseOS) with your own.
+#   Replace the lens (sovereign-conduit) with your chosen lens.
+
+name: Weekly Radiant Read
+
+on:
+  schedule:
+    # Monday at 09:00 UTC. Change to whatever rhythm your team uses.
+    - cron: '0 9 * * MON'
+  # Allow manual trigger from the Actions tab for testing.
+  workflow_dispatch:
+
+permissions:
+  contents: write  # needed to push the new read back into this repo
+
+jobs:
+  read:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out this exocortex repo
+        uses: actions/checkout@v4
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install @neuroverseos/governance
+        run: npm install --no-save @neuroverseos/governance@latest
+
+      - name: Run Radiant emergent read
+        env:
+          # GITHUB_TOKEN is auto-provided by Actions and is enough to read the
+          # NeuroverseOS org's public repos. For private repo reads, replace
+          # with a fine-grained PAT stored in secrets.RADIANT_GITHUB_TOKEN.
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          # Mind Palace writes into THIS repo — since we checked it out at
+          # the workflow root, point the CLI at $GITHUB_WORKSPACE.
+          RADIANT_EXOCORTEX: ${{ github.workspace }}
+        run: |
+          npx @neuroverseos/governance@latest radiant emergent NeuroverseOS/ \
+            --entire-org \
+            --lens sovereign-conduit
+          # --entire-org is required to read all repos in the org. Without
+          # it, Radiant's default scope is narrow (consent-first posture).
+          # No --worlds flag needed — discovery probes NeuroverseOS/worlds
+          # directly from the scope arg. See the governance repo for details.
+
+      - name: Commit and push the new read
+        run: |
+          git config user.name  'radiant-bot'
+          git config user.email 'radiant-bot@users.noreply.github.com'
+          # Only commit if the read actually produced a file.
+          if [[ -n "$(git status --porcelain radiant/reads/)" ]]; then
+            git add radiant/reads/
+            git commit -m "radiant: weekly read $(date -u +%Y-%m-%d)"
+            git push
+          else
+            echo "No new read file produced — nothing to commit."
+          fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neuroverseos/governance",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "Deterministic governance engine for AI agents — enforce worlds (permanent rules) and plans (mission constraints) with full audit trace",
   "license": "Apache-2.0",
   "type": "module",
@@ -114,6 +114,7 @@
     "dist/browser.global.js",
     "policies",
     "examples/social-media-sim",
+    "examples/radiant-weekly-workflow.yml",
     "simulate.html",
     "LICENSE.md",
     "README.md",