@balpal4495/quorum 0.3.0 → 0.4.2

package/bin/commands/init.js

@@ -0,0 +1,244 @@
+import { promises as fs } from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+import { execSync } from "child_process"
+import { createRequire } from "module"
+import { c, log } from "../shared/colors.js"
+
+const _require = createRequire(import.meta.url)
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const QUORUM_ROOT = path.resolve(__dirname, "../..")
+
+const DEPS = { zod: "^3.23.0" }
+const OPTIONAL_DEPS = {
+  vectordb: "^0.4.0",
+  "@xenova/transformers": "^2.17.0",
+}
+
+async function exists(p) {
+  return fs.access(p).then(() => true).catch(() => false)
+}
+
+async function readJson(p) {
+  return JSON.parse(await fs.readFile(p, "utf8"))
+}
+
+function geminiAvailable() {
+  try { execSync("which gemini", { stdio: "ignore" }); return true } catch { return false }
+}
+
+async function guardAlreadyInitialized(target) {
+  if (await exists(path.join(target, "quorum", "modules"))) {
+    console.log(c.yellow("\nQuorum is already initialized in this project."))
+    console.log("Remove quorum/ first if you want to reinitialize.\n")
+    process.exit(0)
+  }
+}
+
+async function copyModules(target) {
+  log.section("Copying modules")
+  const src  = path.join(QUORUM_ROOT, "modules")
+  const dest = path.join(target, "quorum", "modules")
+  await fs.cp(src, dest, {
+    recursive: true,
+    filter: (src) =>
+      !src.includes("__tests__") &&
+      !src.includes(".test.ts") &&
+      !src.includes(".spec.ts"),
+  })
+  log.created("quorum/modules/")
+  await fs.copyFile(
+    path.join(QUORUM_ROOT, "SETUP.md"),
+    path.join(target, "quorum", "SETUP.md"),
+  )
+  log.created("quorum/SETUP.md")
+}
+
+async function copyEvals(target) {
+  const src  = path.join(QUORUM_ROOT, "evals")
+  const dest = path.join(target, "quorum", "evals")
+  await fs.cp(src, dest, { recursive: true })
+  log.created("quorum/evals/")
+}
+
+async function mergeCopilotInstructions(target) {
+  log.section("Merging AI instruction files")
+  const src     = path.join(QUORUM_ROOT, ".github", "copilot-instructions.md")
+  const dest    = path.join(target, ".github", "copilot-instructions.md")
+  const content = await fs.readFile(src, "utf8")
+  await fs.mkdir(path.join(target, ".github"), { recursive: true })
+  if (await exists(dest)) {
+    const existing = await fs.readFile(dest, "utf8")
+    if (existing.includes("<!-- quorum -->")) { log.skipped(".github/copilot-instructions.md (already present)"); return }
+    await fs.appendFile(dest, `\n\n---\n\n<!-- quorum -->\n${content}`, "utf8")
+    log.appended(".github/copilot-instructions.md")
+  } else {
+    await fs.writeFile(dest, content, "utf8")
+    log.created(".github/copilot-instructions.md")
+  }
+}
+
+async function mergeAgentsMd(target) {
+  const dest    = path.join(target, "AGENTS.md")
+  const section = [
+    "", "## Quorum modules", "",
+    "See [quorum/modules/AGENTS.md](quorum/modules/AGENTS.md) for Oracle, Jury, and Council internals.",
+    "See [.github/copilot-instructions.md](.github/copilot-instructions.md) for workflow rules.", "",
+  ].join("\n")
+  if (await exists(dest)) {
+    const existing = await fs.readFile(dest, "utf8")
+    if (existing.includes("quorum/modules/AGENTS.md")) { log.skipped("AGENTS.md (already present)"); return }
+    await fs.appendFile(dest, section, "utf8")
+    log.appended("AGENTS.md")
+  } else {
+    await fs.writeFile(dest, `# Agent Instructions\n${section}`, "utf8")
+    log.created("AGENTS.md")
+  }
+}
+
+async function mergeClaudeMd(target) {
+  const dest = path.join(target, "CLAUDE.md")
+  const section = `
+## Quorum modules
+
+See [quorum/modules/CLAUDE.md](quorum/modules/CLAUDE.md) for Oracle, Jury, and Council internals.
+See [.github/copilot-instructions.md](.github/copilot-instructions.md) for workflow rules.
+
+## Gemini CLI (optional assistant)
+
+Before attempting any Gemini call, check availability:
+
+\`\`\`bash
+which gemini 2>/dev/null
+\`\`\`
+
+If the command returns empty, skip this section entirely. The project is fully functional
+without Gemini. Never try to install it or ask the user to install it mid-task.
+
+If Gemini is available, use it as a large-context assistant for tasks that require
+surveying many files at once — it can hold the entire codebase in a single context window.
+
+\`\`\`bash
+# The Bash tool does not auto-source shell profiles — always prefix with source:
+source ~/.zshrc && gemini -p "Summarise the public API across all modules"
+source ~/.zshrc && gemini -p "I'm about to change X. What should I watch out for?"
+\`\`\`
+
+You reason about Gemini's output — it assists, you decide. Never pass its response to the
+user unfiltered. If Gemini contradicts what you know from reading the code, trust your reading.
+`
+  if (await exists(dest)) {
+    const existing = await fs.readFile(dest, "utf8")
+    if (existing.includes("quorum/modules/CLAUDE.md")) { log.skipped("CLAUDE.md (already present)"); return }
+    await fs.appendFile(dest, section, "utf8")
+    log.appended("CLAUDE.md")
+  } else {
+    await fs.writeFile(dest, `# Claude Instructions\n${section}`, "utf8")
+    log.created("CLAUDE.md")
+  }
+}
+
+async function mergeGeminiMd(target) {
+  const dest = path.join(target, "GEMINI.md")
+  if (await exists(dest)) { log.skipped("GEMINI.md (already present)"); return }
+  if (!geminiAvailable()) { log.skipped("GEMINI.md (Gemini CLI not detected — install it later to enable)"); return }
+  const src = path.join(QUORUM_ROOT, "GEMINI.md")
+  if (await exists(src)) { await fs.copyFile(src, dest); log.created("GEMINI.md") }
+}
+
+async function updatePackageJson(target) {
+  log.section("Updating package.json")
+  const pkgPath = path.join(target, "package.json")
+  let pkg
+  if (await exists(pkgPath)) {
+    pkg = await readJson(pkgPath)
+  } else {
+    pkg = { name: path.basename(target), version: "0.1.0", private: true }
+    log.warn("No package.json found — creating a minimal one")
+  }
+  pkg.dependencies         = pkg.dependencies         ?? {}
+  pkg.optionalDependencies = pkg.optionalDependencies ?? {}
+  const added = []
+  for (const [name, version] of Object.entries(DEPS)) {
+    if (!pkg.dependencies[name]) { pkg.dependencies[name] = version; added.push(name) }
+  }
+  for (const [name, version] of Object.entries(OPTIONAL_DEPS)) {
+    if (!pkg.optionalDependencies[name]) { pkg.optionalDependencies[name] = version; added.push(`${name} (optional)`) }
+  }
+  await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8")
+  if (added.length > 0) {
+    log.appended(`package.json — added: ${added.join(", ")}`)
+  } else {
+    log.skipped("package.json (all deps already present)")
+  }
+}
+
+async function updateGitignore(target) {
+  log.section("Updating .gitignore")
+  const dest  = path.join(target, ".gitignore")
+  const block = [
+    "", "# Quorum — Chronicle",
+    "# entries/ is a binary vector store — do not commit",
+    ".chronicle/entries/", ".chronicle/query-log.jsonl", "",
+  ].join("\n")
+  if (await exists(dest)) {
+    const existing = await fs.readFile(dest, "utf8")
+    if (existing.includes(".chronicle/entries/")) { log.skipped(".gitignore (already present)"); return }
+    await fs.appendFile(dest, block, "utf8")
+    log.appended(".gitignore")
+  } else {
+    await fs.writeFile(dest, block.trimStart(), "utf8")
+    log.created(".gitignore")
+  }
+}
+
+async function createChronicle(target) {
+  log.section("Creating Chronicle")
+  await fs.mkdir(path.join(target, ".chronicle", "proposals"),  { recursive: true })
+  log.created(".chronicle/proposals/")
+  await fs.mkdir(path.join(target, ".chronicle", "committed"), { recursive: true })
+  log.created(".chronicle/committed/")
+}
+
+export async function run(PKG_VERSION) {
+  const target = process.cwd()
+
+  console.log(c.bold("\nQuorum init"))
+  console.log(`Target: ${c.dim(target)}\n`)
+
+  if (target === QUORUM_ROOT) {
+    console.log(c.yellow("Run this from your project directory, not the Quorum repo itself."))
+    process.exit(1)
+  }
+
+  await guardAlreadyInitialized(target)
+  await copyModules(target)
+  await copyEvals(target)
+  await mergeCopilotInstructions(target)
+  await mergeAgentsMd(target)
+  await mergeClaudeMd(target)
+  await mergeGeminiMd(target)
+  await updatePackageJson(target)
+  await updateGitignore(target)
+  await createChronicle(target)
+
+  const hasGemini = geminiAvailable()
+
+  console.log(`\n${c.green("✓ Quorum initialized.")}`)
+  console.log("\nNext steps:")
+  console.log("  1. npm install")
+  console.log("  2. Wire setup() into your entry point:\n")
+  console.log(c.dim('     import { setup } from "./quorum/modules/setup"'))
+  console.log(c.dim('     const { oracle, evaluate, deliberate } = await setup({ llm: yourProvider })'))
+  console.log("\n  Or tell your AI: \"follow quorum/SETUP.md\"")
+
+  if (!hasGemini) {
+    console.log(`\n  ${c.dim("Optional: install Gemini CLI for large-context assistance")}`)
+    console.log(c.dim("  npm install -g @google/gemini-cli  +  set GEMINI_API_KEY"))
+    console.log(c.dim("  See quorum/SETUP.md Step 10 for details."))
+  } else {
+    console.log(`\n  ${c.green("✓ Gemini CLI detected")} — GEMINI.md written. Set GEMINI_API_KEY if not already set.`)
+  }
+  console.log("")
+}

