@balpal4495/quorum 3.5.0 → 3.7.0

package/README.md

@@ -205,6 +205,79 @@ quorum advisor brief
 
 ---
 
+## LLM setup
+
+LLM-powered commands (`advisor`, `evolve`, `check`, `compass`, `serve`) auto-detect whichever provider is available. No config file is needed — Quorum picks the first working option from the list below.
+
+**Recommended: use a CLI tool you're already logged into.** No API key required.
+
+### Option 1 — Claude Code CLI (recommended)
+
+If you have [Claude Code](https://claude.ai/code) installed and are logged in, Quorum uses it automatically.
+
+```bash
+# Verify it's working
+echo "say hi" | claude --print
+```
+
+Quorum detects the `Claude Code-credentials` keychain entry (macOS) or a session file in `~/.claude/sessions/`. If the command above works, Quorum will use it.
+
+### Option 2 — GitHub Copilot CLI
+
+If you have the [GitHub Copilot CLI](https://docs.github.com/en/copilot/how-tos/use-copilot-agents/use-copilot-cli) installed and are logged in via VS Code, Quorum uses it automatically.
+
+```bash
+# Verify it's working
+copilot -p "say hi"
+```
+
+Quorum detects `~/.copilot/session-state/` having at least one session (created after first auth). If the command above works, Quorum will use it.
+
+### Option 3 — API keys
+
+Set any one of these environment variables:
+
+| Variable | Provider |
+|---|---|
+| `ANTHROPIC_API_KEY` | Anthropic Claude |
+| `OPENAI_API_KEY` | OpenAI |
+| `GEMINI_API_KEY` | Google Gemini |
+| `OPENAI_BASE_URL` | Any OpenAI-compatible endpoint (Azure, Groq, etc.) |
+
+```bash
+export ANTHROPIC_API_KEY=sk-ant-...
+```
+
+### Option 4 — Gemini CLI
+
+If you have the [Gemini CLI](https://github.com/google-gemini/gemini-cli) installed and authenticated, Quorum uses it automatically.
+
+```bash
+# Verify it's working
+gemini -p "say hi"
+```
+
+### Option 5 — Ollama (local, last resort)
+
+If Ollama is running at `localhost:11434`, Quorum uses the first available model. Set `OLLAMA_MODEL` to pin a specific model, or `OLLAMA_HOST` for a non-default address.
+
+```bash
+ollama serve
+export OLLAMA_MODEL=llama3.2   # optional
+```
+
+### Checking what was detected
+
+```bash
+quorum serve   # startup line shows: LLM: Claude Code CLI
+```
+
+### No LLM — still useful
+
+Without any provider, `advisor query`, `advisor brief`, `check`, and `coverage` all work with no LLM. Commands output Chronicle evidence and a synthesis request that your agent (Claude Code, Copilot, Codex) can answer inline.
+
+---
+
 ## Upgrading from v1
 
 If your project has a `quorum/modules/` folder (the v1 vendored pattern), migrate in one step:
@@ -602,7 +675,7 @@ Refuted entries always elevate risk by at least one level. Citation validation s
 
 ### LLM auto-detection
 
-Quorum finds whichever LLM is available: `ANTHROPIC_API_KEY` → `OPENAI_API_KEY` → `GEMINI_API_KEY` → `OPENAI_BASE_URL` → Ollama at `localhost:11434` → authenticated `gemini` CLI. When running inside an AI agent with no separate key, commands output Chronicle evidence and a synthesis request — the agent answers inline.
+Quorum tries providers in this order: **Claude Code CLI** → **Copilot CLI** → `ANTHROPIC_API_KEY` → `OPENAI_API_KEY` → `GEMINI_API_KEY` → `OPENAI_BASE_URL` → Gemini CLI → Ollama. See [LLM setup](#llm-setup) for how to configure each option.
 
 ---
 

package/bin/commands/compass.js

@@ -753,7 +753,13 @@ async function loadLastArtifact(chronicleDir) {
 
 // ── Main ─────────────────────────────────────────────────────────────────────
 
-export async function run(argv) {
+/**
+ * @param {string[]} argv
+ * @param {Function|null} [injectedLlm] - Pre-detected LLM provider. When
+ *   supplied, provider detection is skipped entirely (avoids the ~1.5 s Ollama
+ *   probe on every MCP/serve request).
+ */
+export async function run(argv, injectedLlm) {
   const [subcommand, ...rest] = argv
 
   if (!subcommand || subcommand === "--help" || subcommand === "-h") {
@@ -794,8 +800,8 @@ export async function run(argv) {
   }
 
   const NO_LLM_CMDS = new Set(["map", "opportunities", "behavior", "propose", "outcome"])
-  const provider = NO_LLM_CMDS.has(subcommand) ? null : await detectProvider()
-  const llm = provider?.llm
+  const llm = injectedLlm
+    ?? (NO_LLM_CMDS.has(subcommand) ? null : (await detectProvider())?.llm)
 
   // ── Shared context helper ─────────────────────────────────────────────────
 

package/bin/commands/llm.js

@@ -0,0 +1,108 @@
+import { probeAll, detectProvider } from "../shared/llm.js"
+import { c } from "../shared/colors.js"
+
+function row(detected, name, note, suffix = "") {
+  const icon  = detected ? c.green("✓") : c.dim("·")
+  const label = detected ? c.bold(name) : c.dim(name)
+  const right  = detected
+    ? (note ? c.dim(`  ${note}`) : "") + (suffix ? `  ${suffix}` : "")
+    : (note ? `  ${c.dim(note)}` : "")
+  return `  ${icon}  ${label.padEnd(26)}${right}`
+}
+
+export async function run(args) {
+  const test = args.includes("--test")
+
+  console.log("")
+  console.log(`${c.bold("quorum llm")}  ${c.dim("— LLM provider status")}`)
+  console.log("")
+
+  // Run all probes in parallel with active provider detection
+  const [providers, active] = await Promise.all([probeAll(), detectProvider()])
+  const activeName = active?.name ?? null
+
+  console.log("  Provider scan")
+  console.log(c.dim("  ─────────────────────────────────────────────────────"))
+
+  // Normalize names for active matching (gatherCandidates uses "Gemini", probeAll uses "Gemini API")
+  const norm = n => n.replace(/ API$/, "").replace(/ \(.*?\)$/, "").toLowerCase()
+
+  for (const p of providers) {
+    const isActive = p.detected && !!activeName && norm(p.name) === norm(activeName)
+
+    const badges = []
+    if (isActive)                                  badges.push(c.green("← active"))
+    if (p.detected && p.id === "ollama" && p.note) badges.push(c.dim(`(${p.note})`))
+    const suffix = badges.join("  ")
+
+    console.log(row(p.detected, p.name, null, suffix))
+    if (!p.detected && p.note) {
+      console.log(`       ${c.dim(p.note)}`)
+    }
+  }
+
+  console.log("")
+
+  if (!activeName) {
+    console.log(`  ${c.yellow("No provider detected.")}`)
+    console.log("")
+    printSetupGuide()
+    return
+  }
+
+  console.log(`  Active: ${c.bold(activeName)}`)
+  console.log("")
+
+  if (!test) {
+    console.log(c.dim("  Run 'quorum llm --test' to send a live request and verify it works."))
+    console.log("")
+    return
+  }
+
+  // ── Live test ──────────────────────────────────────────────────────────────
+  process.stdout.write(`  Testing ${c.bold(activeName)}… `)
+  const t0 = Date.now()
+
+  try {
+    const result = await active.llm([
+      { role: "user", content: "Respond with exactly the word OK and nothing else." },
+    ])
+    const ms = Date.now() - t0
+    const ok = /\bOK\b/i.test(result?.trim() ?? "")
+    if (ok) {
+      console.log(`${c.green("✓")}  ${c.dim(`(${ms}ms)`)}`)
+    } else {
+      console.log(`${c.yellow("✓ (unexpected response)")}  ${c.dim(`(${ms}ms)`)}`)
+      console.log(c.dim(`     → ${(result ?? "").slice(0, 120)}`))
+    }
+  } catch (err) {
+    console.log(c.red("✗"))
+    console.log(`     ${c.red(err.message?.slice(0, 200) ?? String(err))}`)
+    console.log("")
+    console.log(`  ${c.yellow("The detected provider failed.")} Check that you're signed in, then retry.`)
+  }
+  console.log("")
+}
+
+function printSetupGuide() {
+  console.log("  Quickest options:")
+  console.log("")
+  console.log(`  ${c.bold("A")}  ${c.bold("Claude Code CLI")}  ${c.dim("(no API key needed)")}`)
+  console.log(c.dim("     Install and sign in: https://claude.ai/code"))
+  console.log(c.dim("     Quorum auto-detects it once you're signed in."))
+  console.log("")
+  console.log(`  ${c.bold("B")}  ${c.bold("GitHub Copilot CLI")}  ${c.dim("(no API key needed)")}`)
+  console.log(c.dim("     Install VS Code + GitHub Copilot Chat extension, then sign in."))
+  console.log(c.dim("     Quorum auto-detects it once a session exists."))
+  console.log("")
+  console.log(`  ${c.bold("C")}  ${c.bold("API key")}  ${c.dim("(Anthropic, OpenAI, or Gemini)")}`)
+  console.log(c.dim("     export ANTHROPIC_API_KEY=sk-ant-…"))
+  console.log(c.dim("     export OPENAI_API_KEY=sk-…"))
+  console.log(c.dim("     export GEMINI_API_KEY=…"))
+  console.log("")
+  console.log(`  ${c.bold("D")}  ${c.bold("Ollama")}  ${c.dim("(local, free)")}`)
+  console.log(c.dim("     brew install ollama && ollama serve && ollama pull llama3.2"))
+  console.log("")
+  console.log(`  ${c.dim("After setup, run 'quorum llm' again to confirm detection.")}`)
+  console.log("")
+}

package/bin/mcp/tools.js

@@ -304,22 +304,26 @@ export async function toolCheck({ outcome, design, projectRoot } = {}) {
 export async function toolCompass({ subcommand = "brief", goal, idea, projectRoot } = {}) {
   if (!_llm) return NO_LLM("quorum_compass")
 
-  const { chronicleDir } = await resolve(projectRoot)
-  // Delegate to the compass CLI command handler for now
   const { run: compassRun } = await import("../commands/compass.js")
-  // Capture stdout
+
+  // Capture stdout — always request JSON so there are no ANSI codes
   const captured = []
   const origWrite = process.stdout.write.bind(process.stdout)
   process.stdout.write = (chunk, ...rest) => { captured.push(String(chunk)); return true }
   try {
-    const extraArgs = []
+    const extraArgs = ["--json"]
     if (subcommand === "pathways" && goal) extraArgs.push("--goal", goal)
     if (subcommand === "score"    && idea) extraArgs.push("--idea", idea)
-    await compassRun([subcommand, ...extraArgs])
+    // Pass _llm directly to skip the ~1.5 s provider re-detection on every request
+    await compassRun([subcommand, ...extraArgs], _llm)
   } finally {
     process.stdout.write = origWrite
   }
-  return { subcommand, output: captured.join("").trim() }
+
+  const raw = captured.join("").trim()
+  let data = null
+  try { data = JSON.parse(raw) } catch { /* fallback to raw string below */ }
+  return { subcommand, data, output: data ? null : raw }
 }
 
 /**

package/bin/quorum.js

@@ -23,6 +23,8 @@ ${c.bold("Usage:")}
   ${c.cyan("quorum advisor")} ${c.dim('"question"')}             Ask a plain-language question (uses LLM)
   ${c.cyan("quorum advisor query")} ${c.dim('"topic"')}          Search Chronicle entries (no LLM)
   ${c.cyan("quorum advisor brief")}                 High-level Chronicle summary (no LLM)
+  ${c.cyan("quorum llm")}                           Show LLM provider status and setup guide
+  ${c.cyan("quorum llm --test")}                    Send a live test request to the active provider
   ${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)
@@ -116,6 +118,12 @@ async function cli() {
     return
   }
 
+  if (command === "llm") {
+    const { run } = await import(path.join(__dirname, "commands/llm.js"))
+    await run(rest)
+    return
+  }
+
   if (command === "init") {
     const { run } = await import(path.join(__dirname, "commands/init.js"))
     await run(PKG_VERSION)

package/bin/shared/llm.js

@@ -11,10 +11,12 @@ const execAsync = promisify(exec)
  * Detection order (highest priority first):
  *   1. ANTHROPIC_API_KEY            → Anthropic Claude
  *   2. OPENAI_API_KEY               → OpenAI (or compatible via OPENAI_BASE_URL)
- *   3. GEMINI_API_KEY               → Google Gemini (API)
- *   4. OPENAI_BASE_URL (no key)     → OpenAI-compatible endpoint (Azure, Groq, etc.)
- *   5. OLLAMA_HOST / localhost:11434 → Ollama (probed in parallel with the above)
- *   6. gemini CLI in PATH           → Google Gemini (CLI subprocess)
+ *   3. OPENAI_BASE_URL (no key)     → OpenAI-compatible endpoint (Azure, Groq, etc.)
+ *   4. GEMINI_API_KEY               → Google Gemini (API)
+ *   5. claude CLI in PATH           → Claude Code (CLI subprocess, --print mode)
+ *   6. copilot CLI in PATH          → GitHub Copilot CLI (-p / --prompt mode)
+ *   7. gemini CLI in PATH           → Google Gemini (CLI subprocess)
+ *   8. OLLAMA_HOST / localhost:11434 → Ollama (last resort — local models)
  *
  * All detected providers are tried in order. A 429 / quota / rate-limit error
  * from one provider causes a silent fallback to the next rather than a hard
@@ -39,8 +41,10 @@ export async function detectProvider() {
  */
 async function gatherCandidates() {
   // Probe async sources concurrently
-  const [ollamaModel, geminiCLIAvail] = await Promise.all([
+  const [ollamaModel, claudeCLIAvail, copilotCLIAvail, geminiCLIAvail] = await Promise.all([
     probeOllama(process.env.OLLAMA_HOST || "http://localhost:11434"),
+    probeClaudeCLI(),
+    probeCopilotCLI(),
     probeGeminiCLI(),
   ])
 
@@ -77,11 +81,17 @@ async function gatherCandidates() {
     })
   }
 
-  if (ollamaModel) {
-    const host = process.env.OLLAMA_HOST || "http://localhost:11434"
+  if (claudeCLIAvail) {
     candidates.push({
-      llm:  createOpenAICompatProvider("", `${host}/v1`, ollamaModel),
-      name: `Ollama (${ollamaModel})`,
+      llm:  createClaudeCLIProvider(),
+      name: "Claude Code CLI",
+    })
+  }
+
+  if (copilotCLIAvail) {
+    candidates.push({
+      llm:  createCopilotCLIProvider(),
+      name: "Copilot CLI",
     })
   }
 
@@ -92,6 +102,15 @@ async function gatherCandidates() {
     })
   }
 
+  // Ollama is last — local models are the slowest fallback
+  if (ollamaModel) {
+    const host = process.env.OLLAMA_HOST || "http://localhost:11434"
+    candidates.push({
+      llm:  createOpenAICompatProvider("", `${host}/v1`, ollamaModel),
+      name: `Ollama (${ollamaModel})`,
+    })
+  }
+
   return candidates
 }
 
@@ -139,6 +158,113 @@ export async function detectLLMName() {
   return (await detectProvider())?.name ?? null
 }
 
+/**
+ * Probe all providers and return a priority-ordered status array suitable for
+ * display (e.g. quorum llm). Each entry:
+ *   { id, name, detected: bool, note: string|null }
+ * 'detected' = true  → provider is ready to use right now
+ * 'note'            → setup hint when not detected, or detail when detected
+ */
+export async function probeAll() {
+  // Run async probes in parallel
+  const [ollamaModel, claudeDetail, copilotDetail, geminiDetail] = await Promise.all([
+    probeOllama(process.env.OLLAMA_HOST || "http://localhost:11434"),
+    probeCliDetail("claude", async () => {
+      const { platform } = await import("os")
+      if (platform() === "darwin") {
+        await execAsync("security find-generic-password -s 'Claude Code-credentials' 2>/dev/null")
+        return true
+      }
+      const { readdir } = await import("fs/promises")
+      const { homedir } = await import("os")
+      const sessions = await readdir(path.join(homedir(), ".claude", "sessions")).catch(() => [])
+      return sessions.length > 0
+    }),
+    probeCliDetail("copilot", async () => {
+      const { readdir } = await import("fs/promises")
+      const { homedir } = await import("os")
+      const sessions = await readdir(path.join(homedir(), ".copilot", "session-state")).catch(() => [])
+      return sessions.length > 0
+    }),
+    probeCliDetail("gemini", async () => {
+      if (process.env.GOOGLE_GENAI_USE_VERTEXAI || process.env.GOOGLE_APPLICATION_CREDENTIALS) return true
+      const { readFile } = await import("fs/promises")
+      const { homedir } = await import("os")
+      const raw = await readFile(path.join(homedir(), ".gemini", "settings.json"), "utf8")
+      return !!JSON.parse(raw).selectedAuthType
+    }),
+  ])
+
+  const hasOpenAIKey  = !!process.env.OPENAI_API_KEY
+  const hasOpenAIBase = !!process.env.OPENAI_BASE_URL
+  let openAIName = "OpenAI API"
+  if (hasOpenAIBase && !hasOpenAIKey) {
+    try { openAIName = `OpenAI-compatible (${new URL(process.env.OPENAI_BASE_URL).hostname})` } catch { /**/ }
+  }
+
+  return [
+    {
+      id:       "anthropic",
+      name:     "Anthropic API",
+      detected: !!process.env.ANTHROPIC_API_KEY,
+      note:     process.env.ANTHROPIC_API_KEY ? null : "export ANTHROPIC_API_KEY=sk-ant-…",
+    },
+    {
+      id:       "openai",
+      name:     openAIName,
+      detected: hasOpenAIKey || hasOpenAIBase,
+      note:     hasOpenAIKey || hasOpenAIBase ? null : "export OPENAI_API_KEY=sk-…",
+    },
+    {
+      id:       "gemini-api",
+      name:     "Gemini API",
+      detected: !!process.env.GEMINI_API_KEY,
+      note:     process.env.GEMINI_API_KEY ? null : "export GEMINI_API_KEY=…",
+    },
+    {
+      id:       "claude-cli",
+      name:     "Claude Code CLI",
+      detected: claudeDetail.authed,
+      note:     claudeDetail.authed    ? null
+              : claudeDetail.inPath    ? "found in PATH but not signed in — run: claude"
+              :                          "install from claude.ai/code, then sign in once",
+    },
+    {
+      id:       "copilot-cli",
+      name:     "Copilot CLI",
+      detected: copilotDetail.authed,
+      note:     copilotDetail.authed   ? null
+              : copilotDetail.inPath   ? "found but no session — open VS Code and sign into Copilot Chat"
+              :                          "install VS Code + GitHub Copilot Chat extension",
+    },
+    {
+      id:       "gemini-cli",
+      name:     "Gemini CLI",
+      detected: geminiDetail.authed,
+      note:     geminiDetail.authed    ? null
+              : geminiDetail.inPath    ? "found but not authenticated — run: gemini auth"
+              :                          "npm install -g @google/gemini-cli, then: gemini auth",
+    },
+    {
+      id:       "ollama",
+      name:     "Ollama",
+      detected: !!ollamaModel,
+      note:     ollamaModel ?? "run: ollama serve  (then: ollama pull llama3.2)",
+    },
+  ]
+}
+
+/**
+ * Probe a CLI binary — returns { inPath, authed }.
+ * authCheck is called only when the binary is found; errors are treated as "not authed".
+ */
+async function probeCliDetail(binary, authCheck) {
+  let inPath = false
+  try { await execAsync(`which ${binary}`); inPath = true } catch { /**/ }
+  if (!inPath) return { inPath: false, authed: false }
+  try { const authed = await authCheck(); return { inPath: true, authed: !!authed } } catch { return { inPath: true, authed: false } }
+}
+
 // ── Probe Ollama ───────────────────────────────────────────────────────────────
 
 async function probeOllama(host) {
@@ -236,6 +362,115 @@ function createGeminiProvider(apiKey) {
   }
 }
 
+async function probeClaudeCLI() {
+  // Must be in PATH
+  try {
+    await execAsync("which claude")
+  } catch {
+    return false
+  }
+
+  // Must have an active session — Claude Code stores OAuth tokens in the macOS keychain.
+  // A quick smoke-test is cheaper than shelling out; check the keychain entry exists.
+  // On non-macOS, fall back to checking ~/.claude/sessions/ for any session file.
+  try {
+    const { platform } = await import("os")
+    if (platform() === "darwin") {
+      await execAsync("security find-generic-password -s 'Claude Code-credentials' 2>/dev/null")
+      return true
+    }
+    // Non-macOS: check for at least one session file
+    const { readdir } = await import("fs/promises")
+    const { homedir } = await import("os")
+    const sessions = await readdir(path.join(homedir(), ".claude", "sessions")).catch(() => [])
+    return sessions.length > 0
+  } catch {
+    return false
+  }
+}
+
+function createClaudeCLIProvider() {
+  return function llm(messages) {
+    return new Promise((resolve, reject) => {
+      const system      = messages.find(m => m.role === "system")?.content ?? ""
+      const userContent = messages.filter(m => m.role !== "system").map(m => m.content).join("\n\n")
+
+      // Combine system + user into one prompt piped via stdin; --print for non-interactive output.
+      // Do NOT use --bare — that disables keychain OAuth and requires ANTHROPIC_API_KEY instead.
+      const fullPrompt = system ? `${system}\n\n${userContent}` : userContent
+      const child = spawn("claude", ["--print", "--output-format", "text"], { stdio: ["pipe", "pipe", "pipe"] })
+
+      let out = "", err = ""
+      child.stdout.on("data", d => { out += d })
+      child.stderr.on("data", d => { err += d })
+      child.on("error", reject)
+      child.on("close", code => {
+        if (code === 0) resolve(out.trim())
+        else reject(new Error(`claude CLI exited ${code}: ${err.slice(0, 200)}`))
+      })
+      child.stdin.write(fullPrompt)
+      child.stdin.end()
+    })
+  }
+}
+
+async function probeCopilotCLI() {
+  // Must be in PATH (VS Code installs a shell wrapper into PATH automatically)
+  try {
+    await execAsync("which copilot")
+  } catch {
+    return false
+  }
+
+  // Must have at least one session in ~/.copilot/session-state/ — created after first auth
+  try {
+    const { readdir } = await import("fs/promises")
+    const { homedir } = await import("os")
+    const sessions = await readdir(path.join(homedir(), ".copilot", "session-state")).catch(() => [])
+    return sessions.length > 0
+  } catch {
+    return false
+  }
+}
+
+function createCopilotCLIProvider() {
+  return function llm(messages) {
+    return new Promise((resolve, reject) => {
+      const system      = messages.find(m => m.role === "system")?.content ?? ""
+      const userContent = messages.filter(m => m.role !== "system").map(m => m.content).join("\n\n")
+      const fullPrompt  = system ? `${system}\n\n${userContent}` : userContent
+
+      // Use --output-format json so we can parse the JSONL event stream reliably
+      const child = spawn("copilot", ["-p", fullPrompt, "--output-format", "json"], {
+        stdio: ["ignore", "pipe", "pipe"],
+      })
+
+      let out = "", err = ""
+      child.stdout.on("data", d => { out += d })
+      child.stderr.on("data", d => { err += d })
+      child.on("error", reject)
+      child.on("close", code => {
+        if (code !== 0) {
+          return reject(new Error(`copilot CLI exited ${code}: ${err.slice(0, 200)}`))
+        }
+        // Parse JSONL stream — find the assistant.message event
+        const content = out.split("\n")
+          .filter(Boolean)
+          .reduce((found, line) => {
+            if (found) return found
+            try {
+              const evt = JSON.parse(line)
+              if (evt.type === "assistant.message" && evt.data?.content) return evt.data.content
+            } catch { /* skip non-JSON lines */ }
+            return null
+          }, null)
+        if (content == null) return reject(new Error("copilot CLI: no assistant.message event in output"))
+        resolve(content)
+      })
+    })
+  }
+}
+
 async function probeGeminiCLI() {
   try {
     await execAsync("which gemini")

package/bin/ui/app.html

@@ -408,18 +408,149 @@
   .hint-stalled  { color: var(--red); }
 
   /* ── Compass ── */
-  .compass-output {
+  .cp-header {
+    display: flex;
+    align-items: baseline;
+    gap: 10px;
+    margin-bottom: 14px;
+  }
+  .cp-title {
+    font-size: 15px;
+    font-weight: 700;
+    color: var(--text);
+  }
+  .cp-badge {
+    font-size: 11px;
+    padding: 2px 8px;
+    border-radius: 20px;
+    font-weight: 600;
+    letter-spacing: .03em;
+  }
+  .cp-badge--hi   { background: rgba(52,201,122,.15); color: var(--green); }
+  .cp-badge--mid  { background: rgba(224,185,82,.15);  color: var(--yellow); }
+  .cp-badge--lo   { background: rgba(224,82,82,.15);   color: var(--red); }
+  .cp-direction {
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--text);
+    line-height: 1.6;
+    margin-bottom: 20px;
+    padding: 12px 14px;
+    background: rgba(124,110,255,.08);
+    border-left: 3px solid var(--accent);
+    border-radius: 0 var(--radius) var(--radius) 0;
+  }
+  .cp-section {
+    margin-bottom: 16px;
+  }
+  .cp-section-label {
+    font-size: 11px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: .08em;
+    color: var(--muted);
+    margin-bottom: 6px;
+  }
+  .cp-list {
+    list-style: none;
+    display: flex;
+    flex-direction: column;
+    gap: 5px;
+  }
+  .cp-item {
+    display: flex;
+    gap: 8px;
+    font-size: 13px;
+    line-height: 1.5;
+  }
+  .cp-icon {
+    flex-shrink: 0;
+    width: 16px;
+    text-align: center;
+    margin-top: 1px;
+  }
+  .cp-known   .cp-icon { color: var(--green); }
+  .cp-inferred .cp-icon { color: var(--yellow); }
+  .cp-unknown  .cp-icon { color: var(--muted); }
+  .cp-next-step {
+    margin-top: 20px;
+    padding: 12px 14px;
     background: var(--surface);
     border: 1px solid var(--border);
     border-radius: var(--radius);
-    padding: 16px;
-    font-family: var(--mono);
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+  }
+  .cp-next-label {
+    font-size: 11px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: .08em;
+    color: var(--muted);
+  }
+  .cp-next-text {
+    font-size: 13px;
+    color: var(--text);
+    line-height: 1.5;
+  }
+  /* map / bets / opportunities */
+  .cp-card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 14px;
+    margin-bottom: 10px;
+  }
+  .cp-card-header {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin-bottom: 6px;
+  }
+  .cp-card-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text);
+    flex: 1;
+  }
+  .cp-card-score {
     font-size: 12px;
-    white-space: pre-wrap;
+    font-weight: 700;
+    padding: 2px 8px;
+    border-radius: 20px;
+  }
+  .cp-score-hi  { background: rgba(52,201,122,.15); color: var(--green); }
+  .cp-score-mid { background: rgba(224,185,82,.15);  color: var(--yellow); }
+  .cp-score-lo  { background: rgba(110,110,126,.15); color: var(--muted); }
+  .cp-card-body {
+    font-size: 13px;
     color: var(--muted);
-    max-height: 500px;
-    overflow-y: auto;
-    line-height: 1.6;
+    line-height: 1.5;
+  }
+  .cp-card-meta {
+    font-size: 12px;
+    color: var(--muted);
+    margin-top: 6px;
+  }
+  .cp-card-meta span { margin-right: 12px; }
+  .cp-area-tag {
+    display: inline-block;
+    font-size: 11px;
+    padding: 1px 6px;
+    border-radius: 4px;
+    background: rgba(82,168,224,.12);
+    color: var(--blue);
+    margin-right: 4px;
+  }
+  .cp-gap-item {
+    font-size: 13px;
+    color: var(--yellow);
+    padding: 8px 12px;
+    border-left: 2px solid var(--yellow);
+    margin-bottom: 6px;
+    background: rgba(224,185,82,.05);
+    border-radius: 0 var(--radius) var(--radius) 0;
   }
 
   /* ── Edit modal ── */
@@ -1072,17 +1203,117 @@ async function loadCompass() {
   }
 }
 
+function confidenceBadge(conf) {
+  const pct = Math.round((conf ?? 0) * 100)
+  const cls = pct >= 70 ? 'cp-badge--hi' : pct >= 45 ? 'cp-badge--mid' : 'cp-badge--lo'
+  return `<span class="cp-badge ${cls}">${pct}% confidence</span>`
+}
+
+function cpList(items, cssClass, icon) {
+  if (!items?.length) return ''
+  return `<ul class="cp-list">${items.map(t => `<li class="cp-item ${cssClass}"><span class="cp-icon">${icon}</span><span>${esc(t)}</span></li>`).join('')}</ul>`
+}
+
+function scoreClass(total) {
+  return total >= 75 ? 'cp-score-hi' : total >= 55 ? 'cp-score-mid' : 'cp-score-lo'
+}
+
+function renderBrief(d) {
+  let html = `<div class="cp-header"><span class="cp-title">Direction Brief</span>${confidenceBadge(d.confidence)}</div>`
+  if (d.product_direction) html += `<div class="cp-direction">${esc(d.product_direction)}</div>`
+
+  if (d.known_from_chronicle?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">From Chronicle</div>${cpList(d.known_from_chronicle, 'cp-known', '✓')}</div>`
+  }
+  if (d.known_from_behavior?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">From code / docs</div>${cpList(d.known_from_behavior, 'cp-known', '✓')}</div>`
+  }
+  if (d.inferred?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">Inferred</div>${cpList(d.inferred, 'cp-inferred', '~')}</div>`
+  }
+  if (d.unknowns?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">Unknowns</div>${cpList(d.unknowns, 'cp-unknown', '?')}</div>`
+  }
+  if (d.assumptions?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">Assumptions</div>${cpList(d.assumptions, 'cp-unknown', '·')}</div>`
+  }
+  if (d.recommended_next_step) {
+    html += `<div class="cp-next-step"><span class="cp-next-label">Next step</span><span class="cp-next-text">${esc(d.recommended_next_step)}</span></div>`
+  }
+  return html
+}
+
+function renderMap(d) {
+  let html = `<div class="cp-header"><span class="cp-title">Behaviour Map</span>${confidenceBadge(d.confidence)}</div>`
+  if (d.behaviors?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">Behaviours (${d.behaviors.length})</div>`
+    for (const b of d.behaviors.slice(0, 30)) {
+      html += `<div class="cp-card" style="padding:10px 14px">`
+      html += `<div class="cp-card-header"><span class="cp-card-title">${esc(b.name)}</span><span class="cp-area-tag">${esc(b.area)}</span></div>`
+      html += `<div class="cp-card-body">${esc(b.current_behavior)}</div></div>`
+    }
+    html += `</div>`
+  }
+  if (d.gaps?.length) {
+    html += `<div class="cp-section"><div class="cp-section-label">Gaps (${d.gaps.length})</div>`
+    for (const g of d.gaps) html += `<div class="cp-gap-item">${esc(g.gap)}</div>`
+    html += `</div>`
+  }
+  if (!d.behaviors?.length && !d.gaps?.length) html += `<div class="empty">No behaviours found in this project.</div>`
+  return html
+}
+
+function renderBets(items) {
+  if (!items?.length) return `<div class="empty">No bets generated.</div>`
+  let html = `<div class="cp-header"><span class="cp-title">Strategic Bets</span></div>`
+  for (const b of items) {
+    const total = b.scores?.total ?? 0
+    html += `<div class="cp-card">`
+    html += `<div class="cp-card-header"><span class="cp-card-title">${esc(b.title)}</span><span class="cp-card-score ${scoreClass(total)}">${total}</span></div>`
+    if (b.thesis) html += `<div class="cp-card-body">${esc(b.thesis)}</div>`
+    if (b.first_experiment) html += `<div class="cp-card-meta"><span>First test: ${esc(b.first_experiment)}</span></div>`
+    if (b.kill_criteria?.[0]) html += `<div class="cp-card-meta" style="color:var(--red)">Kill if: ${esc(b.kill_criteria[0])}</div>`
+    if (b.assumptions?.length) html += `<div class="cp-card-meta">Assumes: ${esc(b.assumptions[0])}</div>`
+    html += `</div>`
+  }
+  return html
+}
+
+function renderOpportunities(items) {
+  if (!items?.length) return `<div class="empty">No gaps or opportunities found.</div>`
+  let html = `<div class="cp-header"><span class="cp-title">Opportunities (${items.length})</span></div>`
+  for (const o of items) {
+    html += `<div class="cp-card">`
+    html += `<div class="cp-card-header"><span class="cp-card-title">${esc(o.title ?? o.gap)}</span><span class="cp-area-tag">${esc(o.area)}</span></div>`
+    if (o.why_it_matters) html += `<div class="cp-card-body">${esc(o.why_it_matters)}</div>`
+    if (o.suggested_next_step) html += `<div class="cp-card-meta">Next: ${esc(o.suggested_next_step)}</div>`
+    html += `</div>`
+  }
+  return html
+}
+
 function renderCompass(data, subcommand) {
   const el = document.getElementById("compassView")
   if (data.status === "no-llm") {
     el.innerHTML = `<div class="empty">${esc(data.message)}<small>Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY and restart quorum serve.</small></div>`
     return
   }
-  const output = data.output ?? JSON.stringify(data, null, 2)
-  el.innerHTML = `
-    <div style="font-size:12px;color:var(--muted);margin-bottom:10px">compass ${esc(subcommand)}</div>
-    <div class="compass-output">${esc(output)}</div>
-  `
+
+  const d = data.data  // structured JSON from compass --json
+  if (!d) {
+    // fallback: raw text (shouldn't happen, but safe)
+    el.innerHTML = `<pre style="font-size:12px;line-height:1.6;white-space:pre-wrap;color:var(--muted)">${esc(data.output ?? JSON.stringify(data, null, 2))}</pre>`
+    return
+  }
+
+  let inner = ''
+  if (subcommand === 'brief')         inner = renderBrief(d)
+  else if (subcommand === 'map')      inner = renderMap(d)
+  else if (subcommand === 'bets')     inner = renderBets(Array.isArray(d) ? d : d.bets ?? [d])
+  else if (subcommand === 'opportunities') inner = renderOpportunities(Array.isArray(d) ? d : [])
+  else inner = `<pre style="font-size:12px;line-height:1.6;white-space:pre-wrap;color:var(--muted)">${esc(JSON.stringify(d, null, 2))}</pre>`
+
+  el.innerHTML = `<div style="padding-bottom:16px">${inner}</div>`
 }
 </script>
 </body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@balpal4495/quorum",
-  "version": "3.5.0",
+  "version": "3.7.0",
   "description": "Git-backed memory and design review for AI coding agents",
   "type": "module",
   "license": "MIT",