@neuroverseos/governance 0.8.1 → 0.10.0

package/dist/radiant/index.cjs

@@ -48,35 +48,49 @@ __export(radiant_exports, {
   createAnthropicAI: () => createAnthropicAI,
   createMockAI: () => createMockAI,
   createMockGitHubAdapter: () => createMockGitHubAdapter,
+  detectOrgExtendsSpec: () => detectOrgExtendsSpec,
   discoverWorlds: () => discoverWorlds,
   emergent: () => emergent,
+  extractDeclaredVocabulary: () => extractDeclaredVocabulary,
   extractSignals: () => extractSignals,
   fetchDiscordActivity: () => fetchDiscordActivity,
   fetchGitHubActivity: () => fetchGitHubActivity,
   fetchGitHubOrgActivity: () => fetchGitHubOrgActivity,
+  fetchLinearActivity: () => fetchLinearActivity,
   fetchNotionActivity: () => fetchNotionActivity,
   fetchSlackActivity: () => fetchSlackActivity,
+  filterEventsByUser: () => filterEventsByUser,
   formatActiveWorlds: () => formatActiveWorlds,
   formatDiscordSignalsForPrompt: () => formatDiscordSignalsForPrompt,
   formatExocortexForPrompt: () => formatExocortexForPrompt,
+  formatLinearSignalsForPrompt: () => formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt: () => formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt: () => formatPriorReadsForPrompt,
   formatScope: () => formatScope,
   formatSlackSignalsForPrompt: () => formatSlackSignalsForPrompt,
   formatTeamExocorticesForPrompt: () => formatTeamExocorticesForPrompt,
+  getCacheDir: () => getCacheDir,
   getLens: () => getLens,
+  getRepoOrigin: () => getRepoOrigin,
   interpretPatterns: () => interpretPatterns,
   isPresent: () => isPresent,
   isScored: () => isScored,
   isSentinel: () => isSentinel,
   listLenses: () => listLenses,
+  loadExtendsConfig: () => loadExtendsConfig,
   loadPriorReads: () => loadPriorReads,
+  matchDeclaredPattern: () => matchDeclaredPattern,
+  parseExtendsSpec: () => parseExtendsSpec,
+  parseRemoteUrl: () => parseRemoteUrl,
   parseRepoScope: () => parseRepoScope,
   parseScope: () => parseScope,
   presenceAverage: () => presenceAverage,
   readExocortex: () => readExocortex,
+  readOriginRemote: () => readOriginRemote,
   readTeamExocortices: () => readTeamExocortices,
   render: () => render,
+  resolveAllExtends: () => resolveAllExtends,
+  resolveExtendsSpec: () => resolveExtendsSpec,
   scoreComposite: () => scoreComposite,
   scoreCyber: () => scoreCyber,
   scoreLife: () => scoreLife,
@@ -575,17 +589,17 @@ var aukiBuilderLens = {
 var SOVEREIGN_CONDUIT_FRAME = {
   domains: [
     "stewardship",
-    "sovereignty",
+    "agency",
     "integration"
   ],
   overlaps: [
     {
-      domains: ["stewardship", "sovereignty"],
+      domains: ["stewardship", "agency"],
       emergent_state: "Trust",
       description: "I am safe to be myself. When the system protects AND preserves individual authority, trust emerges \u2014 the feeling that you can think freely because someone is watching the boundaries."
     },
     {
-      domains: ["sovereignty", "integration"],
+      domains: ["agency", "integration"],
       emergent_state: "Possibility",
       description: "My thinking can expand. When individual authority is preserved AND AI extends cognitive capability, possibility opens \u2014 the feeling that you can reach further without losing yourself."
     },
@@ -616,7 +630,7 @@ var SOVEREIGN_CONDUIT_FRAME = {
       "harm detection",
       "constraint design"
     ],
-    "sovereignty": [
+    "agency": [
       "independent thinking",
       "decision ownership",
       "self-trust",
@@ -640,7 +654,7 @@ var SOVEREIGN_CONDUIT_FRAME = {
   output_translation: {
     never_surface_in_output: [
       "Stewardship",
-      "Sovereignty",
+      "Agency",
       "Integration"
     ],
     surface_freely: [
@@ -655,7 +669,7 @@ var SOVEREIGN_CONDUIT_FRAME = {
         external_expression: "the boundaries are clear and the system feels safe to operate inside"
       },
       {
-        internal_reasoning: "Sovereignty is weakening",
+        internal_reasoning: "Agency is weakening",
         external_expression: "decision ownership is quietly shifting \u2014 the human is accepting AI output without engaging with it"
       },
       {
@@ -738,12 +752,12 @@ var SOVEREIGN_CONDUIT_VOICE = {
   close_with_strategic_frame: "preferred",
   punchline_move: "sparing",
   honesty_about_failure: "required",
-  output_translation: `Reason internally through the three-domain frame (Stewardship, Sovereignty, Integration). Express externally through the skills inside each domain and the overlap feelings (Trust, Possibility, Responsibility). Do NOT surface the bucket names as labels. Readers understand "the boundaries feel safe" not "Stewardship is strong." Use everyday analogies \u2014 mom rules, friend's house rules, idea calculator. Name the emotion before the mechanism.`
+  output_translation: `Reason internally through the three-domain frame (Stewardship, Agency, Integration). Express externally through the skills inside each domain and the overlap feelings (Trust, Possibility, Responsibility). Do NOT surface the bucket names as labels. Readers understand "the boundaries feel safe" not "Stewardship is strong." Use everyday analogies \u2014 mom rules, friend's house rules, idea calculator. Name the emotion before the mechanism.`
 };
 var SOVEREIGN_CONDUIT_FORBIDDEN = Object.freeze([
   // Bucket names as labels
   "stewardship is",
-  "sovereignty is",
+  "agency is",
   "integration is",
   // AI-assistant hedging
   "it may be beneficial to consider",
@@ -779,7 +793,7 @@ var SOVEREIGN_CONDUIT_PREFERRED = Object.freeze([
   "Here's what's actually happening: [plain explanation].",
   "The question to ask yourself: [question].",
   "The difference between [A] and [B] matters here: [why].",
-  // Sovereignty checks
+  // Agency checks
   "Are you still the author of this decision, or did the AI make it for you?",
   "The AI extended your thinking here. That's working.",
   "The AI replaced your thinking here. That's the drift to watch.",
@@ -790,7 +804,7 @@ var SOVEREIGN_CONDUIT_PREFERRED = Object.freeze([
 ]);
 var SOVEREIGN_CONDUIT_STRATEGIC = Object.freeze([
   "Safety before expansion \u2014 always. No exception.",
-  "Sovereignty before convenience \u2014 the right to think for yourself is not a feature to optimize away.",
+  "Agency before convenience \u2014 the right to think for yourself is not a feature to optimize away.",
   "Extension, not replacement \u2014 AI should make your thinking bigger, not do your thinking for you.",
   "Diversity over uniformity \u2014 different thinkers produce different ideas, and that's the engine of progress.",
   "The rules should be visible \u2014 like a good house, you know the rules before you walk in.",
@@ -800,9 +814,9 @@ var SOVEREIGN_CONDUIT_STRATEGIC = Object.freeze([
 ]);
 var SOVEREIGN_CONDUIT_EXEMPLARS = Object.freeze([
   {
-    path: "neuroverseos-sovereign-conduit.worldmodel.md",
+    path: "src/radiant/examples/neuroverse-base/neuroverseos-sovereign-conduit.worldmodel.md",
     title: "The Sovereign Conduit Worldmodel",
-    exhibits: ["stewardship", "sovereignty", "integration"],
+    exhibits: ["stewardship", "agency", "integration"],
     integration_quality: "full \u2014 all three domains defined, overlaps named, center identity declared",
     notes: 'The source worldmodel. The tagline "Humanity first. In constant learning. In shared teaching." is the voice compressed to its essence. Use this as the north star for tone calibration.'
   }
@@ -828,13 +842,13 @@ function sovereignConduitRewrite(pattern) {
   return {
     ...pattern,
     framing: "what this means for the people in the system",
-    emphasis: "humanity + sovereignty + learning",
+    emphasis: "humanity + agency + learning",
     compress: false
   };
 }
 var sovereignConduitLens = {
   name: "sovereign-conduit",
-  description: "The NeuroVerseOS base lens. Warm, accessible, teaching. Evaluates activity through Stewardship (safety), Sovereignty (authority over thinking), and Integration (AI as cognitive extension). Uses everyday analogies \u2014 mom rules, friend's house, idea calculator. Names emotions before mechanisms. If a non-technical person can't understand the output, the voice is wrong. Humanity first. In constant learning. In shared teaching.",
+  description: "The NeuroVerseOS base lens. Warm, accessible, teaching. Evaluates activity through Stewardship (safety), Agency (authority over thinking), and Integration (AI as cognitive extension). Uses everyday analogies \u2014 mom rules, friend's house, idea calculator. Names emotions before mechanisms. If a non-technical person can't understand the output, the voice is wrong. Humanity first. In constant learning. In shared teaching.",
   primary_frame: {
     domains: SOVEREIGN_CONDUIT_FRAME.domains,
     overlaps: SOVEREIGN_CONDUIT_FRAME.overlaps,
@@ -2031,11 +2045,398 @@ async function fetchNotionAPI(url, headers, init) {
   return await res.json();
 }
 
+// src/radiant/adapters/linear.ts
+async function fetchLinearActivity(apiKey, options = {}) {
+  const windowDays = options.windowDays ?? 14;
+  const maxIssues = options.maxIssues ?? 200;
+  const since = new Date(Date.now() - windowDays * 24 * 60 * 60 * 1e3);
+  const sinceIso = since.toISOString();
+  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+  const teamFilter = options.teamIds && options.teamIds.length > 0 ? `team: { id: { in: [${options.teamIds.map((t) => JSON.stringify(t)).join(", ")}] } }` : "";
+  const issuesQuery = `
+    query RadiantIssues($since: DateTimeOrDuration!, $first: Int!) {
+      issues(
+        filter: {
+          updatedAt: { gte: $since }
+          ${teamFilter}
+        }
+        first: $first
+        orderBy: updatedAt
+      ) {
+        nodes {
+          id
+          identifier
+          title
+          url
+          createdAt
+          updatedAt
+          completedAt
+          canceledAt
+          state { name type }
+          assignee { id name email }
+          creator { id name }
+          team { id name }
+          project { id name }
+          cycle { id number startsAt endsAt }
+          comments(first: 20) {
+            nodes { id body createdAt user { id name } }
+          }
+        }
+      }
+    }
+  `;
+  const cyclesQuery = `
+    query RadiantCycles($since: DateTimeOrDuration!, $now: DateTimeOrDuration!) {
+      cycles(
+        filter: { endsAt: { gte: $since, lte: $now } }
+        first: 20
+      ) {
+        nodes {
+          id
+          number
+          startsAt
+          endsAt
+          issueCountHistory
+          completedIssueCountHistory
+          team { id name }
+        }
+      }
+    }
+  `;
+  const [issuesResponse, cyclesResponse] = await Promise.all([
+    fetchLinearGraphQL(apiKey, issuesQuery, {
+      since: sinceIso,
+      first: maxIssues
+    }),
+    fetchLinearGraphQL(apiKey, cyclesQuery, {
+      since: sinceIso,
+      now: nowIso
+    })
+  ]);
+  const rawIssues = issuesResponse.issues?.nodes ?? [];
+  const rawCycles = cyclesResponse.cycles?.nodes ?? [];
+  const events = [];
+  const assignees = /* @__PURE__ */ new Set();
+  const projects = /* @__PURE__ */ new Map();
+  let issuesCreated = 0;
+  let issuesCompleted = 0;
+  let issuesOpen = 0;
+  let issuesStalled = 0;
+  let commentsTotal = 0;
+  const now = Date.now();
+  const stallThresholdMs = 14 * 24 * 60 * 60 * 1e3;
+  for (const issue of rawIssues) {
+    const created = new Date(issue.createdAt);
+    const updated = new Date(issue.updatedAt);
+    const completed = issue.completedAt ? new Date(issue.completedAt) : null;
+    const assigneeId = issue.assignee?.id ?? "unassigned";
+    if (assigneeId !== "unassigned") assignees.add(assigneeId);
+    if (issue.project) {
+      projects.set(issue.project.name, (projects.get(issue.project.name) ?? 0) + 1);
+    }
+    const actor = {
+      id: assigneeId,
+      kind: "human",
+      name: issue.assignee?.name ?? "unassigned"
+    };
+    if (created >= since) {
+      issuesCreated++;
+      events.push({
+        id: `linear-created-${issue.id}`,
+        timestamp: issue.createdAt,
+        actor: {
+          id: issue.creator?.id ?? "unknown",
+          kind: "human",
+          name: issue.creator?.name ?? "unknown"
+        },
+        kind: "issue_created",
+        content: `[${issue.identifier}] ${issue.title}`,
+        metadata: {
+          issueId: issue.id,
+          url: issue.url,
+          team: issue.team?.name,
+          project: issue.project?.name,
+          state: issue.state?.name
+        }
+      });
+    }
+    if (completed && completed >= since) {
+      issuesCompleted++;
+      events.push({
+        id: `linear-completed-${issue.id}`,
+        timestamp: issue.completedAt,
+        actor,
+        kind: "issue_completed",
+        content: `[${issue.identifier}] ${issue.title}`,
+        metadata: {
+          issueId: issue.id,
+          url: issue.url,
+          team: issue.team?.name,
+          project: issue.project?.name,
+          cycleDays: issue.cycle?.startsAt && issue.completedAt ? Math.round(
+            (new Date(issue.completedAt).getTime() - new Date(issue.cycle.startsAt).getTime()) / (24 * 60 * 60 * 1e3)
+          ) : null
+        }
+      });
+    }
+    if (!completed && !issue.canceledAt) {
+      issuesOpen++;
+      const isInProgress = issue.state?.type === "started";
+      const idleMs = now - updated.getTime();
+      if (isInProgress && idleMs > stallThresholdMs) issuesStalled++;
+    }
+    for (const comment of issue.comments?.nodes ?? []) {
+      const commentedAt = new Date(comment.createdAt);
+      if (commentedAt < since) continue;
+      commentsTotal++;
+      events.push({
+        id: `linear-comment-${comment.id}`,
+        timestamp: comment.createdAt,
+        actor: {
+          id: comment.user?.id ?? "unknown",
+          kind: "human",
+          name: comment.user?.name ?? "unknown"
+        },
+        kind: "issue_comment",
+        content: comment.body.slice(0, 280),
+        metadata: {
+          issueId: issue.id,
+          issueIdentifier: issue.identifier,
+          url: issue.url
+        }
+      });
+    }
+  }
+  let cycleCompletionRate = null;
+  if (rawCycles.length > 0) {
+    const rates = [];
+    for (const cycle of rawCycles) {
+      const committed = cycle.issueCountHistory?.at(0) ?? 0;
+      const completed = cycle.completedIssueCountHistory?.at(-1) ?? 0;
+      if (committed > 0) rates.push(completed / committed);
+    }
+    if (rates.length > 0) {
+      cycleCompletionRate = Math.round(rates.reduce((a, b) => a + b, 0) / rates.length * 100) / 100;
+    }
+  }
+  const topProjects = [...projects.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([name]) => name);
+  const signals = {
+    issuesCreated,
+    issuesCompleted,
+    issuesOpen,
+    issuesStalled,
+    cycleCompletionRate,
+    uniqueAssignees: assignees.size,
+    commentsTotal,
+    topProjects
+  };
+  events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  return { events, signals };
+}
+function formatLinearSignalsForPrompt(signals) {
+  if (signals.issuesCreated === 0 && signals.issuesCompleted === 0 && signals.issuesOpen === 0) {
+    return "";
+  }
+  const lines = [
+    "## Linear Activity (planned work vs. shipped outcome)",
+    "",
+    `${signals.issuesCreated} issues created, ${signals.issuesCompleted} completed in window.`,
+    `${signals.issuesOpen} issues still open.`
+  ];
+  if (signals.issuesStalled > 0) {
+    lines.push(
+      `${signals.issuesStalled} in-progress issues haven't moved in 14+ days (stalled).`
+    );
+  }
+  if (signals.cycleCompletionRate !== null) {
+    const pct = Math.round(signals.cycleCompletionRate * 100);
+    lines.push(`Cycles ended in window completed ${pct}% of what was committed.`);
+  }
+  if (signals.uniqueAssignees > 0) {
+    lines.push(`${signals.uniqueAssignees} unique assignees active.`);
+  }
+  if (signals.commentsTotal > 0) {
+    lines.push(`${signals.commentsTotal} comments across issues in window.`);
+  }
+  if (signals.topProjects.length > 0) {
+    lines.push(`Most active projects: ${signals.topProjects.join(", ")}.`);
+  }
+  lines.push("");
+  lines.push("Linear is where the team states what it will build.");
+  lines.push("GitHub is where the team reveals what actually got built.");
+  lines.push("Low completion rate + high creation rate = planning faster than shipping.");
+  lines.push("High stalled count = commitments made but not honored.");
+  lines.push("Compare Linear signals against GitHub to find the stated-vs-shipped gap.");
+  return lines.join("\n");
+}
+async function fetchLinearGraphQL(apiKey, query, variables) {
+  const res = await fetch("https://api.linear.app/graphql", {
+    method: "POST",
+    headers: {
+      // Linear accepts the raw API key in Authorization with no "Bearer" prefix.
+      Authorization: apiKey,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ query, variables })
+  });
+  if (!res.ok) {
+    throw new Error(
+      `Linear API error ${res.status}: ${(await res.text()).slice(0, 300)}`
+    );
+  }
+  const json = await res.json();
+  if (json.errors && json.errors.length > 0) {
+    throw new Error(
+      `Linear GraphQL errors: ${json.errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (!json.data) {
+    throw new Error("Linear API returned no data");
+  }
+  return json.data;
+}
+
+// src/radiant/core/vocabulary.ts
+function extractDeclaredVocabulary(worldmodelContent) {
+  const aligned = extractSection(worldmodelContent, "Aligned Behaviors").map(
+    (b) => parseBehavior(b, "aligned")
+  );
+  const drift = extractSection(worldmodelContent, "Drift Behaviors").map(
+    (b) => parseBehavior(b, "drift")
+  );
+  const allNames = [...aligned, ...drift].map((p) => p.name);
+  return { aligned, drift, allNames };
+}
+function extractSection(content, header) {
+  const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##\\s|$)`,
+    "i"
+  );
+  const match = content.match(pattern);
+  if (!match) return [];
+  const body = match[1];
+  const bullets = body.match(/^[-*]\s+.+$/gm);
+  if (!bullets) return [];
+  return bullets.map((b) => b.replace(/^[-*]\s+/, "").trim()).filter((b) => b.length > 0 && !b.startsWith("<!--"));
+}
+function parseBehavior(bullet, kind) {
+  const explicit = bullet.match(
+    /^`?([a-z][a-z0-9_]*)`?\s+[—\u2014-]\s+(.+)$/i
+  );
+  if (explicit && isSnakeCase(explicit[1])) {
+    return {
+      name: explicit[1].toLowerCase(),
+      prose: explicit[2].trim(),
+      kind
+    };
+  }
+  return { name: snakeCaseName(bullet), prose: bullet, kind };
+}
+function isSnakeCase(s) {
+  return /^[a-z][a-z0-9_]*$/.test(s);
+}
+function snakeCaseName(s) {
+  const base = s.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  if (base.length <= 60) return base;
+  const truncated = base.slice(0, 60);
+  const lastUnderscore = truncated.lastIndexOf("_");
+  return lastUnderscore > 20 ? truncated.slice(0, lastUnderscore) : truncated;
+}
+function matchDeclaredPattern(candidateName, candidateDescription, vocabulary) {
+  const candidateText = `${candidateName.replace(/_/g, " ")} ${candidateDescription}`;
+  const candidateWords = contentWords(candidateText);
+  if (candidateWords.size === 0) return null;
+  let best = null;
+  for (const pattern of [...vocabulary.aligned, ...vocabulary.drift]) {
+    const proseWords = contentWords(pattern.prose);
+    if (proseWords.size === 0) continue;
+    let shared = 0;
+    for (const w of proseWords) {
+      if (candidateWords.has(w)) shared++;
+    }
+    const coverage = shared / proseWords.size;
+    if (shared >= 2 && coverage >= 0.3) {
+      if (!best || coverage > best.score) {
+        best = { pattern, score: coverage };
+      }
+    }
+  }
+  return best?.pattern ?? null;
+}
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "against",
+  "among",
+  "around",
+  "because",
+  "been",
+  "before",
+  "being",
+  "between",
+  "both",
+  "could",
+  "does",
+  "doing",
+  "during",
+  "each",
+  "from",
+  "further",
+  "have",
+  "having",
+  "into",
+  "itself",
+  "most",
+  "nor",
+  "only",
+  "other",
+  "over",
+  "same",
+  "should",
+  "some",
+  "such",
+  "than",
+  "that",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "under",
+  "until",
+  "very",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "while",
+  "will",
+  "with",
+  "without",
+  "would",
+  "your",
+  "yours"
+]);
+function contentWords(text) {
+  const words = text.toLowerCase().match(/[a-z][a-z0-9_]+/g) ?? [];
+  return new Set(words.filter((w) => w.length > 3 && !STOPWORDS.has(w)));
+}
+
 // 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 ?? []);
+  const canonicalNames = [
+    ...input.canonicalPatterns ?? [],
+    ...input.declaredVocabulary?.allNames ?? []
+  ];
+  const parsed = parseInterpretation(raw, canonicalNames, input.declaredVocabulary);
   return {
     patterns: parsed.patterns,
     meaning: parsed.meaning,
@@ -2046,8 +2447,10 @@ async function interpretPatterns(input) {
 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 canonicalList = formatDeclaredVocabulary(
+    input.declaredVocabulary,
+    input.canonicalPatterns ?? []
+  );
   const compressedWorld = compressWorldmodel(input.worldmodelContent);
   const cl = compressLens(input.lens);
   const frame = input.lens.primary_frame;
@@ -2158,6 +2561,44 @@ Only recommend a move when the evidence actually calls for one.
 Do NOT use these phrases anywhere in your output:
 ${forbiddenList}`;
 }
+function formatDeclaredVocabulary(vocabulary, extraNames) {
+  const aligned = vocabulary?.aligned ?? [];
+  const drift = vocabulary?.drift ?? [];
+  if (aligned.length === 0 && drift.length === 0 && extraNames.length === 0) {
+    return 'No patterns have been named yet. Everything you observe is new \u2014 mark it type: "candidate".';
+  }
+  const parts = [];
+  parts.push("## Declared vocabulary (use these names when you see matching evidence)");
+  parts.push("");
+  parts.push(
+    'The worldmodel declares the patterns below. If your observation matches one of these, use the EXACT snake_case name shown and mark type: "canonical" \u2014 do not invent a new name for something that already has one.'
+  );
+  parts.push("");
+  if (aligned.length > 0) {
+    parts.push("### Aligned behaviors (positive patterns)");
+    for (const p of aligned) {
+      parts.push(`- \`${p.name}\` \u2014 ${p.prose}`);
+    }
+    parts.push("");
+  }
+  if (drift.length > 0) {
+    parts.push("### Drift behaviors (negative patterns)");
+    for (const p of drift) {
+      parts.push(`- \`${p.name}\` \u2014 ${p.prose}`);
+    }
+    parts.push("");
+  }
+  if (extraNames.length > 0) {
+    parts.push(
+      `Additional canonical names (from prior runs or caller): ${extraNames.join(", ")}`
+    );
+    parts.push("");
+  }
+  parts.push(
+    'If you observe something genuinely new that matches NO declared pattern, mark it type: "candidate" with a freshly-invented snake_case name.'
+  );
+  return parts.join("\n");
+}
 function formatSignalSummary(signals) {
   const lines = [];
   const domains = ["life", "cyber", "joint"];
@@ -2183,7 +2624,7 @@ function formatEventSample(events, maxEvents) {
   "${content}"`;
   }).join("\n");
 }
-function parseInterpretation(raw, canonicalNames) {
+function parseInterpretation(raw, canonicalNames, vocabulary) {
   let meaning = "";
   let move = "";
   let patternsArray = [];
@@ -2213,14 +2654,23 @@ function parseInterpretation(raw, canonicalNames) {
   const patterns = [];
   for (const item of patternsArray) {
     if (!isPatternLike(item)) continue;
-    const nameStr = String(item.name ?? "unnamed");
+    const rawName = String(item.name ?? "unnamed");
+    const description = String(item.description ?? "");
     const ev = item.evidence;
-    const isCanonical = item.type === "canonical" || canonicalSet.has(nameStr.toLowerCase());
+    let name = rawName;
+    let isCanonical = item.type === "canonical" || canonicalSet.has(rawName.toLowerCase());
+    if (!isCanonical && vocabulary) {
+      const matched = matchDeclaredPattern(rawName, description, vocabulary);
+      if (matched) {
+        name = matched.name;
+        isCanonical = true;
+      }
+    }
     patterns.push({
-      name: nameStr,
+      name,
       type: isCanonical ? "canonical" : "candidate",
-      declaredAs: isCanonical ? nameStr : void 0,
-      description: String(item.description ?? ""),
+      declaredAs: isCanonical ? name : void 0,
+      description,
       evidence: {
         signals: Array.isArray(ev?.signals) ? ev.signals.map(String) : [],
         events: Array.isArray(ev?.events) ? ev.events.map(String) : [],
@@ -2467,70 +2917,351 @@ function serializeYAML(obj, indent = 0) {
 }
 
 // src/radiant/core/discovery.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
+var import_os2 = require("os");
+
+// src/radiant/core/extends.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os = require("os");
+var import_crypto = require("crypto");
+var import_child_process = require("child_process");
+
+// src/radiant/core/git-remote.ts
 var import_fs2 = require("fs");
 var import_path2 = require("path");
-var import_os = require("os");
+function resolveGitConfigPath(repoDir) {
+  const dotGit = (0, import_path2.join)(repoDir, ".git");
+  if (!(0, import_fs2.existsSync)(dotGit)) return null;
+  try {
+    const stat = (0, import_fs2.statSync)(dotGit);
+    if (stat.isDirectory()) {
+      return (0, import_path2.join)(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = (0, import_fs2.readFileSync)(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = (0, import_path2.resolve)(repoDir, match[1].trim());
+      const configPath = (0, import_path2.join)(gitDir, "config");
+      return (0, import_fs2.existsSync)(configPath) ? configPath : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readOriginRemote(repoDir) {
+  const configPath = resolveGitConfigPath(repoDir);
+  if (!configPath) return null;
+  try {
+    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
+    const sectionRe = /\[remote "origin"\]\s*\n((?:(?!\[)[^\n]*\n?)*)/;
+    const section = sectionRe.exec(raw);
+    if (!section) return null;
+    const urlRe = /^\s*url\s*=\s*(.+?)\s*$/m;
+    const url = urlRe.exec(section[1]);
+    return url ? url[1] : null;
+  } catch {
+    return null;
+  }
+}
+function parseRemoteUrl(url) {
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const ssh = /^git@([^:]+):([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (ssh) return { host: ssh[1], owner: ssh[2], repo: ssh[3] };
+  const sshProto = /^ssh:\/\/git@([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (sshProto) return { host: sshProto[1], owner: sshProto[2], repo: sshProto[3] };
+  const https = /^https?:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(trimmed);
+  if (https) return { host: https[1], owner: https[2], repo: https[3] };
+  return null;
+}
+function getRepoOrigin(repoDir) {
+  const url = readOriginRemote(repoDir);
+  if (!url) return null;
+  return parseRemoteUrl(url);
+}
+
+// src/radiant/core/extends.ts
+function loadExtendsConfig(repoDir) {
+  const configPath = (0, import_path3.join)(repoDir, ".neuroverse", "config.json");
+  if (!(0, import_fs3.existsSync)(configPath)) return null;
+  try {
+    const raw = (0, import_fs3.readFileSync)(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function parseExtendsSpec(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("github:")) {
+    const rest = trimmed.slice("github:".length);
+    const match = /^([^/]+)\/([^@:]+)(?:@([^:]+))?(?::(.+))?$/.exec(rest);
+    if (!match) return null;
+    return {
+      raw: trimmed,
+      kind: "github",
+      owner: match[1],
+      repo: match[2],
+      ref: match[3] ?? "HEAD",
+      subpath: match[4] ?? ""
+    };
+  }
+  if (trimmed.startsWith("./") || trimmed.startsWith("../") || (0, import_path3.isAbsolute)(trimmed)) {
+    return { raw: trimmed, kind: "local", path: trimmed };
+  }
+  return null;
+}
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+function getCacheDir(spec, baseCacheDir) {
+  const root = baseCacheDir ?? (0, import_path3.join)((0, import_os.homedir)(), ".neuroverse", "cache", "extends");
+  const key = (0, import_crypto.createHash)("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return (0, import_path3.join)(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = (0, import_path3.join)(cacheDir, ".neuroverse-fetched");
+  if (!(0, import_fs3.existsSync)(stampPath)) return false;
+  try {
+    const stamp = (0, import_fs3.statSync)(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = (0, import_path3.join)(cacheDir, ".neuroverse-fetched");
+  try {
+    (0, import_fs3.mkdirSync)(cacheDir, { recursive: true });
+    (0, import_fs3.writeFileSync)(stampPath, (/* @__PURE__ */ new Date()).toISOString());
+  } catch {
+  }
+}
+var defaultGitFetcher = (spec, destDir) => {
+  if (spec.kind !== "github") return;
+  const url = `https://github.com/${spec.owner}/${spec.repo}.git`;
+  const parent = (0, import_path3.resolve)(destDir, "..");
+  (0, import_fs3.mkdirSync)(parent, { recursive: true });
+  if ((0, import_fs3.existsSync)(destDir)) {
+    (0, import_fs3.rmSync)(destDir, { recursive: true, force: true });
+  }
+  const args = ["clone", "--depth", "1", "--filter=blob:none"];
+  if (spec.ref && spec.ref !== "HEAD") {
+    args.push("--branch", spec.ref);
+  }
+  args.push(url, destDir);
+  (0, import_child_process.execFileSync)("git", args, { stdio: "pipe" });
+};
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = (0, import_path3.isAbsolute)(spec.path) ? spec.path : (0, import_path3.resolve)(repoDir, spec.path);
+    if (!(0, import_fs3.existsSync)(full)) {
+      return { spec, dir: null, warning: `local extends path not found: ${full}` };
+    }
+    return { spec, dir: full };
+  }
+  const cacheRoot = options?.cacheDir;
+  const ttl = options?.ttlMs ?? DEFAULT_TTL_MS;
+  const cacheDir = getCacheDir(spec, cacheRoot);
+  const fresh = isCacheFresh(cacheDir, ttl);
+  const needsFetch = options?.forceRefresh || !fresh || !(0, import_fs3.existsSync)(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if ((0, import_fs3.existsSync)(cacheDir) && (0, import_fs3.existsSync)((0, import_path3.join)(cacheDir, ".neuroverse-fetched"))) {
+      return resolveSubpath(spec, cacheDir);
+    }
+    return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `NEUROVERSE_NO_FETCH set and no cache for ${spec.raw}` };
+  }
+  if (needsFetch) {
+    const fetcher = options?.fetcher ?? defaultGitFetcher;
+    try {
+      fetcher(spec, cacheDir);
+      markCacheFresh(cacheDir);
+    } catch (err) {
+      if ((0, import_fs3.existsSync)(cacheDir) && (0, import_fs3.existsSync)((0, import_path3.join)(cacheDir, ".neuroverse-fetched"))) {
+        const result = resolveSubpath(spec, cacheDir);
+        return options?.silentOnMissing ? result : { ...result, warning: `fetch failed for ${spec.raw}, using stale cache: ${err.message}` };
+      }
+      return options?.silentOnMissing ? { spec, dir: null } : { spec, dir: null, warning: `fetch failed for ${spec.raw}: ${err.message}` };
+    }
+  }
+  return resolveSubpath(spec, cacheDir);
+}
+function resolveSubpath(spec, cacheDir) {
+  const target = spec.subpath ? (0, import_path3.join)(cacheDir, spec.subpath) : cacheDir;
+  if (!(0, import_fs3.existsSync)(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      (0, import_path3.join)(target, "worlds"),
+      (0, import_path3.join)(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if ((0, import_fs3.existsSync)(c)) return { spec, dir: c };
+    }
+  }
+  return { spec, dir: target };
+}
+function detectOrgExtendsSpec(repoDir) {
+  const origin = getRepoOrigin(repoDir);
+  if (!origin) return null;
+  if (origin.host !== "github.com") return null;
+  if (origin.repo === "worlds") return null;
+  return {
+    raw: `github:${origin.owner}/worlds`,
+    kind: "github",
+    owner: origin.owner,
+    repo: "worlds",
+    ref: "HEAD",
+    subpath: ""
+  };
+}
+function resolveAllExtends(repoDir, options) {
+  const config = options?.config !== void 0 ? options.config : loadExtendsConfig(repoDir);
+  if (!config?.extends || config.extends.length === 0) return [];
+  const results = [];
+  for (const raw of config.extends) {
+    const spec = parseExtendsSpec(raw);
+    if (!spec) {
+      results.push({
+        spec: { raw, kind: "local" },
+        dir: null,
+        warning: `unparseable extends spec: ${raw}`
+      });
+      continue;
+    }
+    results.push(resolveExtendsSpec(spec, repoDir, options));
+  }
+  return results;
+}
+
+// src/radiant/core/discovery.ts
 function discoverWorlds(options) {
   const worlds = [];
-  const userDir = options?.userWorldsDir ?? (0, import_path2.join)((0, import_os.homedir)(), ".neuroverse", "worlds");
-  if ((0, import_fs2.existsSync)(userDir)) {
+  const warnings = [];
+  const forceRefresh = process.env.NEUROVERSE_REFRESH === "1";
+  const noFetch = process.env.NEUROVERSE_NO_FETCH === "1";
+  const noOrg = options?.disableOrg || process.env.NEUROVERSE_NO_ORG === "1";
+  const userDir = options?.userWorldsDir ?? (0, import_path4.join)((0, import_os2.homedir)(), ".neuroverse", "worlds");
+  if ((0, import_fs4.existsSync)(userDir)) {
     worlds.push(...loadWorldsFromDir(userDir, "user"));
   }
+  if (!noOrg && !options?.explicitWorldsDir) {
+    const specs = [];
+    if (options?.repoDir) {
+      const fromGit = detectOrgExtendsSpec(options.repoDir);
+      if (fromGit) specs.push(fromGit);
+    }
+    if (options?.scopeOwner) {
+      const already = specs.some(
+        (s) => s.owner?.toLowerCase() === options.scopeOwner.toLowerCase()
+      );
+      if (!already) {
+        specs.push({
+          raw: `github:${options.scopeOwner}/worlds`,
+          kind: "github",
+          owner: options.scopeOwner,
+          repo: "worlds"
+        });
+      }
+    }
+    const baseDir = options?.repoDir ?? process.cwd();
+    for (const spec of specs) {
+      const result = resolveExtendsSpec(spec, baseDir, {
+        cacheDir: options?.extendsCacheDir,
+        fetcher: options?.extendsFetcher,
+        ttlMs: options?.extendsTtlMs,
+        forceRefresh,
+        noFetch,
+        silentOnMissing: true
+      });
+      worlds.push(...loadExtendsWorlds(result, "org"));
+    }
+  }
+  if (options?.repoDir && !options.disableExtends && !options.explicitWorldsDir) {
+    const results = resolveAllExtends(options.repoDir, {
+      cacheDir: options.extendsCacheDir,
+      fetcher: options.extendsFetcher,
+      ttlMs: options.extendsTtlMs,
+      forceRefresh,
+      noFetch
+    });
+    for (const result of results) {
+      worlds.push(...loadExtendsWorlds(result, "extends"));
+      if (result.warning) warnings.push(result.warning);
+    }
+  }
   if (options?.explicitWorldsDir) {
     worlds.push(...loadWorldsFromDir(options.explicitWorldsDir, "repo"));
   } else if (options?.repoDir) {
     const repoPaths = [
-      (0, import_path2.join)(options.repoDir, "worlds"),
-      (0, import_path2.join)(options.repoDir, ".neuroverse", "worlds")
+      (0, import_path4.join)(options.repoDir, "worlds"),
+      (0, import_path4.join)(options.repoDir, ".neuroverse", "worlds")
     ];
     for (const p of repoPaths) {
-      if ((0, import_fs2.existsSync)(p)) {
+      if ((0, import_fs4.existsSync)(p)) {
         worlds.push(...loadWorldsFromDir(p, "repo"));
         break;
       }
     }
   }
-  const combinedContent = worlds.map((w) => `<!-- world: ${w.name} (${w.source}) -->
-${w.content}`).join("\n\n---\n\n");
+  const combinedContent = worlds.map((w) => {
+    const tag = w.extendsFrom ? `<!-- world: ${w.name} (${w.source} ${w.extendsFrom}) -->` : `<!-- world: ${w.name} (${w.source}) -->`;
+    return `${tag}
+${w.content}`;
+  }).join("\n\n---\n\n");
   const summary = worlds.length === 0 ? "no worlds discovered" : worlds.map((w) => `${w.name} (${w.source})`).join(", ");
-  return { worlds, combinedContent, summary };
+  return { worlds, combinedContent, summary, warnings };
 }
 function formatActiveWorlds(stack) {
   if (stack.worlds.length === 0) return "No worlds loaded.";
   const lines = ["ACTIVE WORLDS", ""];
   for (const w of stack.worlds) {
-    const sourceLabel = w.source === "base" ? "universal" : w.source === "user" ? "personal" : "this repo";
+    const sourceLabel = w.source === "base" ? "universal" : w.source === "user" ? "personal" : w.source === "org" ? `org (${w.extendsFrom ?? "auto"})` : w.source === "extends" ? `shared (${w.extendsFrom ?? "extends"})` : "this repo";
     lines.push(`  ${w.name} (${sourceLabel})`);
   }
+  if (stack.warnings.length > 0) {
+    lines.push("", "WARNINGS");
+    for (const w of stack.warnings) lines.push(`  ${w}`);
+  }
   return lines.join("\n");
 }
+function loadExtendsWorlds(result, source) {
+  if (!result.dir) return [];
+  const loaded = loadWorldsFromDir(result.dir, source);
+  return loaded.map((w) => ({ ...w, extendsFrom: result.spec.raw }));
+}
 function loadWorldsFromDir(dirPath, source) {
-  const dir = (0, import_path2.resolve)(dirPath);
-  if (!(0, import_fs2.existsSync)(dir)) return [];
-  const stat = (0, import_fs2.statSync)(dir);
+  const dir = (0, import_path4.resolve)(dirPath);
+  if (!(0, import_fs4.existsSync)(dir)) return [];
+  const stat = (0, import_fs4.statSync)(dir);
   if (stat.isFile() && dir.endsWith(".md")) {
     try {
       return [{
-        name: (0, import_path2.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
+        name: (0, import_path4.basename)(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
         source,
         path: dir,
-        content: (0, import_fs2.readFileSync)(dir, "utf-8")
+        content: (0, import_fs4.readFileSync)(dir, "utf-8")
       }];
     } catch {
       return [];
     }
   }
   if (!stat.isDirectory()) return [];
-  const files = (0, import_fs2.readdirSync)(dir).filter(
+  const files = (0, import_fs4.readdirSync)(dir).filter(
     (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
   ).sort();
   return files.map((f) => {
-    const fullPath = (0, import_path2.join)(dir, f);
+    const fullPath = (0, import_path4.join)(dir, f);
     return {
       name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
       source,
       path: fullPath,
-      content: (0, import_fs2.readFileSync)(fullPath, "utf-8")
+      content: (0, import_fs4.readFileSync)(fullPath, "utf-8")
     };
   });
 }
@@ -3621,10 +4352,10 @@ function verdictToEvent(status, intent) {
 // src/loader/world-loader.ts
 async function loadWorldFromDirectory(dirPath) {
   const { readFile } = await import("fs/promises");
-  const { join: join4 } = await import("path");
+  const { join: join6 } = await import("path");
   const { readdirSync: readdirSync4 } = await import("fs");
   async function readJson(filename) {
-    const filePath = join4(dirPath, filename);
+    const filePath = join6(dirPath, filename);
     try {
       const content = await readFile(filePath, "utf-8");
       return JSON.parse(content);
@@ -3654,11 +4385,11 @@ async function loadWorldFromDirectory(dirPath) {
   const metadataJson = await readJson("metadata.json");
   const rules = [];
   try {
-    const rulesDir = join4(dirPath, "rules");
+    const rulesDir = join6(dirPath, "rules");
     const ruleFiles = readdirSync4(rulesDir).filter((f) => f.endsWith(".json")).sort();
     for (const file of ruleFiles) {
       try {
-        const content = await readFile(join4(rulesDir, file), "utf-8");
+        const content = await readFile(join6(rulesDir, file), "utf-8");
         rules.push(JSON.parse(content));
       } catch (err) {
         process.stderr.write(
@@ -3818,25 +4549,25 @@ function emptyAudit(total, reason) {
 }
 
 // src/radiant/memory/palace.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
-  (0, import_fs3.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant", "reads");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = (0, import_path3.join)(dir, filename);
+  const filepath = (0, import_path5.join)(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  (0, import_fs3.writeFileSync)(filepath, content, "utf-8");
+  (0, import_fs5.writeFileSync)(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant");
-  (0, import_fs3.mkdirSync)(dir, { recursive: true });
-  const filepath = (0, import_path3.join)(dir, "knowledge.md");
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant");
+  (0, import_fs5.mkdirSync)(dir, { recursive: true });
+  const filepath = (0, import_path5.join)(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -3923,14 +4654,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  (0, import_fs3.writeFileSync)(filepath, lines.join("\n"), "utf-8");
+  (0, import_fs5.writeFileSync)(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!(0, import_fs3.existsSync)(filepath)) return counts;
+  if (!(0, import_fs5.existsSync)(filepath)) return counts;
   try {
-    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -3948,13 +4679,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = (0, import_path3.resolve)(exocortexDir, "radiant", "reads");
-  if (!(0, import_fs3.existsSync)(dir)) return [];
-  const files = (0, import_fs3.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
+  const dir = (0, import_path5.resolve)(exocortexDir, "radiant", "reads");
+  if (!(0, import_fs5.existsSync)(dir)) return [];
+  const files = (0, import_fs5.readdirSync)(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = (0, import_path3.join)(dir, filename);
-    const content = (0, import_fs3.readFileSync)(filepath, "utf-8");
+    const filepath = (0, import_path5.join)(dir, filename);
+    const content = (0, import_fs5.readFileSync)(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -4118,10 +4849,24 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     } catch {
     }
   }
+  const linearKey = process.env.LINEAR_API_KEY;
+  if (linearKey) {
+    try {
+      const linear = await fetchLinearActivity(linearKey, { windowDays });
+      events.push(...linear.events);
+      adapterSignals += "\n\n" + formatLinearSignalsForPrompt(linear.signals);
+      activeAdapters.push("linear");
+    } catch {
+    }
+  }
   events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+  if (input.personalUser) {
+    events = filterEventsByUser(events, input.personalUser);
+  }
   const classified = classifyEvents(events);
   const signals = extractSignals(classified);
   const scores = computeScores(signals, input.worldmodelContent !== "");
+  const declaredVocabulary = extractDeclaredVocabulary(worldmodelContent);
   const { patterns, meaning, move } = await interpretPatterns({
     signals,
     events: classified,
@@ -4129,6 +4874,7 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     lens,
     ai: input.ai,
     canonicalPatterns: input.canonicalPatterns,
+    declaredVocabulary,
     statedIntent: [statedIntent, adapterSignals, priorReadContext].filter(Boolean).join("\n\n") || void 0
   });
   const rewrittenPatterns = patterns.map((p) => lens.rewrite(p));
@@ -4183,6 +4929,10 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     worldStack
   };
 }
+function filterEventsByUser(events, username) {
+  const target = username.toLowerCase();
+  return events.filter((e) => e.actor.id.toLowerCase() === target);
+}
 function computeScores(signals, worldmodelLoaded) {
   const gate = DEFAULT_EVIDENCE_GATE;
   const lifeSignals = signals.filter((s) => s.domain === "life");
@@ -4253,35 +5003,49 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   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,