package/bin/commands/sentinel.js

@@ -0,0 +1,160 @@
+import { promises as fs, Dirent } from "fs"
+import path from "path"
+import { c } from "../shared/colors.js"
+import { findChronicleDir, readCommitted } from "../shared/chronicle.js"
+
+// Mirrors the ignored dirs in modules/sentinel/coverage.ts
+const IGNORED_DIRS = new Set(["node_modules", "dist", ".git", ".chronicle", "coverage", "__tests__"])
+const TEST_SUFFIXES = [".test.ts", ".spec.ts", ".test.js", ".spec.js"]
+
+function parseArgs(argv) {
+  const args = { subcommand: "coverage", codebasePath: process.cwd(), json: false }
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "coverage" || argv[i] === "drift") { args.subcommand = argv[i]; continue }
+    if ((argv[i] === "--path" || argv[i] === "-p") && argv[i + 1]) { args.codebasePath = argv[++i]; continue }
+    if (argv[i] === "--json") { args.json = true; continue }
+  }
+  return args
+}
+
+async function walkFiles(dir, extensions, excludeTestFiles) {
+  const results = []
+  async function recurse(current) {
+    let entries
+    try { entries = await fs.readdir(current, { withFileTypes: true, encoding: "utf8" }) } catch { return }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRS.has(entry.name)) await recurse(path.join(current, entry.name))
+      } else if (extensions.some(ext => entry.name.endsWith(ext))) {
+        if (excludeTestFiles && TEST_SUFFIXES.some(s => entry.name.endsWith(s))) continue
+        results.push(path.join(current, entry.name))
+      }
+    }
+  }
+  await recurse(dir)
+  return results
+}
+
+function isCovered(relativePath, entries) {
+  const matched = []
+  const normalised = relativePath.replace(/\\/g, "/")
+  for (const entry of entries) {
+    const hits = (entry.affected_areas ?? []).some(area => {
+      const normArea = area.replace(/\\/g, "/")
+      return normalised.includes(normArea) || normArea.includes(normalised)
+    })
+    if (hits) matched.push(entry.id)
+  }
+  return { covered: matched.length > 0, entryIds: matched }
+}
+
+function barChart(pct, width = 20) {
+  const filled = Math.round((pct / 100) * width)
+  const bar    = "█".repeat(filled) + "░".repeat(width - filled)
+  const color  = pct === 0 ? c.red : pct < 50 ? c.yellow : c.green
+  return color(bar)
+}
+
+async function runCoverage(args) {
+  const extensions = [".ts"]
+  const chronicleDir  = await findChronicleDir(process.cwd())
+  const codebasePath  = path.resolve(args.codebasePath)
+
+  if (!chronicleDir) {
+    console.error(`\n${c.red("No .chronicle/ directory found.")} Run ${c.bold("quorum init")} first.\n`)
+    process.exit(1)
+  }
+
+  const [entries, files] = await Promise.all([
+    readCommitted(chronicleDir),
+    walkFiles(codebasePath, extensions, true),
+  ])
+
+  const coverageByFile = files.map(absolute => {
+    const relative = path.relative(codebasePath, absolute).replace(/\\/g, "/")
+    const { covered, entryIds } = isCovered(relative, entries)
+    return { file: relative, covered, entryIds }
+  })
+
+  const covered   = coverageByFile.filter(f => f.covered)
+  const uncovered = coverageByFile.filter(f => !f.covered)
+  const pct       = files.length === 0 ? 0 : Math.round((covered.length / files.length) * 100)
+
+  if (args.json) {
+    console.log(JSON.stringify({
+      totalFiles: files.length,
+      coveredFiles: covered.length,
+      uncoveredFiles: uncovered.map(f => f.file),
+      coverageByFile,
+      percentage: pct,
+    }, null, 2))
+    return
+  }
+
+  // ── Header ─────────────────────────────────────────────────────────────────
+  console.log(`\n${c.bold("Chronicle coverage")}  ${c.dim(codebasePath)}\n`)
+  console.log(`  ${barChart(pct)}  ${pct}%  (${covered.length}/${files.length} files)\n`)
+
+  if (entries.length === 0) {
+    console.log(c.dim("  No committed Chronicle entries — nothing to match against.\n"))
+    return
+  }
+
+  if (files.length === 0) {
+    console.log(c.dim(`  No .ts files found under ${codebasePath}\n`))
+    console.log(c.dim(`  Tip: quorum sentinel coverage --path ./modules\n`))
+    return
+  }
+
+  // ── Covered files ──────────────────────────────────────────────────────────
+  if (covered.length > 0) {
+    console.log(c.bold("Covered"))
+    for (const f of covered) {
+      console.log(`  ${c.green("✓")}  ${f.file}  ${c.dim(`(${f.entryIds.length} ${f.entryIds.length === 1 ? "entry" : "entries"})`)}`)
+    }
+    console.log("")
+  }
+
+  // ── Uncovered files ────────────────────────────────────────────────────────
+  if (uncovered.length > 0) {
+    console.log(c.bold("Uncovered") + c.dim("  (no Chronicle entries reference these files)"))
+    const show = uncovered.slice(0, 20)
+    for (const f of show) {
+      console.log(`  ${c.dim("✗")}  ${f.file}`)
+    }
+    if (uncovered.length > 20) {
+      console.log(`  ${c.dim(`… and ${uncovered.length - 20} more`)}`)
+    }
+    console.log("")
+  }
+
+  // ── Tip ────────────────────────────────────────────────────────────────────
+  if (pct < 100) {
+    console.log(c.dim(`  Tip: add Chronicle entries for uncovered files via oracle.propose() in your app,`))
+    console.log(c.dim(`       then run quorum commit <id> to index them.\n`))
+  }
+}
+
+export async function run(argv) {
+  const args = parseArgs(argv)
+
+  if (args.subcommand === "drift") {
+    console.log(`\n${c.yellow("quorum sentinel drift")} requires an LLM provider and is not available as a standalone CLI command.`)
+    console.log(c.dim("\nUse the sentinelAssertions() helper in your test suite instead:"))
+    console.log(c.dim("\n  import { sentinelAssertions } from \"./quorum/modules/sentinel\""))
+    console.log(c.dim("  const assertions = sentinelAssertions({ llm: yourProvider })"))
+    console.log(c.dim("  describe(\"sentinel\", () => { assertions.forEach(a => a()) })\n"))
+    process.exit(0)
+  }
+
+  if (args.subcommand === "coverage" || !argv.length) {
+    await runCoverage(args)
+    return
+  }
+
+  console.error(`\n${c.bold("quorum sentinel")} — Chronicle analysis\n`)
+  console.error("Subcommands:")
+  console.error(`  quorum sentinel coverage [--path <dir>]  Chronicle coverage of source files`)
+  console.error(`  quorum sentinel coverage --json          Machine-readable output`)
+  console.error(`  quorum sentinel drift                    (requires LLM — use sentinelAssertions() instead)\n`)
+}

