@neuroverseos/governance 0.9.0 → 0.11.0

package/dist/radiant/index.cjs

@@ -51,15 +51,19 @@ __export(radiant_exports, {
   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,
@@ -75,6 +79,7 @@ __export(radiant_exports, {
   listLenses: () => listLenses,
   loadExtendsConfig: () => loadExtendsConfig,
   loadPriorReads: () => loadPriorReads,
+  matchDeclaredPattern: () => matchDeclaredPattern,
   parseExtendsSpec: () => parseExtendsSpec,
   parseRemoteUrl: () => parseRemoteUrl,
   parseRepoScope: () => parseRepoScope,
@@ -2040,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,
@@ -2055,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;
@@ -2167,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"];
@@ -2192,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 = [];
@@ -2222,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) : [],
@@ -3119,8 +3560,26 @@ function isExternalScope(scope) {
   ];
   return !internalPatterns.some((p) => p.test(scope));
 }
-var MAX_INPUT_LENGTH = 1e5;
 function evaluateGuard(event, world, options = {}) {
+  const verdict = evaluateGuardCore(event, world, options);
+  return options.mode === "observe" ? toShadowVerdict(verdict) : verdict;
+}
+function toShadowVerdict(verdict) {
+  if (verdict.status === "ALLOW") return verdict;
+  return {
+    ...verdict,
+    status: "ALLOW",
+    shadowStatus: verdict.status,
+    shadowReason: verdict.reason,
+    // Preserve the original reason as shadowReason and wipe the
+    // top-level reason so callers that display `reason` for BLOCK/PAUSE
+    // don't accidentally surface an enforcement message.
+    reason: void 0,
+    warning: verdict.reason ? `Observe mode: would have ${verdict.status.toLowerCase()} \u2014 ${verdict.reason}` : `Observe mode: would have ${verdict.status.toLowerCase()}`
+  };
+}
+var MAX_INPUT_LENGTH = 1e5;
+function evaluateGuardCore(event, world, options = {}) {
   const startTime = performance.now();
   const level = options.level ?? "standard";
   const includeTrace = options.trace ?? false;
@@ -4010,6 +4469,7 @@ async function auditGovernance(events, worldPath) {
     return emptyAudit(events.length, "Could not load compiled worldmodel for governance audit.");
   }
   const verdicts = [];
+  const crossings = [];
   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;
@@ -4020,16 +4480,32 @@ async function auditGovernance(events, worldPath) {
           scope,
           actionCategory: mapKindToCategory(ce.event.kind)
         },
-        world
+        world,
+        { mode: "observe" }
       );
+      const shadow = result.shadowStatus ?? "ALLOW";
       verdicts.push({
         eventId: ce.event.id,
         domain: ce.domain,
-        status: result.status,
-        reason: result.reason,
+        status: shadow,
+        reason: result.shadowReason,
         ruleId: result.ruleId,
         warning: result.warning
       });
+      if (shadow !== "ALLOW") {
+        crossings.push({
+          eventId: ce.event.id,
+          timestamp: ce.event.timestamp,
+          kind: ce.event.kind,
+          actorId: ce.event.actor.id,
+          shadowStatus: shadow,
+          shadowReason: result.shadowReason,
+          ruleId: result.ruleId,
+          excerpt: intent.length > 280 ? intent.slice(0, 279) + "\u2026" : intent,
+          wouldHaveBlocked: true,
+          verdict: result
+        });
+      }
     } catch {
       verdicts.push({
         eventId: ce.event.id,
@@ -4048,6 +4524,7 @@ async function auditGovernance(events, worldPath) {
     human,
     cyber,
     joint,
+    crossings,
     summary
   };
 }
@@ -4103,6 +4580,7 @@ function emptyAudit(total, reason) {
     human: { allow: 0, modify: 0, block: 0, details: [] },
     cyber: { allow: 0, modify: 0, block: 0, details: [] },
     joint: { allow: 0, modify: 0, block: 0, details: [] },
+    crossings: [],
     summary: reason
   };
 }
@@ -4408,10 +4886,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,
@@ -4419,6 +4911,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));
@@ -4470,9 +4963,14 @@ Compare stated intent against actual GitHub activity. Gaps = drift.`;
     scores,
     eventCount: events.length,
     activeAdapters,
-    worldStack
+    worldStack,
+    governance
   };
 }
+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");
@@ -4546,15 +5044,19 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   detectOrgExtendsSpec,
   discoverWorlds,
   emergent,
+  extractDeclaredVocabulary,
   extractSignals,
   fetchDiscordActivity,
   fetchGitHubActivity,
   fetchGitHubOrgActivity,
+  fetchLinearActivity,
   fetchNotionActivity,
   fetchSlackActivity,
+  filterEventsByUser,
   formatActiveWorlds,
   formatDiscordSignalsForPrompt,
   formatExocortexForPrompt,
+  formatLinearSignalsForPrompt,
   formatNotionSignalsForPrompt,
   formatPriorReadsForPrompt,
   formatScope,
@@ -4570,6 +5072,7 @@ var RADIANT_PACKAGE_VERSION = "0.0.0";
   listLenses,
   loadExtendsConfig,
   loadPriorReads,
+  matchDeclaredPattern,
   parseExtendsSpec,
   parseRemoteUrl,
   parseRepoScope,