@neuroverseos/governance 0.9.0 → 0.10.0

package/dist/cli/radiant.cjs

@@ -1670,6 +1670,262 @@ var init_notion = __esm({
   }
 });
 
+// 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;
+}
+var init_linear = __esm({
+  "src/radiant/adapters/linear.ts"() {
+    "use strict";
+  }
+});
+
 // src/radiant/core/git-remote.ts
 function resolveGitConfigPath(repoDir) {
   const dotGit = (0, import_path.join)(repoDir, ".git");
@@ -3799,6 +4055,144 @@ var init_signals = __esm({
   }
 });
 
+// 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;
+}
+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)));
+}
+var STOPWORDS;
+var init_vocabulary = __esm({
+  "src/radiant/core/vocabulary.ts"() {
+    "use strict";
+    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"
+    ]);
+  }
+});
+
 // src/radiant/types.ts
 function isScored(s) {
   return typeof s === "number";
@@ -3850,7 +4244,11 @@ var init_math = __esm({
 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,
@@ -3861,8 +4259,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;
@@ -3973,6 +4373,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"];
@@ -3998,7 +4436,7 @@ function formatEventSample(events, maxEvents) {
   "${content}"`;
   }).join("\n");
 }
-function parseInterpretation(raw, canonicalNames) {
+function parseInterpretation(raw, canonicalNames, vocabulary) {
   let meaning = "";
   let move = "";
   let patternsArray = [];
@@ -4028,14 +4466,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) : [],
@@ -4053,6 +4500,7 @@ var init_patterns = __esm({
   "src/radiant/core/patterns.ts"() {
     "use strict";
     init_compress();
+    init_vocabulary();
   }
 });
 
@@ -4371,10 +4819,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,
@@ -4382,6 +4844,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));
@@ -4436,6 +4899,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");
@@ -4491,12 +4958,14 @@ var init_emergent = __esm({
     init_discord();
     init_slack();
     init_notion();
+    init_linear();
     init_discovery();
     init_exocortex();
     init_palace();
     init_compress();
     init_governance();
     init_signals();
+    init_vocabulary();
     init_math();
     init_patterns();
     init_renderer();
@@ -4818,7 +5287,9 @@ var init_server = __esm({
 // src/cli/radiant.ts
 var radiant_exports = {};
 __export(radiant_exports, {
-  main: () => main
+  checkScopeConsent: () => checkScopeConsent,
+  main: () => main,
+  parseArgs: () => parseArgs
 });
 module.exports = __toCommonJS(radiant_exports);
 var import_fs7 = require("fs");
@@ -4831,6 +5302,7 @@ init_exocortex();
 init_lenses();
 init_discovery();
 var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
 var DIM = "\x1B[2m";
 var BOLD = "\x1B[1m";
 var YELLOW = "\x1B[33m";
@@ -4838,6 +5310,9 @@ var RESET = "\x1B[0m";
 var USAGE = `
 ${BOLD}neuroverse radiant${RESET} \u2014 behavioral intelligence for collaboration systems
 
+${BOLD}Setup:${RESET}
+  init           Scaffold a Mind Palace in the current directory
+
 ${BOLD}Stage A (voice layer):${RESET}
   think          Send a query through the worldmodel + lens \u2192 AI-framed response
 
@@ -4848,13 +5323,27 @@ ${BOLD}Stage B (behavioral analysis, coming soon):${RESET}
   lenses         List or describe available rendering lenses
 
 ${BOLD}Usage:${RESET}
+  neuroverse radiant init                      (scaffolds ./mind-palace/)
+  neuroverse radiant init ./my-palace          (custom path)
   neuroverse radiant think --lens auki-builder --worlds ./worlds/ --query "What is our biggest risk?"
   neuroverse radiant think --lens auki-builder --worlds ./worlds/ < prompt.txt
   neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/
   neuroverse radiant emergent aukiverse/posemesh --lens auki-builder --worlds ./worlds/ --exocortex ~/exocortex/
+  neuroverse radiant emergent aukilabs/posemesh --personal --user alice
+  neuroverse radiant emergent aukilabs/ --entire-org --lens auki-builder --worlds ./worlds/
   neuroverse radiant lenses list
   neuroverse radiant lenses describe auki-builder
 
+${BOLD}Read modes:${RESET}
+  ${BOLD}Default (team):${RESET} reads all contributors in the given scope.
+  ${BOLD}--personal --user <login>:${RESET} reads ONLY that user's activity.
+    A local, private facilitator \u2014 no one else is observed. Works against
+    any scope; an org scope with --personal is fine.
+  ${BOLD}--entire-org (gated):${RESET} org-wide scope observes every contributor
+    across every repo. This is a global-observer stance and is opt-in.
+    \`radiant emergent <org>/\` without --entire-org will refuse and show
+    you the three choices (single repo, --personal, or explicit opt-in).
+
 ${BOLD}Auto-discovery:${RESET}
   You do not need to clone the target repo.
 
@@ -4873,6 +5362,7 @@ ${BOLD}Environment:${RESET}
   RADIANT_LENS         Default lens id (overridden by --lens)
   RADIANT_MODEL        AI model override (default: claude-sonnet-4-20250514)
   RADIANT_EXOCORTEX    Default exocortex directory (overridden by --exocortex)
+  RADIANT_USER         Default personal-mode user (overridden by --user)
 `.trim();
 function parseArgs(argv) {
   const result = {
@@ -4884,8 +5374,12 @@ function parseArgs(argv) {
     exocortex: void 0,
     teamExocortex: void 0,
     view: void 0,
+    user: void 0,
+    personal: false,
+    entireOrg: false,
     json: false,
     help: false,
+    force: false,
     rest: []
   };
   let i = 0;
@@ -4917,9 +5411,22 @@ function parseArgs(argv) {
       case "--view":
         result.view = argv[++i];
         break;
+      case "--user":
+        result.user = argv[++i];
+        break;
+      case "--personal":
+        result.personal = true;
+        break;
+      case "--entire-org":
+        result.entireOrg = true;
+        break;
       case "--json":
         result.json = true;
         break;
+      case "--force":
+      case "-f":
+        result.force = true;
+        break;
       case "--help":
       case "-h":
         result.help = true;
@@ -5077,6 +5584,15 @@ ${DIM}Model:  ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET}
     process.exit(2);
   }
 }
+function checkScopeConsent(input) {
+  if (input.personal && !input.resolvedUser) {
+    return { ok: false, reason: "personal_requires_user" };
+  }
+  if (input.scope.type === "org" && !input.entireOrg && !input.personal) {
+    return { ok: false, reason: "org_requires_opt_in" };
+  }
+  return { ok: true };
+}
 async function cmdEmergent(args) {
   const scopeStr = args.rest[0];
   if (!scopeStr) {
@@ -5087,6 +5603,43 @@ async function cmdEmergent(args) {
     process.exit(1);
   }
   const scope = parseScope(scopeStr);
+  const personalUser = args.user ?? process.env.RADIANT_USER;
+  const consent = checkScopeConsent({
+    scope,
+    personal: args.personal,
+    entireOrg: args.entireOrg,
+    resolvedUser: personalUser
+  });
+  if (!consent.ok) {
+    if (consent.reason === "personal_requires_user") {
+      process.stderr.write(
+        `${RED}Error:${RESET} --personal requires a GitHub username.
+${DIM}Pass --user <login> or set RADIANT_USER. Radiant will read
+only that user's activity \u2014 no one else is observed.${RESET}
+`
+      );
+    } else {
+      process.stderr.write(
+        `${YELLOW}\u26A0${RESET}  ${BOLD}"${scope.owner}" is an org-wide scope.${RESET}
+
+${DIM}This reads activity across ALL repos in the org \u2014 a global-observer
+pattern that some teams consider offside with decentralization and
+cognitive-liberty principles. It's opt-in for that reason.${RESET}
+
+Three ways forward:
+  ${GREEN}1.${RESET} Scope to a single repo (recommended default):
+       radiant emergent ${scope.owner}/<repo>
+
+  ${GREEN}2.${RESET} Read only your own activity (personal mode):
+       radiant emergent ${scope.owner}/ --personal --user <your-login>
+
+  ${GREEN}3.${RESET} Explicitly opt in to org-wide observation:
+       radiant emergent ${scope.owner}/ --entire-org
+`
+      );
+    }
+    process.exit(1);
+  }
   const lensId = args.lens ?? process.env.RADIANT_LENS;
   if (!lensId) {
     process.stderr.write(
@@ -5135,8 +5688,11 @@ ${DIM}Set it to a GitHub PAT with repo read access.${RESET}
     const ctx = readExocortex(exocortexPath);
     exocortexStatus = summarizeExocortex(ctx);
   }
+  const scopeLabel = scope.type === "org" ? scope.owner + " (entire org)" : scope.owner + "/" + scope.repo;
+  const modeLabel = args.personal ? `personal \u2014 only ${personalUser}'s activity` : "team \u2014 all contributors";
   process.stderr.write(
-    `${DIM}Scope:      ${scope.type === "org" ? scope.owner + " (entire org)" : scope.owner + "/" + scope.repo}${RESET}
+    `${DIM}Scope:      ${scopeLabel}${RESET}
+${DIM}Mode:       ${modeLabel}${RESET}
 ${DIM}View:       ${view}${RESET}
 ${DIM}Lens:       ${lensId}${RESET}
 ${DIM}Model:      ${model ?? "claude-sonnet-4-20250514 (default)"}${RESET}
@@ -5152,7 +5708,8 @@ ${DIM}Fetching activity...${RESET}
     lensId,
     ai,
     windowDays: 14,
-    exocortexPath: exocortexPath || void 0
+    exocortexPath: exocortexPath || void 0,
+    personalUser: args.personal ? personalUser : void 0
   });
   if (!result.voiceClean) {
     process.stderr.write(
@@ -5254,6 +5811,204 @@ ${DIM}Use: lenses list | lenses describe <id>${RESET}
   );
   process.exit(1);
 }
+var MIND_PALACE_FILES = {
+  "README.md": `# Mind Palace
+
+This is your Mind Palace \u2014 structured external memory that gives Radiant
+(and any agent you wire into it) persistent context about who you are,
+what you're working on, and what "on track" means for you.
+
+Radiant reads these files before every run and writes each read back into
+\`reads/\`. Over time, \`knowledge.md\` accumulates what's persisted and what
+hasn't \u2014 the feedback loop that turns raw activity into named behavior.
+
+## Files
+
+- \`attention.md\` \u2014 what you're focused on **right now**
+- \`goals.md\` \u2014 what you're working toward
+- \`sprint.md\` \u2014 this week's focus
+- \`identity.md\` \u2014 who you are, what you value
+- \`worldmodels/\` \u2014 your thinking constitutions (drift + aligned behaviors)
+- \`reads/\` \u2014 dated Radiant reads (written by \`radiant emergent\`)
+- \`knowledge.md\` \u2014 accumulated pattern persistence across reads
+
+## How to use
+
+1. Fill in \`attention.md\`, \`goals.md\`, \`sprint.md\`, \`identity.md\` with
+   your own words. A sentence each is enough to start \u2014 the files grow
+   with you.
+2. Edit \`worldmodels/starter.worldmodel.md\`: add a few aligned behaviors
+   (what on-track looks like) and drift behaviors (what off-track looks
+   like). The sharper these are, the sharper Radiant's reads.
+3. Run \`neuroverse radiant emergent <owner/repo> --mind-palace .\` against
+   the repo you want read. Radiant compares your stated intent (these
+   files) to your observed activity (GitHub) and names the gap.
+
+Edit freely. These files are yours.
+`,
+  "attention.md": `# Attention
+
+<!--
+What are you focused on RIGHT NOW? One paragraph. Updated as you shift.
+This is the file an AI agent reads at the start of a session to know
+what to help with today.
+-->
+
+`,
+  "goals.md": `# Goals
+
+<!--
+What are you working toward? Bullet points welcome.
+Longer horizon than attention \u2014 months, not days.
+-->
+
+-
+`,
+  "sprint.md": `# Sprint
+
+<!--
+This week's focus. What do you want to ship or finish?
+Keep it short \u2014 five bullets max.
+-->
+
+-
+`,
+  "identity.md": `# Identity
+
+<!--
+Who are you, what do you value, how do you work?
+This is the context an agent needs to not treat you like a stranger
+every time. Write it in your own voice.
+-->
+
+`,
+  "knowledge.md": `# Knowledge
+
+<!--
+Radiant writes accumulated pattern persistence here across reads.
+Leave this file empty on day one \u2014 it fills up as \`radiant emergent\`
+runs accumulate.
+-->
+
+`,
+  "reads/.gitkeep": "",
+  "worldmodels/starter.worldmodel.md": `# Starter Worldmodel
+
+<!--
+Your thinking constitution. Radiant reads this to understand what
+"aligned" and "drift" mean for your work.
+
+The sharper the Aligned/Drift Behaviors, the sharper Radiant's reads.
+When Radiant detects something matching a drift behavior below, it
+labels it with THAT name \u2014 it doesn't invent new ones.
+-->
+
+## Mission
+
+<!-- One sentence. What are you doing in the world? -->
+
+
+## Invariants
+
+<!--
+Non-negotiable rules. If a decision violates one, it's blocked.
+Keep this list short \u2014 3 to 6 items. Each should be a hard no.
+-->
+
+-
+
+## Aligned Behaviors
+
+<!--
+What "on track" looks like. One per line, phrased as a behavior.
+Radiant will use these as canonical pattern names when it sees
+matching evidence in your activity.
+
+Example:
+  - ships partial-but-working features rather than waiting for the full stack
+  - writes decisions down before acting on them
+-->
+
+-
+
+## Drift Behaviors
+
+<!--
+What "off track" looks like. Same format as Aligned.
+When Radiant detects drift, it will label it with these names \u2014 not
+make up new ones.
+
+Example:
+  - shipping pace outruns strategic decision-making
+  - architecture decisions surface without context about why
+-->
+
+-
+
+## Signals
+
+<!--
+Observable quantities you care about. Radiant scores activity
+against these \u2014 5 to 7 is the sweet spot.
+
+Example:
+  - shipping_velocity
+  - decision_ownership
+  - storytelling_cadence
+-->
+
+-
+
+## Decision Priorities
+
+<!--
+When tradeoffs appear, these resolve them. Format: "A > B".
+
+Example:
+  - correctness > speed
+  - clarity > cleverness
+-->
+
+-
+`
+};
+async function cmdInit(args) {
+  const targetDir = (0, import_path7.resolve)(args.rest[0] ?? "./mind-palace");
+  const existed = (0, import_fs7.existsSync)(targetDir);
+  if (existed && !args.force) {
+    const entries = (0, import_fs7.readdirSync)(targetDir);
+    if (entries.length > 0) {
+      process.stderr.write(
+        `${RED}Error:${RESET} ${targetDir} already exists and is not empty.
+${DIM}Use --force to write into it anyway (existing files will be overwritten).${RESET}
+`
+      );
+      process.exit(1);
+    }
+  }
+  (0, import_fs7.mkdirSync)(targetDir, { recursive: true });
+  (0, import_fs7.mkdirSync)((0, import_path7.join)(targetDir, "reads"), { recursive: true });
+  (0, import_fs7.mkdirSync)((0, import_path7.join)(targetDir, "worldmodels"), { recursive: true });
+  for (const [relPath, content] of Object.entries(MIND_PALACE_FILES)) {
+    const fullPath = (0, import_path7.join)(targetDir, relPath);
+    (0, import_fs7.mkdirSync)((0, import_path7.resolve)(fullPath, ".."), { recursive: true });
+    (0, import_fs7.writeFileSync)(fullPath, content, "utf-8");
+  }
+  process.stdout.write(
+    `${GREEN}\u2713${RESET} Mind Palace scaffolded at ${BOLD}${targetDir}${RESET}
+
+${DIM}Next steps:${RESET}
+  1. Edit ${targetDir}/attention.md \u2014 what you're focused on right now
+  2. Edit ${targetDir}/worldmodels/starter.worldmodel.md \u2014 add a few
+     aligned and drift behaviors
+  3. Run: neuroverse radiant emergent <owner/repo> \\
+           --worlds ${targetDir}/worldmodels \\
+           --exocortex ${targetDir}
+
+${DIM}Files are yours. Edit freely.${RESET}
+`
+  );
+}
 async function main(argv) {
   const args = parseArgs(argv);
   if (args.help || !args.subcommand) {
@@ -5261,6 +6016,8 @@ async function main(argv) {
     return;
   }
   switch (args.subcommand) {
+    case "init":
+      return cmdInit(args);
     case "think":
       return cmdThink(args);
     case "lenses":
@@ -5293,5 +6050,7 @@ async function main(argv) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  main
+  checkScopeConsent,
+  main,
+  parseArgs
 });