package/bin/commands/status.js

@@ -0,0 +1,117 @@
+import { c } from "../shared/colors.js"
+import { findChronicleDir, readProposals, readCommitted, entryText } from "../shared/chronicle.js"
+
+function relativeTime(isoString) {
+  const ms = Date.now() - new Date(isoString).getTime()
+  const mins  = Math.floor(ms / 60_000)
+  const hours = Math.floor(ms / 3_600_000)
+  const days  = Math.floor(ms / 86_400_000)
+  if (mins < 2)    return "just now"
+  if (mins < 60)   return `${mins}m ago`
+  if (hours < 24)  return `${hours}h ago`
+  if (days < 30)   return `${days}d ago`
+  return new Date(isoString).toISOString().slice(0, 10)
+}
+
+function statusBadge(status) {
+  switch (status) {
+    case "accepted":  return c.green("accepted")
+    case "refuted":   return c.red("refuted")
+    case "superseded":return c.yellow("superseded")
+    default:          return c.dim(status ?? "unknown")
+  }
+}
+
+export async function run(argv) {
+  const jsonMode = argv.includes("--json")
+  const cwd = process.cwd()
+
+  const chronicleDir = await findChronicleDir(cwd)
+
+  if (!chronicleDir) {
+    if (jsonMode) {
+      console.log(JSON.stringify({ error: "No .chronicle directory found", initialized: false }))
+    } else {
+      console.log(`\n${c.yellow("No .chronicle/ found")} in ${cwd} or any parent directory.`)
+      console.log(`${c.dim("Run")} quorum init ${c.dim("first.")}\n`)
+    }
+    process.exit(1)
+  }
+
+  const [proposals, committed] = await Promise.all([
+    readProposals(chronicleDir),
+    readCommitted(chronicleDir),
+  ])
+
+  if (jsonMode) {
+    console.log(JSON.stringify({
+      initialized: true,
+      chronicleDir,
+      proposals: proposals.length,
+      committed: committed.length,
+      pendingProposals: proposals.map(p => ({
+        id: p.proposalId,
+        key_insight: p.key_insight,
+        affected_areas: p.affected_areas,
+      })),
+      recentEntries: committed.slice(0, 5).map(e => ({
+        id: e.id,
+        status: e.status,
+        key_insight: e.key_insight,
+        timestamp: e.timestamp,
+      })),
+    }, null, 2))
+    return
+  }
+
+  // ── Header ────────────────────────────────────────────────────────────────
+  console.log(`\n${c.bold("Chronicle status")}  ${c.dim(chronicleDir)}\n`)
+
+  // ── Counts ────────────────────────────────────────────────────────────────
+  const acceptedCount  = committed.filter(e => e.status === "accepted").length
+  const refutedCount   = committed.filter(e => e.status === "refuted").length
+  const otherCount     = committed.length - acceptedCount - refutedCount
+
+  console.log(`  ${c.bold(String(committed.length).padStart(4))}  committed entries  ` +
+    `(${c.green(acceptedCount + " accepted")}, ${c.red(refutedCount + " refuted")}${otherCount ? `, ${otherCount} other` : ""})`)
+  console.log(`  ${c.bold(String(proposals.length).padStart(4))}  pending proposals\n`)
+
+  // ── Pending proposals ─────────────────────────────────────────────────────
+  if (proposals.length > 0) {
+    console.log(c.bold("Pending proposals") + c.dim("  (awaiting quorum commit <id>)"))
+    for (const p of proposals) {
+      const insight = (entryText(p) ?? "").slice(0, 72)
+      const areas   = (p.affected_areas ?? []).join(", ").slice(0, 40)
+      console.log(`  ${c.cyan(p.proposalId.slice(0, 8))}  ${insight}`)
+      if (areas) console.log(`          ${c.dim(areas)}`)
+    }
+    console.log("")
+  }
+
+  // ── Recent committed entries ───────────────────────────────────────────────
+  if (committed.length > 0) {
+    console.log(c.bold("Recent entries"))
+    for (const e of committed.slice(0, 8)) {
+      const insight = (entryText(e) ?? "").slice(0, 65)
+      const when    = relativeTime(e.timestamp)
+      const areas   = (e.affected_areas ?? []).join(", ").slice(0, 35)
+      console.log(
+        `  ${c.dim(e.id.slice(0, 8))}  [${statusBadge(e.status)}]  ` +
+        `${insight}  ${c.dim(when)}`
+      )
+      if (areas) console.log(`          ${c.dim(areas)}`)
+    }
+    if (committed.length > 8) {
+      console.log(`  ${c.dim(`… and ${committed.length - 8} more`)}`)
+    }
+    console.log("")
+  } else {
+    console.log(c.dim("  No committed entries yet.\n"))
+  }
+
+  // ── Hint ──────────────────────────────────────────────────────────────────
+  if (proposals.length > 0) {
+    console.log(c.dim(`  Tip: quorum commit <first-8-chars-of-id>  to approve a proposal`))
+    console.log(c.dim(`       quorum commit --list                  to see full proposal details\n`))
+  }
+}

