@neuroverseos/governance 0.8.1 → 0.10.0

package/dist/{chunk-ETDIEVAX.js → chunk-BZYQHJDM.js}

@@ -1,6 +1,6 @@
 import {
   getLens
-} from "./chunk-F2LWMOM5.js";
+} from "./chunk-TCGGED4G.js";
 import {
   loadWorld
 } from "./chunk-I4RTIMLX.js";
@@ -859,55 +859,583 @@ async function fetchNotionAPI(url, headers, init) {
   return await res.json();
 }
 
-// src/radiant/core/discovery.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { join, resolve, basename } from "path";
+// 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/git-remote.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { join, resolve } from "path";
+function resolveGitConfigPath(repoDir) {
+  const dotGit = join(repoDir, ".git");
+  if (!existsSync(dotGit)) return null;
+  try {
+    const stat = statSync(dotGit);
+    if (stat.isDirectory()) {
+      return join(dotGit, "config");
+    }
+    if (stat.isFile()) {
+      const content = readFileSync(dotGit, "utf-8");
+      const match = /^gitdir:\s*(.+)$/m.exec(content);
+      if (!match) return null;
+      const gitDir = resolve(repoDir, match[1].trim());
+      const configPath = join(gitDir, "config");
+      return existsSync(configPath) ? configPath : null;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function readOriginRemote(repoDir) {
+  const configPath = resolveGitConfigPath(repoDir);
+  if (!configPath) return null;
+  try {
+    const raw = 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
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, statSync as statSync2, writeFileSync } from "fs";
+import { join as join2, resolve as resolve2, isAbsolute } from "path";
 import { homedir } from "os";
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
+function loadExtendsConfig(repoDir) {
+  const configPath = join2(repoDir, ".neuroverse", "config.json");
+  if (!existsSync2(configPath)) return null;
+  try {
+    const raw = readFileSync2(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("../") || 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 ?? join2(homedir(), ".neuroverse", "cache", "extends");
+  const key = createHash("sha256").update(spec.raw).digest("hex").slice(0, 16);
+  return join2(root, key);
+}
+function isCacheFresh(cacheDir, ttlMs) {
+  const stampPath = join2(cacheDir, ".neuroverse-fetched");
+  if (!existsSync2(stampPath)) return false;
+  try {
+    const stamp = statSync2(stampPath);
+    return Date.now() - stamp.mtimeMs < ttlMs;
+  } catch {
+    return false;
+  }
+}
+function markCacheFresh(cacheDir) {
+  const stampPath = join2(cacheDir, ".neuroverse-fetched");
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    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 = resolve2(destDir, "..");
+  mkdirSync(parent, { recursive: true });
+  if (existsSync2(destDir)) {
+    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);
+  execFileSync("git", args, { stdio: "pipe" });
+};
+function resolveExtendsSpec(spec, repoDir, options) {
+  if (spec.kind === "local") {
+    const full = isAbsolute(spec.path) ? spec.path : resolve2(repoDir, spec.path);
+    if (!existsSync2(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 || !existsSync2(cacheDir);
+  if (needsFetch && options?.noFetch) {
+    if (existsSync2(cacheDir) && existsSync2(join2(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 (existsSync2(cacheDir) && existsSync2(join2(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 ? join2(cacheDir, spec.subpath) : cacheDir;
+  if (!existsSync2(target)) {
+    return { spec, dir: null, warning: `subpath not found in ${spec.raw}: ${spec.subpath}` };
+  }
+  if (!spec.subpath) {
+    const candidates = [
+      join2(target, "worlds"),
+      join2(target, ".neuroverse", "worlds")
+    ];
+    for (const c of candidates) {
+      if (existsSync2(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
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { join as join3, resolve as resolve3, basename } from "path";
+import { homedir as homedir2 } from "os";
 function discoverWorlds(options) {
   const worlds = [];
-  const userDir = options?.userWorldsDir ?? join(homedir(), ".neuroverse", "worlds");
-  if (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 ?? join3(homedir2(), ".neuroverse", "worlds");
+  if (existsSync3(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 = [
-      join(options.repoDir, "worlds"),
-      join(options.repoDir, ".neuroverse", "worlds")
+      join3(options.repoDir, "worlds"),
+      join3(options.repoDir, ".neuroverse", "worlds")
     ];
     for (const p of repoPaths) {
-      if (existsSync(p)) {
+      if (existsSync3(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 = resolve(dirPath);
-  if (!existsSync(dir)) return [];
-  const stat = statSync(dir);
+  const dir = resolve3(dirPath);
+  if (!existsSync3(dir)) return [];
+  const stat = statSync3(dir);
   if (stat.isFile() && dir.endsWith(".md")) {
     try {
       return [{
         name: basename(dir).replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
         source,
         path: dir,
-        content: readFileSync(dir, "utf-8")
+        content: readFileSync3(dir, "utf-8")
       }];
     } catch {
       return [];
@@ -918,28 +1446,28 @@ function loadWorldsFromDir(dirPath, source) {
     (f) => f.endsWith(".worldmodel.md") || f.endsWith(".nv-world.md")
   ).sort();
   return files.map((f) => {
-    const fullPath = join(dir, f);
+    const fullPath = join3(dir, f);
     return {
       name: f.replace(/\.worldmodel\.md$/, "").replace(/\.nv-world\.md$/, ""),
       source,
       path: fullPath,
-      content: readFileSync(fullPath, "utf-8")
+      content: readFileSync3(fullPath, "utf-8")
     };
   });
 }
 
 // src/radiant/adapters/exocortex.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join2, resolve as resolve2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync4 } from "fs";
+import { join as join4, resolve as resolve4 } from "path";
 function readExocortex(dirPath, repoName) {
-  const dir = resolve2(dirPath);
+  const dir = resolve4(dirPath);
   let filesLoaded = 0;
   function tryRead(...paths) {
     for (const p of paths) {
-      const full = join2(dir, p);
-      if (existsSync2(full)) {
+      const full = join4(dir, p);
+      if (existsSync4(full)) {
         try {
-          const content = readFileSync2(full, "utf-8").trim();
+          const content = readFileSync4(full, "utf-8").trim();
           if (content) {
             filesLoaded++;
             return content;
@@ -1049,14 +1577,14 @@ ${ctx.methods}`);
   return sections.join("\n\n");
 }
 function readTeamExocortices(teamDir) {
-  const dir = resolve2(teamDir);
-  if (!existsSync2(dir)) return [];
+  const dir = resolve4(teamDir);
+  if (!existsSync4(dir)) return [];
   const entries = readdirSync2(dir);
   const results = [];
   for (const entry of entries) {
-    const entryPath = join2(dir, entry);
+    const entryPath = join4(dir, entry);
     try {
-      const stat = statSync2(entryPath);
+      const stat = statSync4(entryPath);
       if (stat.isDirectory()) {
         const ctx = readExocortex(entryPath);
         if (ctx.filesLoaded > 0) {
@@ -1101,25 +1629,25 @@ function summarizeExocortex(ctx) {
 }
 
 // src/radiant/memory/palace.ts
-import { readFileSync as readFileSync3, writeFileSync, mkdirSync, readdirSync as readdirSync3, existsSync as existsSync3 } from "fs";
-import { join as join3, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3, existsSync as existsSync5 } from "fs";
+import { join as join5, resolve as resolve5 } from "path";
 function writeRead(exocortexDir, frontmatter, text) {
-  const dir = resolve3(exocortexDir, "radiant", "reads");
-  mkdirSync(dir, { recursive: true });
+  const dir = resolve5(exocortexDir, "radiant", "reads");
+  mkdirSync2(dir, { recursive: true });
   const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
   const filename = `${date}.md`;
-  const filepath = join3(dir, filename);
+  const filepath = join5(dir, filename);
   const content = `${frontmatter}
 
 ${text}
 `;
-  writeFileSync(filepath, content, "utf-8");
+  writeFileSync2(filepath, content, "utf-8");
   return filepath;
 }
 function updateKnowledge(exocortexDir, persistence, options) {
-  const dir = resolve3(exocortexDir, "radiant");
-  mkdirSync(dir, { recursive: true });
-  const filepath = join3(dir, "knowledge.md");
+  const dir = resolve5(exocortexDir, "radiant");
+  mkdirSync2(dir, { recursive: true });
+  const filepath = join5(dir, "knowledge.md");
   const totalReads = options?.totalReads ?? 0;
   const existingUntriggered = loadUntriggeredCounts(filepath);
   const lines = [
@@ -1206,14 +1734,14 @@ function updateKnowledge(exocortexDir, persistence, options) {
     lines.push(`${name}=${count}`);
   }
   lines.push("-->");
-  writeFileSync(filepath, lines.join("\n"), "utf-8");
+  writeFileSync2(filepath, lines.join("\n"), "utf-8");
   return filepath;
 }
 function loadUntriggeredCounts(filepath) {
   const counts = /* @__PURE__ */ new Map();
-  if (!existsSync3(filepath)) return counts;
+  if (!existsSync5(filepath)) return counts;
   try {
-    const content = readFileSync3(filepath, "utf-8");
+    const content = readFileSync5(filepath, "utf-8");
     const match = content.match(
       /<!-- untriggered_counts[\s\S]*?-->/
     );
@@ -1231,13 +1759,13 @@ function loadUntriggeredCounts(filepath) {
   return counts;
 }
 function loadPriorReads(exocortexDir) {
-  const dir = resolve3(exocortexDir, "radiant", "reads");
-  if (!existsSync3(dir)) return [];
+  const dir = resolve5(exocortexDir, "radiant", "reads");
+  if (!existsSync5(dir)) return [];
   const files = readdirSync3(dir).filter((f) => f.endsWith(".md")).sort();
   const reads = [];
   for (const filename of files) {
-    const filepath = join3(dir, filename);
-    const content = readFileSync3(filepath, "utf-8");
+    const filepath = join5(dir, filename);
+    const content = readFileSync5(filepath, "utf-8");
     const date = filename.replace(".md", "");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
     const frontmatter = fmMatch ? fmMatch[1] : "";
@@ -1559,6 +2087,138 @@ var DEFAULT_SIGNAL_EXTRACTORS = Object.freeze([
   DECISION_MOMENTUM_EXTRACTOR
 ]);
 
+// 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/types.ts
 var DEFAULT_EVIDENCE_GATE = { k: 3, c: 0.5 };
 function isScored(s) {
@@ -1601,7 +2261,11 @@ function scoreComposite(a_L, a_C, a_N) {
 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,
@@ -1612,8 +2276,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;
@@ -1724,6 +2390,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"];
@@ -1749,7 +2453,7 @@ function formatEventSample(events, maxEvents) {
   "${content}"`;
   }).join("\n");
 }
-function parseInterpretation(raw, canonicalNames) {
+function parseInterpretation(raw, canonicalNames, vocabulary) {
   let meaning = "";
   let move = "";
   let patternsArray = [];
@@ -1779,14 +2483,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) : [],
@@ -2109,10 +2822,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,
@@ -2120,6 +2847,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));
@@ -2174,6 +2902,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");
@@ -2283,6 +3015,17 @@ export {
   formatSlackSignalsForPrompt,
   fetchNotionActivity,
   formatNotionSignalsForPrompt,
+  fetchLinearActivity,
+  formatLinearSignalsForPrompt,
+  readOriginRemote,
+  parseRemoteUrl,
+  getRepoOrigin,
+  loadExtendsConfig,
+  parseExtendsSpec,
+  getCacheDir,
+  resolveExtendsSpec,
+  detectOrgExtendsSpec,
+  resolveAllExtends,
   discoverWorlds,
   formatActiveWorlds,
   readExocortex,
@@ -2300,6 +3043,8 @@ export {
   classifyEvents,
   extractSignals,
   DEFAULT_SIGNAL_EXTRACTORS,
+  extractDeclaredVocabulary,
+  matchDeclaredPattern,
   DEFAULT_EVIDENCE_GATE,
   isScored,
   isSentinel,
@@ -2312,6 +3057,7 @@ export {
   interpretPatterns,
   render,
   emergent,
+  filterEventsByUser,
   createAnthropicAI,
   createMockAI
 };