@cmnwlth/curate 0.1.0

package/dist/index.js

@@ -0,0 +1,738 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path4 from "path";
+import { promises as fs3 } from "fs";
+import { parseArgs } from "util";
+import {
+  computeBrainHealth,
+  FEATURE_FLAGS,
+  loadBrainConfig as loadBrainConfig2,
+  NOTE_KINDS,
+  resolveBrainDir,
+  resolveProjectSource,
+  setFeature
+} from "@cmnwlth/core";
+
+// src/capture.ts
+import { isFeatureEnabled as isFeatureEnabled2 } from "@cmnwlth/core";
+
+// src/curate.ts
+import {
+  hasSecrets,
+  isFeatureEnabled,
+  listNotes as listNotes2,
+  loadBrainConfig,
+  scanOptions
+} from "@cmnwlth/core";
+
+// src/staging.ts
+import path from "path";
+import { listNotes, writeNote } from "@cmnwlth/core";
+var STAGING_DIR = "staging";
+function stagingRoot(brainDir) {
+  return path.join(brainDir, STAGING_DIR);
+}
+function stageNote(brainDir, input) {
+  return writeNote(stagingRoot(brainDir), input);
+}
+function listStaged(brainDir) {
+  return listNotes(stagingRoot(brainDir));
+}
+function stagedAbsPath(brainDir, note) {
+  return path.join(stagingRoot(brainDir), note.path);
+}
+
+// src/curate.ts
+var MIN_BODY_LENGTH = 15;
+var DUPLICATE_THRESHOLD = 0.8;
+function tokenSet(text) {
+  const normalized = text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").trim();
+  const tokens = normalized.split(/\s+/).filter((t) => t.length > 0);
+  return new Set(tokens);
+}
+function jaccard(a, b) {
+  if (a.size === 0 && b.size === 0) return 0;
+  let intersection = 0;
+  for (const token of a) {
+    if (b.has(token)) intersection += 1;
+  }
+  const union = a.size + b.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function textSimilarity(a, b) {
+  return jaccard(tokenSet(a), tokenSet(b));
+}
+function candidateText(input) {
+  return `${input.title} ${input.body}`;
+}
+function candidateSecretScanText(input) {
+  const parts = [input.title, input.body, ...input.tags ?? []];
+  if (input.author) parts.push(input.author);
+  if (input.source) parts.push(input.source);
+  if (input.fields && Object.keys(input.fields).length > 0)
+    parts.push(JSON.stringify(input.fields));
+  return parts.join("\n");
+}
+function noteText(note) {
+  return `${note.frontmatter.title} ${note.body}`;
+}
+var defaultCurator = {
+  assess(candidate, existing) {
+    if (candidate.title.trim().length === 0 || candidate.body.trim().length < MIN_BODY_LENGTH) {
+      return { accept: false, reason: "too-thin" };
+    }
+    const candidateTokens = tokenSet(candidateText(candidate));
+    let bestScore = 0;
+    let bestId;
+    for (const note of existing) {
+      const score = jaccard(candidateTokens, tokenSet(noteText(note)));
+      if (score > bestScore) {
+        bestScore = score;
+        bestId = note.frontmatter.id;
+      }
+    }
+    if (bestScore >= DUPLICATE_THRESHOLD && bestId !== void 0) {
+      return { accept: false, reason: "duplicate", duplicateOf: bestId };
+    }
+    return { accept: true, reason: "accepted" };
+  }
+};
+async function curate(brainDir, candidates, curator = defaultCurator) {
+  const canon = await listNotes2(brainDir);
+  const staged = await listStaged(brainDir);
+  const existing = [...canon, ...staged];
+  const result = { staged: [], rejected: [] };
+  const autoAdr = await isFeatureEnabled(brainDir, "autoAdr");
+  const secretOpts = scanOptions(await loadBrainConfig(brainDir));
+  for (const candidate of candidates) {
+    if (hasSecrets(candidateSecretScanText(candidate), secretOpts)) {
+      result.rejected.push({ candidate, reason: "contains-secret" });
+      continue;
+    }
+    if (candidate.kind === "decision" && !autoAdr) {
+      result.rejected.push({ candidate, reason: "auto-adr-disabled" });
+      continue;
+    }
+    const assessment = curator.assess(candidate, existing);
+    if (!assessment.accept) {
+      result.rejected.push({
+        candidate,
+        reason: assessment.reason,
+        ...assessment.duplicateOf !== void 0 ? { duplicateOf: assessment.duplicateOf } : {}
+      });
+      continue;
+    }
+    try {
+      const note = await stageNote(brainDir, candidate);
+      result.staged.push(note);
+      existing.push(note);
+    } catch (err) {
+      result.rejected.push({
+        candidate,
+        reason: `invalid: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return result;
+}
+
+// src/review.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+import { pathForNote, resolveWithinBrain } from "@cmnwlth/core";
+function listPending(brainDir) {
+  return listStaged(brainDir);
+}
+async function findStaged(brainDir, id) {
+  const pending = await listStaged(brainDir);
+  return pending.find((n) => n.frontmatter.id === id);
+}
+async function approve(brainDir, id) {
+  const note = await findStaged(brainDir, id);
+  if (!note) {
+    throw new Error(`No staged note with id "${id}" to approve`);
+  }
+  const canonRel = pathForNote(note.frontmatter.kind, id, note.frontmatter.source);
+  const canonAbs = resolveWithinBrain(brainDir, canonRel);
+  const stagedAbs = stagedAbsPath(brainDir, note);
+  await fs.mkdir(path2.dirname(canonAbs), { recursive: true });
+  const content = await fs.readFile(stagedAbs, "utf8");
+  const tmp = `${canonAbs}.${Date.now()}.tmp`;
+  await fs.writeFile(tmp, content, "utf8");
+  await fs.rename(tmp, canonAbs);
+  await fs.rm(stagedAbs);
+  return canonRel;
+}
+async function reject(brainDir, id) {
+  const note = await findStaged(brainDir, id);
+  if (!note) {
+    throw new Error(`No staged note with id "${id}" to reject`);
+  }
+  await fs.rm(stagedAbsPath(brainDir, note));
+}
+async function approveAll(brainDir) {
+  const pending = await listStaged(brainDir);
+  const paths = [];
+  for (const note of pending) {
+    paths.push(await approve(brainDir, note.frontmatter.id));
+  }
+  return paths;
+}
+
+// src/capture.ts
+async function captureCandidates(brainDir, candidates, curator) {
+  const result = await curate(brainDir, candidates, curator);
+  const promoted = [];
+  if (result.staged.length > 0 && await isFeatureEnabled2(brainDir, "autoPromote")) {
+    for (const note of result.staged) {
+      promoted.push(await approve(brainDir, note.frontmatter.id));
+    }
+  }
+  return { ...result, promoted };
+}
+
+// src/consolidate.ts
+import { acquireSyncLock, listNotes as listNotes3, supersedeNote } from "@cmnwlth/core";
+var DEFAULT_CONSOLIDATE_THRESHOLD = 0.9;
+function noteText2(n) {
+  return `${n.frontmatter.title} ${n.body}`;
+}
+function pickSurvivor(cluster) {
+  return [...cluster].sort((a, b) => {
+    const av = a.frontmatter.kind === "memory" ? a.frontmatter.verified ?? "" : "";
+    const bv = b.frontmatter.kind === "memory" ? b.frontmatter.verified ?? "" : "";
+    if (av !== bv) return av < bv ? 1 : -1;
+    if (a.frontmatter.created !== b.frontmatter.created) {
+      return a.frontmatter.created < b.frontmatter.created ? 1 : -1;
+    }
+    return a.frontmatter.id < b.frontmatter.id ? -1 : 1;
+  })[0];
+}
+function clusterBySimilarity(notes, threshold) {
+  const parent = notes.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const union = (a, b) => {
+    parent[find(a)] = find(b);
+  };
+  for (let i = 0; i < notes.length; i++) {
+    for (let j = i + 1; j < notes.length; j++) {
+      if (textSimilarity(noteText2(notes[i]), noteText2(notes[j])) >= threshold) union(i, j);
+    }
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  notes.forEach((n, i) => {
+    const r = find(i);
+    (byRoot.get(r) ?? byRoot.set(r, []).get(r)).push(n);
+  });
+  return [...byRoot.values()].filter((c) => c.length > 1);
+}
+async function consolidateCanon(brainDir, opts = {}) {
+  const threshold = opts.threshold ?? DEFAULT_CONSOLIDATE_THRESHOLD;
+  const release = await acquireSyncLock(brainDir);
+  if (!release)
+    return { clusters: 0, superseded: [], skipped: "another writer holds the sync lock" };
+  try {
+    const notes = await listNotes3(brainDir);
+    const active = notes.filter(
+      (n) => (n.frontmatter.kind === "memory" || n.frontmatter.kind === "decision") && n.frontmatter.status !== "superseded"
+    );
+    const superseded = [];
+    let clusters = 0;
+    for (const kind of ["memory", "decision"]) {
+      const ofKind = active.filter((n) => n.frontmatter.kind === kind);
+      for (const cluster of clusterBySimilarity(ofKind, threshold)) {
+        clusters += 1;
+        const survivor = pickSurvivor(cluster);
+        for (const dup of cluster) {
+          if (dup.frontmatter.id === survivor.frontmatter.id) continue;
+          if (!opts.dryRun) await supersedeNote(brainDir, dup.path, survivor.frontmatter.id);
+          superseded.push({
+            id: dup.frontmatter.id,
+            path: dup.path,
+            survivor: survivor.frontmatter.id
+          });
+        }
+      }
+    }
+    superseded.sort((a, b) => a.id < b.id ? -1 : 1);
+    return { clusters, superseded };
+  } finally {
+    await release();
+  }
+}
+
+// src/context.ts
+import "@cmnwlth/core";
+var SNIPPET_MAX = 120;
+function firstLine(body) {
+  for (const line of body.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length > 0) {
+      return trimmed.length > SNIPPET_MAX ? trimmed.slice(0, SNIPPET_MAX) : trimmed;
+    }
+  }
+  return "";
+}
+function formatContext(notes) {
+  if (notes.length === 0) return "";
+  const lines = [
+    `## Team brain \u2014 ${notes.length} relevant note(s)`,
+    '_Cite any note you use inline, e.g. "\u{1F4D6} from the team brain: TITLE"._',
+    ""
+  ];
+  for (const note of notes) {
+    const { title, kind } = note.frontmatter;
+    const snippet = firstLine(note.body);
+    lines.push(snippet ? `- **${title}** (${kind}) \u2014 ${snippet}` : `- **${title}** (${kind})`);
+  }
+  return lines.join("\n");
+}
+
+// src/relevance.ts
+import { listNotes as listNotes4, readNote, search } from "@cmnwlth/core";
+var DEFAULT_LIMIT = 10;
+function byId(a, b) {
+  return a.frontmatter.id < b.frontmatter.id ? -1 : a.frontmatter.id > b.frontmatter.id ? 1 : 0;
+}
+function byCreatedDesc(a, b) {
+  if (a.frontmatter.created !== b.frontmatter.created) {
+    return a.frontmatter.created < b.frontmatter.created ? 1 : -1;
+  }
+  return byId(a, b);
+}
+async function selectRelevant(brainDir, q = {}) {
+  const limit = q.limit ?? DEFAULT_LIMIT;
+  if (q.query !== void 0 && q.query.trim().length > 0) {
+    const hits = await search(brainDir, q.query, { limit });
+    const notes = [];
+    for (const hit of hits) {
+      notes.push(await readNote(brainDir, hit.path));
+    }
+    return notes;
+  }
+  const workStates = await listNotes4(brainDir, "work-state");
+  const active = workStates.filter((n) => n.frontmatter.kind === "work-state" && n.frontmatter.status !== "done").sort(byId);
+  const decisions = (await listNotes4(brainDir, "decision")).sort(byCreatedDesc);
+  return [...active, ...decisions].slice(0, limit);
+}
+
+// src/scope.ts
+import { promises as fs2 } from "fs";
+import os from "os";
+import path3 from "path";
+function defaultConfigPath() {
+  return process.env.COMMONWEALTH_CONFIG ?? path3.join(os.homedir(), ".commonwealth", "config.json");
+}
+async function loadUserConfig(configPath = defaultConfigPath()) {
+  let raw;
+  try {
+    raw = await fs2.readFile(configPath, "utf8");
+  } catch {
+    return { allow: [], deny: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { allow: [], deny: [] };
+  }
+  const obj = typeof parsed === "object" && parsed !== null ? parsed : {};
+  return {
+    allow: Array.isArray(obj.allow) ? obj.allow : [],
+    deny: Array.isArray(obj.deny) ? obj.deny : []
+  };
+}
+async function saveUserConfig(config, configPath = defaultConfigPath()) {
+  await fs2.mkdir(path3.dirname(configPath), { recursive: true });
+  await fs2.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function expand(entry) {
+  const home = os.homedir();
+  if (entry === "~") return path3.resolve(home);
+  if (entry.startsWith("~/")) return path3.resolve(home, entry.slice(2));
+  return path3.resolve(entry);
+}
+function isUnder(child, parent) {
+  if (parent === path3.sep) return true;
+  return child === parent || child.startsWith(parent + path3.sep);
+}
+function underAny(p, list) {
+  return list.some((entry) => isUnder(p, expand(entry)));
+}
+function isInScope(cwd, config) {
+  const target = expand(cwd);
+  const allowed = config.allow.length === 0 || underAny(target, config.allow);
+  return allowed && !underAny(target, config.deny);
+}
+async function addAllow(pathArg, configPath = defaultConfigPath()) {
+  const config = await loadUserConfig(configPath);
+  const resolved = expand(pathArg);
+  if (!config.allow.includes(resolved)) {
+    config.allow.push(resolved);
+    await saveUserConfig(config, configPath);
+  }
+}
+async function addDeny(pathArg, configPath = defaultConfigPath()) {
+  const config = await loadUserConfig(configPath);
+  const resolved = expand(pathArg);
+  if (!config.deny.includes(resolved)) {
+    config.deny.push(resolved);
+    await saveUserConfig(config, configPath);
+  }
+}
+
+// src/index.ts
+async function resolveDir(explicit, cwd = process.cwd()) {
+  if (explicit && explicit.length > 0) return path4.resolve(explicit);
+  const env = process.env.COMMONWEALTH_BRAIN_DIR;
+  if (env && env.length > 0) return path4.resolve(env);
+  return resolveBrainDir(cwd);
+}
+function noBrain(cwd) {
+  console.error(
+    `[commonwealth-curate] no Commonwealth brain configured for ${cwd} \u2014 run \`commonwealth init\` here, add a prefix \u2192 brain mapping to ~/.commonwealth/registry.json, or pass --dir <brain>.`
+  );
+  process.exit(1);
+}
+function usage() {
+  console.error(
+    [
+      "commonwealth-curate \u2014 curation + in-repo review queue",
+      "",
+      "Usage:",
+      "  commonwealth-curate list [--dir <brain>]",
+      "  commonwealth-curate approve <id...> [--dir <brain>]",
+      "  commonwealth-curate reject <id...> [--dir <brain>]",
+      "  commonwealth-curate approve-all [--dir <brain>]",
+      "  commonwealth-curate stage --kind <kind> --title <t> --body <b> [--tags a,b] [--dir <brain>]",
+      "  commonwealth-curate context [--dir <brain>] [--cwd <dir>] [--query <q>] [--limit <n>]",
+      "  commonwealth-curate capture [--dir <brain>] [--cwd <dir>] [--from <json-file>]",
+      "  commonwealth-curate scope show",
+      "  commonwealth-curate scope check [--cwd <dir>]",
+      "  commonwealth-curate scope allow <path>",
+      "  commonwealth-curate scope deny <path>",
+      "  commonwealth-curate health [--dir <brain>]",
+      "  commonwealth-curate consolidate [--dry-run] [--dir <brain>]",
+      "  commonwealth-curate feature list [--dir <brain>]",
+      "  commonwealth-curate feature enable <name> [--dir <brain>]",
+      "  commonwealth-curate feature disable <name> [--dir <brain>]",
+      "",
+      `Kinds: ${NOTE_KINDS.join(", ")}`
+    ].join("\n")
+  );
+}
+function isNoteKind(value) {
+  return NOTE_KINDS.includes(value);
+}
+async function cmdList(dir) {
+  const pending = await listPending(dir);
+  for (const note of pending) {
+    console.log(`${note.frontmatter.id}  [${note.frontmatter.kind}]  ${note.frontmatter.title}`);
+  }
+}
+async function cmdApprove(dir, ids) {
+  if (ids.length === 0) throw new Error("approve requires at least one <id>");
+  for (const id of ids) {
+    const canonPath = await approve(dir, id);
+    console.log(canonPath);
+  }
+}
+async function cmdReject(dir, ids) {
+  if (ids.length === 0) throw new Error("reject requires at least one <id>");
+  for (const id of ids) {
+    await reject(dir, id);
+    console.error(`[commonwealth-curate] rejected ${id}`);
+  }
+}
+async function cmdApproveAll(dir) {
+  const paths = await approveAll(dir);
+  for (const p of paths) console.log(p);
+  console.error(`[commonwealth-curate] approved ${paths.length} note(s)`);
+}
+async function cmdStage(dir, args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      kind: { type: "string" },
+      title: { type: "string" },
+      body: { type: "string" },
+      tags: { type: "string" },
+      // Tolerated here (handled by the top-level parser) so `--dir` doesn't error.
+      dir: { type: "string" }
+    },
+    allowPositionals: false
+  });
+  const { kind, title, body, tags } = values;
+  if (!kind || !title || !body) {
+    throw new Error("stage requires --kind, --title and --body");
+  }
+  if (!isNoteKind(kind)) {
+    throw new Error(`invalid --kind "${kind}"; expected one of: ${NOTE_KINDS.join(", ")}`);
+  }
+  const candidate = {
+    kind,
+    title,
+    body,
+    ...tags ? {
+      tags: tags.split(",").map((t) => t.trim()).filter((t) => t.length > 0)
+    } : {}
+  };
+  const result = await curate(dir, [candidate]);
+  for (const note of result.staged) {
+    console.log(`${note.frontmatter.id}  [${note.frontmatter.kind}]  ${note.frontmatter.title}`);
+  }
+  for (const r of result.rejected) {
+    const extra = r.duplicateOf ? ` (of ${r.duplicateOf})` : "";
+    console.error(`[commonwealth-curate] rejected: ${r.reason}${extra}`);
+  }
+}
+async function cmdContext(explicitDir, args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      dir: { type: "string" },
+      cwd: { type: "string" },
+      query: { type: "string" },
+      limit: { type: "string" }
+    },
+    allowPositionals: false
+  });
+  const cwd = typeof values.cwd === "string" ? values.cwd : process.cwd();
+  const config = await loadUserConfig();
+  if (!isInScope(cwd, config)) {
+    console.error(`[commonwealth-curate] ${cwd} is out of scope; injecting nothing`);
+    return;
+  }
+  const dir = await resolveDir(explicitDir ?? values.dir, cwd);
+  if (dir === null) {
+    console.error(`[commonwealth-curate] no brain for ${cwd}; injecting nothing`);
+    return;
+  }
+  const limit = values.limit !== void 0 ? Number.parseInt(values.limit, 10) : void 0;
+  const notes = await selectRelevant(dir, {
+    ...typeof values.query === "string" ? { query: values.query } : {},
+    ...limit !== void 0 && Number.isFinite(limit) ? { limit } : {}
+  });
+  const rendered = formatContext(notes);
+  if (rendered.length > 0) console.log(rendered);
+}
+function parseCandidates(raw) {
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("capture expects a JSON array of candidate notes");
+  }
+  return parsed;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function cmdCapture(explicitDir, args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      dir: { type: "string" },
+      cwd: { type: "string" },
+      from: { type: "string" },
+      // Explicit imports (e.g. seeding a chosen repo) bypass the per-session scope gate,
+      // which exists to filter out-of-scope *sessions*, not deliberate imports.
+      force: { type: "boolean" }
+    },
+    allowPositionals: false
+  });
+  const cwd = typeof values.cwd === "string" ? values.cwd : process.cwd();
+  if (!values.force) {
+    const config = await loadUserConfig();
+    if (!isInScope(cwd, config)) {
+      console.error(`[commonwealth-curate] ${cwd} is out of scope; capturing nothing`);
+      return;
+    }
+  }
+  const dir = await resolveDir(explicitDir ?? values.dir, cwd);
+  if (dir === null) {
+    console.error(`[commonwealth-curate] no brain for ${cwd}; capturing nothing`);
+    return;
+  }
+  const raw = typeof values.from === "string" ? await fs3.readFile(values.from, "utf8") : await readStdin();
+  const candidates = parseCandidates(raw);
+  const source = await resolveProjectSource(cwd) ?? void 0;
+  const stamped = candidates.map((c) => c.source ? c : { ...c, source });
+  const result = await captureCandidates(dir, stamped);
+  if (result.promoted.length > 0) {
+    result.staged.forEach((note, i) => {
+      const canonPath = result.promoted[i] ?? `${note.frontmatter.kind}/${note.frontmatter.id}.md`;
+      console.log(`promoted  ${canonPath}  [${note.frontmatter.kind}]  ${note.frontmatter.title}`);
+    });
+  } else {
+    for (const note of result.staged) {
+      console.log(`${note.frontmatter.id}  [${note.frontmatter.kind}]  ${note.frontmatter.title}`);
+    }
+  }
+  for (const r of result.rejected) {
+    const extra = r.duplicateOf ? ` (of ${r.duplicateOf})` : "";
+    console.error(`[commonwealth-curate] rejected: ${r.reason}${extra}`);
+  }
+}
+async function cmdScope(args) {
+  const [sub, ...rest] = args;
+  switch (sub) {
+    case "show": {
+      const config = await loadUserConfig();
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+    case "check": {
+      const { values } = parseArgs({
+        args: rest,
+        options: { cwd: { type: "string" } },
+        allowPositionals: false
+      });
+      const cwd = typeof values.cwd === "string" ? values.cwd : process.cwd();
+      const config = await loadUserConfig();
+      console.log(isInScope(cwd, config) ? "in-scope" : "out-of-scope");
+      return;
+    }
+    case "allow": {
+      const target = rest[0];
+      if (!target) throw new Error("scope allow requires a <path>");
+      await addAllow(target);
+      console.error(`[commonwealth-curate] allow += ${target}`);
+      return;
+    }
+    case "deny": {
+      const target = rest[0];
+      if (!target) throw new Error("scope deny requires a <path>");
+      await addDeny(target);
+      console.error(`[commonwealth-curate] deny += ${target}`);
+      return;
+    }
+    default:
+      throw new Error(`unknown scope subcommand "${sub ?? ""}"; expected show|check|allow|deny`);
+  }
+}
+async function cmdFeature(dir, args) {
+  const { positionals } = parseArgs({
+    args,
+    options: { dir: { type: "string" } },
+    allowPositionals: true,
+    strict: false
+  });
+  const [sub, ...rest] = positionals;
+  switch (sub) {
+    case "list": {
+      const config = await loadBrainConfig2(dir);
+      for (const flag of FEATURE_FLAGS) {
+        const state = config.features[flag.name] ? "on" : "off";
+        console.log(`${flag.name}  [${state}]  \u2014 ${flag.description}`);
+      }
+      return;
+    }
+    case "enable":
+    case "disable": {
+      const name = rest[0];
+      if (!name) throw new Error(`feature ${sub} requires a <name>`);
+      if (!FEATURE_FLAGS.some((f) => f.name === name)) {
+        const known = FEATURE_FLAGS.map((f) => f.name).join(", ");
+        throw new Error(`unknown feature "${name}"; expected one of: ${known}`);
+      }
+      const on = sub === "enable";
+      await setFeature(dir, name, on);
+      console.error(`[commonwealth-curate] feature ${name} ${on ? "enabled" : "disabled"}`);
+      return;
+    }
+    default:
+      throw new Error(`unknown feature subcommand "${sub ?? ""}"; expected list|enable|disable`);
+  }
+}
+async function cmdHealth(dir) {
+  const h = await computeBrainHealth(dir);
+  console.log(`Brain health: ${h.score}/100  (${h.total} note${h.total === 1 ? "" : "s"})`);
+  console.log(`  stale:        ${h.stale.count}`);
+  console.log(`  unverified:   ${h.unverified.count}`);
+  console.log(`  contradicted: ${h.contradicted.count}`);
+  console.log(`  orphaned:     ${h.orphaned.count}`);
+}
+async function cmdConsolidate(dir, args) {
+  const { values } = parseArgs({
+    args,
+    options: { "dry-run": { type: "boolean" }, dir: { type: "string" } },
+    allowPositionals: false
+  });
+  const result = await consolidateCanon(dir, { dryRun: values["dry-run"] === true });
+  if (result.skipped) {
+    console.error(`[commonwealth-curate] consolidate skipped: ${result.skipped}`);
+    return;
+  }
+  const verb = values["dry-run"] ? "would supersede" : "superseded";
+  console.error(
+    `[commonwealth-curate] ${result.clusters} duplicate cluster(s); ${verb} ${result.superseded.length} note(s)`
+  );
+  for (const s of result.superseded) console.log(`${s.id} -> ${s.survivor}`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const [command, ...rest] = argv;
+  const { values, positionals } = parseArgs({
+    args: rest,
+    options: { dir: { type: "string" } },
+    allowPositionals: true,
+    // Leave unknown options (e.g. stage's --kind) for the subcommand parser.
+    strict: false
+  });
+  const explicitDir = typeof values.dir === "string" ? values.dir : void 0;
+  const requireBrain = async () => await resolveDir(explicitDir) ?? noBrain(process.cwd());
+  switch (command) {
+    case "list":
+      await cmdList(await requireBrain());
+      break;
+    case "approve":
+      await cmdApprove(await requireBrain(), positionals);
+      break;
+    case "reject":
+      await cmdReject(await requireBrain(), positionals);
+      break;
+    case "approve-all":
+      await cmdApproveAll(await requireBrain());
+      break;
+    case "stage":
+      await cmdStage(await requireBrain(), rest);
+      break;
+    case "context":
+      await cmdContext(explicitDir, rest);
+      break;
+    case "capture":
+      await cmdCapture(explicitDir, rest);
+      break;
+    case "scope":
+      await cmdScope(rest);
+      break;
+    case "feature":
+      await cmdFeature(await requireBrain(), rest);
+      break;
+    case "health":
+      await cmdHealth(await requireBrain());
+      break;
+    case "consolidate":
+      await cmdConsolidate(await requireBrain(), rest);
+      break;
+    default:
+      usage();
+      process.exitCode = command ? 1 : 0;
+  }
+}
+main().catch((err) => {
+  console.error("[commonwealth-curate] error:", err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map