package/bin/init.js

@@ -5,7 +5,7 @@
  * Drops Quorum into an existing Node.js project.
  * Run from the target project root:
  *
- *   npx github:balpal4495/Quorum init
+ *   npx @balpal4495/quorum@latest init
  *
  * Zero external dependencies — uses only Node.js built-ins.
  * Requires Node.js 18+.
@@ -104,6 +104,13 @@ async function copyModules() {
   log.created("quorum/SETUP.md")
 }
 
+async function copyEvals() {
+  const src  = path.join(QUORUM_ROOT, "evals")
+  const dest = path.join(TARGET, "quorum", "evals")
+  await fs.cp(src, dest, { recursive: true })
+  log.created("quorum/evals/")
+}
+
 async function mergeCopilotInstructions() {
   log.section("Merging AI instruction files")
 
@@ -309,6 +316,7 @@ async function main() {
 
   await guardAlreadyInitialized()
   await copyModules()
+  await copyEvals()
   await mergeCopilotInstructions()
   await mergeAgentsMd()
   await mergeClaudeMd()

package/bin/quorum.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { createRequire } from "module"
+import { fileURLToPath } from "url"
+import path from "path"
+
+const _require = createRequire(import.meta.url)
+const PKG_VERSION = _require("../package.json").version
+
+const c = {
+  bold:  (s) => `\x1b[1m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  blue:  (s) => `\x1b[34m${s}\x1b[0m`,
+  dim:   (s) => `\x1b[90m${s}\x1b[0m`,
+  cyan:  (s) => `\x1b[36m${s}\x1b[0m`,
+  red:   (s) => `\x1b[31m${s}\x1b[0m`,
+}
+
+function help() {
+  console.log(`
+${c.bold("quorum")} ${c.dim(`v${PKG_VERSION}`)} — portable reasoning layer for agentic codebases
+
+${c.bold("Usage:")}
+  ${c.cyan("quorum init")}                          Scaffold Quorum into a project
+  ${c.cyan("quorum status")}                        Show Chronicle health and pending proposals
+  ${c.cyan("quorum check")} --outcome <x> --design <y>  Preflight + risk (no LLM)
+  ${c.cyan("quorum commit")} <id>                   Approve and index a Chronicle proposal
+  ${c.cyan("quorum sentinel")} [coverage]           Chronicle coverage of source files
+  ${c.cyan("quorum --version")}                     Print version
+
+${c.bold("quorum check")} flags:
+  --outcome  -o   What you want to achieve
+  --design   -d   How you plan to do it
+  --json          Machine-readable JSON output
+  (also accepts JSON on stdin: ${c.dim('echo \'{"outcome":"…","design":"…"}\' | quorum check')})
+
+${c.bold("quorum commit")} flags:
+  --dry-run       Preview without writing
+  --list          List pending proposals
+
+${c.bold("quorum sentinel")} subcommands:
+  coverage [--path <dir>]   Chronicle coverage for .ts files (default: cwd)
+  drift                     (requires LLM — use sentinelAssertions() instead)
+  --json                    Machine-readable output
+
+${c.bold("Exit codes")} (quorum check):
+  0  low / medium risk
+  1  high risk
+  2  critical risk
+`)
+}
+
+async function cli() {
+  const [,, command = "", ...rest] = process.argv
+
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    help(); return
+  }
+
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(PKG_VERSION); return
+  }
+
+  const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+  if (command === "init") {
+    const { run } = await import(path.join(__dirname, "commands/init.js"))
+    await run(PKG_VERSION)
+    return
+  }
+
+  if (command === "status") {
+    const { run } = await import(path.join(__dirname, "commands/status.js"))
+    await run(rest)
+    return
+  }
+
+  if (command === "check") {
+    const { run } = await import(path.join(__dirname, "commands/check.js"))
+    await run(rest)
+    return
+  }
+
+  if (command === "commit") {
+    const { run } = await import(path.join(__dirname, "commands/commit.js"))
+    await run(rest)
+    return
+  }
+
+  if (command === "sentinel") {
+    const { run } = await import(path.join(__dirname, "commands/sentinel.js"))
+    await run(rest)
+    return
+  }
+
+  console.error(`${c.red(`Unknown command: ${command}`)}`)
+  console.error(`Run ${c.bold("quorum help")} for usage.`)
+  process.exit(1)
+}
+
+cli().catch((err) => {
+  console.error(`\x1b[31m\nQuorum failed:\x1b[0m ${err.message}`)
+  process.exit(1)
+})