@balpal4495/quorum 3.0.4 → 3.1.1

package/modules/advisor/types.ts

@@ -1,26 +0,0 @@
-import type { OracleResult, LLMProvider } from "../shared/types"
-
-export interface AdvisorInput {
-  question: string
-  evidence: OracleResult[]
-}
-
-export interface AdvisorAnswer {
-  confidence: number
-  what_we_know: string
-  risks: string[]
-  blockers: string[]
-  recommendation: string
-  next_step: string
-}
-
-export interface AdvisorOutput extends AdvisorAnswer {
-  question: string
-  /** Number of retries taken before the answer met the satisfaction threshold. */
-  retries: number
-}
-
-export interface AdvisorDeps {
-  llm: LLMProvider
-  model?: string
-}

package/modules/compass/behavior.ts

@@ -1,161 +0,0 @@
-import { randomUUID } from "crypto"
-import type {
-  ProductBehavior, ProductBehaviorGap, ProductBehaviorContradiction, BehaviorMap,
-  BehaviorMapInput, ProductSourceFinding, CompassEvidenceRef,
-} from "./types"
-
-// ── Deterministic behaviour mapping from source findings ─────────────────────
-
-export function mapBehaviorsFromFindings(
-  findings: ProductSourceFinding[],
-  input: BehaviorMapInput = {},
-): BehaviorMap {
-  const behaviors: ProductBehavior[] = []
-  const gaps: ProductBehaviorGap[] = []
-  const contradictions: ProductBehaviorContradiction[] = []
-
-  // Group CLI commands into behaviours
-  const cliFindings = findings.filter(f => f.kind === "cli")
-  for (const f of cliFindings) {
-    behaviors.push({
-      id: `behavior-cli-${f.id}`,
-      area: inferArea(f),
-      name: f.title,
-      description: f.summary,
-      current_behavior: f.summary,
-      evidence: [findingToRef(f)],
-      basis: ["implemented"],
-      confidence: f.confidence,
-    })
-  }
-
-  // Extract documented user flows from docs findings
-  const docsFindings = findings.filter(f => f.kind === "docs" && f.tags.includes("cli"))
-  for (const f of docsFindings) {
-    // Only add if not already covered by a CLI finding
-    const alreadyPresent = behaviors.some(b =>
-      b.current_behavior.toLowerCase().includes(extractCommand(f.summary).toLowerCase()) &&
-      extractCommand(f.summary).length > 3,
-    )
-    if (!alreadyPresent && extractCommand(f.summary)) {
-      behaviors.push({
-        id: `behavior-docs-${f.id}`,
-        area: inferArea(f),
-        name: `Documented: ${f.title}`,
-        description: f.summary,
-        current_behavior: f.summary,
-        evidence: [findingToRef(f)],
-        basis: ["documented"],
-        confidence: f.confidence * 0.9,
-      })
-    }
-  }
-
-  // Cross-reference: documented claims without implementation
-  const docsHeadings = findings.filter(f => f.kind === "docs" && !f.tags.includes("cli"))
-  const implementedAreas = new Set(behaviors.map(b => b.area))
-
-  // Detect gaps: central product promises with no CLI surface
-  const EXPECTED_AREAS = ["onboarding", "chronicle", "advisor", "review"]
-  for (const expected of EXPECTED_AREAS) {
-    const hasBehavior = behaviors.some(b => b.area === expected || b.name.toLowerCase().includes(expected))
-    if (!hasBehavior) {
-      const docRef = docsHeadings.find(f => f.summary.toLowerCase().includes(expected))
-      gaps.push({
-        id: `gap-${expected}`,
-        area: expected,
-        gap: `No first-class CLI command found for '${expected}'.`,
-        why_it_matters: `'${expected}' appears in product docs but has no dedicated CLI surface.`,
-        evidence: docRef ? [findingToRef(docRef)] : [],
-        confidence: 0.7,
-      })
-    }
-  }
-
-  // Gap: no product-direction module (Compass itself)
-  const hasCompass = behaviors.some(b => b.name.toLowerCase().includes("compass"))
-  if (!hasCompass) {
-    gaps.push({
-      id: "gap-product-direction",
-      area: "product direction",
-      gap: "No product behaviour mapping or direction module currently exists.",
-      why_it_matters: "Quorum helps agents avoid repeating engineering mistakes, but has no module to help avoid repeating product-direction mistakes.",
-      evidence: [],
-      confidence: 0.93,
-    })
-  }
-
-  // Filter by area if provided
-  const filteredBehaviors = input.area
-    ? behaviors.filter(b =>
-        b.area.toLowerCase().includes(input.area!.toLowerCase()) ||
-        b.name.toLowerCase().includes(input.area!.toLowerCase()),
-      )
-    : behaviors
-
-  const overallConfidence = filteredBehaviors.length === 0
-    ? 0.5
-    : filteredBehaviors.reduce((s, b) => s + b.confidence, 0) / filteredBehaviors.length
-
-  return {
-    generated_at: new Date().toISOString(),
-    area: input.area,
-    behaviors: filteredBehaviors,
-    gaps: input.area
-      ? gaps.filter(g => g.area.toLowerCase().includes(input.area!.toLowerCase()))
-      : gaps,
-    contradictions,
-    confidence: Math.round(overallConfidence * 100) / 100,
-  }
-}
-
-// ── Extract documented behaviors for LLM context ─────────────────────────────
-
-export function summarizeBehaviorMap(map: BehaviorMap): string {
-  const lines: string[] = []
-
-  if (map.behaviors.length > 0) {
-    lines.push("## Current behaviours")
-    for (const b of map.behaviors.slice(0, 20)) {
-      lines.push(`  ✓ ${b.current_behavior.slice(0, 100)}`)
-    }
-  }
-
-  if (map.gaps.length > 0) {
-    lines.push("\n## Gaps")
-    for (const g of map.gaps) {
-      lines.push(`  ? ${g.gap}`)
-    }
-  }
-
-  return lines.join("\n")
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-function findingToRef(f: ProductSourceFinding): CompassEvidenceRef {
-  return {
-    id: f.id,
-    kind: f.kind,
-    source: f.source,
-    path: f.path,
-    summary: f.summary,
-    confidence: f.confidence,
-  }
-}
-
-function inferArea(f: ProductSourceFinding): string {
-  if (f.tags.includes("onboarding") || f.tags.includes("init")) return "onboarding"
-  if (f.tags.includes("chronicle") || f.tags.includes("commit") || f.tags.includes("proposal")) return "chronicle review"
-  if (f.tags.includes("advisor")) return "memory retrieval"
-  if (f.tags.includes("sentinel")) return "coverage"
-  if (f.tags.includes("compass")) return "product direction"
-  if (f.tags.includes("auth")) return "auth"
-  if (f.tags.includes("cli")) return "cli"
-  return "general"
-}
-
-function extractCommand(text: string): string {
-  const match = text.match(/`(quorum [^`]+)`/)
-  return match?.[1] ?? ""
-}

package/modules/compass/create.ts

@@ -1,365 +0,0 @@
-import { randomUUID } from "crypto"
-import type { LLMProvider } from "../shared/types"
-import type {
-  Compass, CreateCompassOptions,
-  CompassBrief, CompassBriefInput,
-  BehaviorMap, BehaviorMapInput,
-  BehaviorAnswer, BehaviorQuestionInput,
-  ProductOpportunity, OpportunitiesInput,
-  ProductPathway, PathwaysInput,
-  ProductBet, BigBetsInput,
-  ProductIdeaScore, ScoreIdeaInput,
-  ProductBrief, ProductBriefInput,
-  CompassProposalInput, CompassProposalResult,
-  CompassOutcomeInput, CompassOutcomeResultPayload,
-} from "./types"
-import { defaultSources } from "./sources/index"
-import { collectBearings, collectTerrain, formatBearingsForPrompt, formatTerrainForPrompt } from "./evidence/collect"
-import { mapBehaviorsFromFindings, summarizeBehaviorMap } from "./behavior"
-import { computeScore, scoreToRecommendation, explainScore } from "./score"
-import { stageProposal, stageOutcome } from "./propose"
-import { COMPASS_SYSTEM_PROMPT } from "./prompts/system"
-import {
-  buildBriefPrompt, buildPathwaysPrompt,
-  buildBetsPrompt, buildScorePrompt,
-} from "./prompts/index"
-import {
-  CompassBriefLLMSchema, PathwaysLLMSchema,
-  BetsLLMSchema, ProductIdeaScoreSchema,
-} from "./schemas"
-
-function parseLLMJson(raw: string): unknown {
-  const cleaned = raw.replace(/^```(?:json)?\s*/m, "").replace(/\s*```$/m, "").trim()
-  return JSON.parse(cleaned)
-}
-
-async function callLLM(
-  llm: LLMProvider | undefined,
-  userPrompt: string,
-  model?: string,
-): Promise<string> {
-  if (!llm) throw new Error("Compass: LLM provider is required for this command. Set ANTHROPIC_API_KEY, OPENAI_API_KEY, or pass llm to setup().")
-  return llm(
-    [
-      { role: "system" as const, content: COMPASS_SYSTEM_PROMPT },
-      { role: "user" as const, content: userPrompt },
-    ],
-    model,
-  )
-}
-
-export function createCompass(options: CreateCompassOptions): Compass {
-  const {
-    oracle,
-    llm,
-    rootDir = process.cwd(),
-    chronicleDir = ".chronicle",
-    sources = defaultSources(),
-    models = {},
-    minimumEvidence = "balanced",
-  } = options
-
-  // ── Shared context helpers ─────────────────────────────────────────────────
-
-  async function getContext(area?: string) {
-    const [bearings, terrain] = await Promise.all([
-      collectBearings(oracle, area),
-      collectTerrain(sources, rootDir, area),
-    ])
-    const chronicleContext = formatBearingsForPrompt(bearings)
-    const behaviorContext = formatTerrainForPrompt(terrain.findings)
-    const behaviorMap = mapBehaviorsFromFindings(terrain.findings, { area })
-    return { bearings, terrain, chronicleContext, behaviorContext, behaviorMap }
-  }
-
-  // ── brief ──────────────────────────────────────────────────────────────────
-
-  async function brief(input?: CompassBriefInput): Promise<CompassBrief> {
-    const { chronicleContext, behaviorContext, terrain, behaviorMap } = await getContext(input?.area)
-
-    if (!llm) {
-      // Deterministic fallback
-      return {
-        generated_at: new Date().toISOString(),
-        area: input?.area,
-        product_direction: "Unable to synthesize direction — no LLM configured. See Chronicle and behaviour map for raw evidence.",
-        known_from_chronicle: [],
-        known_from_behavior: behaviorMap.behaviors.slice(0, 5).map(b => b.current_behavior),
-        inferred: [],
-        assumptions: [],
-        unknowns: ["LLM not configured — full synthesis unavailable."],
-        opportunities: [],
-        missing_evidence: ["LLM provider required for synthesis"],
-        recommended_next_step: "Run: quorum advisor brief",
-        confidence: 0.4,
-      }
-    }
-
-    const raw = await callLLM(llm, buildBriefPrompt({ chronicleContext, behaviorContext, area: input?.area }), models.brief)
-    let parsed: unknown
-    try { parsed = parseLLMJson(raw) } catch {
-      throw new Error(`Compass brief: LLM returned non-JSON. Raw (first 300): ${raw.slice(0, 300)}`)
-    }
-
-    const result = CompassBriefLLMSchema.safeParse(parsed)
-    if (!result.success) throw new Error(`Compass brief: LLM output failed validation: ${JSON.stringify(result.error.issues)}`)
-
-    const d = result.data
-    // Build opportunity items from behavior map gaps
-    const opportunities: ProductOpportunity[] = behaviorMap.gaps.slice(0, 3).map((g, i) => ({
-      id: `opp-gap-${i}`,
-      title: g.gap,
-      area: g.area,
-      why_it_matters: g.why_it_matters,
-      evidence_strength: "inferred" as const,
-      suggested_next_step: "Run: quorum compass map",
-      evidence: g.evidence,
-      confidence: g.confidence,
-    }))
-
-    return {
-      generated_at: new Date().toISOString(),
-      area: input?.area,
-      ...d,
-      opportunities,
-    }
-  }
-
-  // ── mapBehaviors ────────────────────────────────────────────────────────────
-
-  async function mapBehaviors(input?: BehaviorMapInput): Promise<BehaviorMap> {
-    const terrain = await collectTerrain(sources, rootDir, input?.area)
-    return mapBehaviorsFromFindings(terrain.findings, input)
-  }
-
-  // ── behavior (single question) ──────────────────────────────────────────────
-
-  async function behavior(input: BehaviorQuestionInput): Promise<BehaviorAnswer> {
-    const terrain = await collectTerrain(sources, rootDir, input.area)
-    const map = mapBehaviorsFromFindings(terrain.findings, { area: input.area })
-
-    const relevant = terrain.findings.filter(f =>
-      f.summary.toLowerCase().includes(input.question.toLowerCase().split(" ").slice(0, 3).join(" ")) ||
-      f.tags.some(t => input.question.toLowerCase().includes(t)),
-    ).slice(0, 10)
-
-    if (!llm || input.deterministic) {
-      // Deterministic answer from behaviour map
-      const what_exists = map.behaviors.slice(0, 6).map(b => b.current_behavior)
-      const what_missing = map.gaps.slice(0, 4).map(g => g.gap)
-      return {
-        question: input.question,
-        what_exists,
-        what_appears_missing: what_missing,
-        product_implication: map.gaps.length > 0
-          ? `The area has ${map.behaviors.length} documented behaviours but ${map.gaps.length} notable gaps.`
-          : `The area appears well-covered with ${map.behaviors.length} documented behaviours.`,
-        evidence: relevant.map(f => ({ id: f.id, kind: f.kind, source: f.source, path: f.path, summary: f.summary, confidence: f.confidence })),
-        confidence: map.confidence,
-      }
-    }
-
-    // LLM-backed synthesis
-    const contextLines = [
-      "## Behaviours found",
-      ...map.behaviors.slice(0, 10).map(b => `  ✓ ${b.current_behavior}`),
-      "## Gaps found",
-      ...map.gaps.slice(0, 5).map(g => `  ? ${g.gap}`),
-    ].join("\n")
-
-    const prompt = `Answer this product-behaviour question by combining repo evidence with known behaviours.
-
-Question: ${input.question}
-
-${contextLines}
-
-Return JSON:
-{
-  "question": "${input.question}",
-  "what_exists": ["<existing behaviour>"],
-  "what_appears_missing": ["<missing capability>"],
-  "product_implication": "<one sentence product implication>",
-  "evidence": [{ "id": "<id>", "kind": "<kind>", "source": "<source>", "summary": "<summary>", "confidence": <0–1> }],
-  "confidence": <0–1>
-}`
-
-    const raw = await callLLM(llm, prompt, models.brief)
-    try {
-      const parsed = parseLLMJson(raw) as BehaviorAnswer
-      return { ...parsed, question: input.question }
-    } catch {
-      // Fall back to deterministic
-      return behavior({ ...input, deterministic: true })
-    }
-  }
-
-  // ── opportunities ───────────────────────────────────────────────────────────
-
-  async function opportunities(input?: OpportunitiesInput): Promise<ProductOpportunity[]> {
-    const terrain = await collectTerrain(sources, rootDir, input?.area)
-    const map = mapBehaviorsFromFindings(terrain.findings, { area: input?.area })
-
-    const opps: ProductOpportunity[] = map.gaps.map((g, i) => ({
-      id: `opp-${i}`,
-      title: g.gap,
-      area: g.area,
-      why_it_matters: g.why_it_matters,
-      evidence_strength: g.confidence >= 0.7 ? "strong" as const
-        : g.confidence >= 0.5 ? "medium" as const
-        : "inferred" as const,
-      suggested_next_step: `quorum compass pathways --goal "${g.gap.slice(0, 50)}"`,
-      evidence: g.evidence,
-      confidence: g.confidence,
-    }))
-
-    const limited = input?.limit ? opps.slice(0, input.limit) : opps
-    return input?.goal
-      ? limited.filter(o => o.title.toLowerCase().includes(input.goal!.toLowerCase()) || o.area.toLowerCase().includes(input.goal!.toLowerCase()))
-      : limited
-  }
-
-  // ── pathways ────────────────────────────────────────────────────────────────
-
-  async function pathways(input: PathwaysInput): Promise<ProductPathway[]> {
-    const { chronicleContext, behaviorContext } = await getContext(input.area)
-    const raw = await callLLM(
-      llm,
-      buildPathwaysPrompt({ ...input, chronicleContext, behaviorContext, limit: input.limit ?? 5 }),
-      models.pathways,
-    )
-
-    let parsed: unknown
-    try { parsed = parseLLMJson(raw) } catch {
-      throw new Error(`Compass pathways: LLM returned non-JSON. Raw (first 300): ${raw.slice(0, 300)}`)
-    }
-    const result = PathwaysLLMSchema.safeParse(parsed)
-    if (!result.success) throw new Error(`Compass pathways: LLM output failed validation: ${JSON.stringify(result.error.issues)}`)
-
-    // Recompute scores deterministically
-    return result.data.pathways.map(p => ({
-      ...p,
-      scores: computeScore(p.scores),
-    }))
-  }
-
-  // ── bigBets ─────────────────────────────────────────────────────────────────
-
-  async function bigBets(input: BigBetsInput): Promise<ProductBet[]> {
-    const { chronicleContext, behaviorContext } = await getContext()
-    const raw = await callLLM(
-      llm,
-      buildBetsPrompt({ ...input, chronicleContext, behaviorContext }),
-      models.bets,
-    )
-
-    let parsed: unknown
-    try { parsed = parseLLMJson(raw) } catch {
-      throw new Error(`Compass bets: LLM returned non-JSON. Raw (first 300): ${raw.slice(0, 300)}`)
-    }
-    const result = BetsLLMSchema.safeParse(parsed)
-    if (!result.success) throw new Error(`Compass bets: LLM output failed validation: ${JSON.stringify(result.error.issues)}`)
-
-    return result.data.bets.map(b => ({
-      ...b,
-      scores: computeScore(b.scores),
-    }))
-  }
-
-  // ── scoreIdea ───────────────────────────────────────────────────────────────
-
-  async function scoreIdea(input: ScoreIdeaInput): Promise<ProductIdeaScore> {
-    const { chronicleContext, behaviorContext } = await getContext()
-    const raw = await callLLM(
-      llm,
-      buildScorePrompt({ ...input, chronicleContext, behaviorContext }),
-      models.score,
-    )
-
-    let parsed: unknown
-    try { parsed = parseLLMJson(raw) } catch {
-      throw new Error(`Compass score: LLM returned non-JSON. Raw (first 300): ${raw.slice(0, 300)}`)
-    }
-    const result = ProductIdeaScoreSchema.safeParse(parsed)
-    if (!result.success) throw new Error(`Compass score: LLM output failed validation: ${JSON.stringify(result.error.issues)}`)
-
-    const d = result.data
-    return {
-      ...d,
-      scores: computeScore(d.scores),
-      recommendation: scoreToRecommendation(d.scores.total),
-    }
-  }
-
-  // ── productBrief ─────────────────────────────────────────────────────────────
-
-  async function productBrief(input: ProductBriefInput): Promise<ProductBrief> {
-    const { chronicleContext, behaviorContext, terrain } = await getContext()
-
-    const prompt = `Generate a product brief for implementation planning.
-
-Title: ${input.title}
-${input.idea ? `Idea: ${input.idea}` : ""}
-${input.context ? `Context: ${input.context}` : ""}
-
-## Chronicle evidence
-${chronicleContext}
-
-## Current behaviour
-${behaviorContext}
-
-Return JSON:
-{
-  "title": "${input.title}",
-  "problem": "<problem being solved>",
-  "target_user": "<who>",
-  "current_behavior": ["<relevant current behaviour>"],
-  "product_opportunity": "<gap or need>",
-  "recommended_solution": "<recommended approach>",
-  "smallest_useful_version": "<minimum useful version>",
-  "non_goals": ["<explicit non-goal>"],
-  "user_flow": ["<step in user flow>"],
-  "implementation_notes": ["<implementation note>"],
-  "dependencies": ["<dependency>"],
-  "risks": ["<risk>"],
-  "open_questions": ["<open question>"],
-  "assumptions": ["<assumption>"],
-  "validation_signals": ["<signal>"],
-  "invalidation_signals": ["<signal>"],
-  "evidence": [{ "id": "<id>", "kind": "<kind>", "source": "<source>", "summary": "<summary>", "confidence": <0–1> }],
-  "suggested_quorum_checks": ["<quorum check command>"]
-}`
-
-    const raw = await callLLM(llm, prompt, models.brief)
-    try {
-      const parsed = parseLLMJson(raw) as ProductBrief
-      return parsed
-    } catch {
-      throw new Error(`Compass productBrief: LLM returned non-JSON. Raw (first 300): ${raw.slice(0, 300)}`)
-    }
-  }
-
-  // ── propose ──────────────────────────────────────────────────────────────────
-
-  async function propose(input: CompassProposalInput): Promise<CompassProposalResult> {
-    return stageProposal(input, oracle)
-  }
-
-  // ── outcome ──────────────────────────────────────────────────────────────────
-
-  async function outcome(input: CompassOutcomeInput): Promise<CompassOutcomeResultPayload> {
-    return stageOutcome(input, oracle)
-  }
-
-  return {
-    brief,
-    mapBehaviors,
-    behavior,
-    opportunities,
-    pathways,
-    bigBets,
-    scoreIdea,
-    productBrief,
-    propose,
-    outcome,
-  }
-}

package/modules/compass/evidence/collect.ts

@@ -1,109 +0,0 @@
-import type { OracleClient, OracleResult } from "../../shared/types"
-import type { CompassEvidenceRef, ProductBearing, ProductSource, ProductSourceFinding } from "../types"
-import { randomUUID } from "crypto"
-
-// ── Bearings from Chronicle ───────────────────────────────────────────────────
-
-export async function collectBearings(
-  oracle: OracleClient,
-  area?: string,
-): Promise<ProductBearing[]> {
-  const queries = [
-    area ?? "product direction goals decisions",
-    "rejected approaches refuted alternatives",
-    "constraints scope out-of-scope",
-  ]
-
-  const seen = new Set<string>()
-  const bearings: ProductBearing[] = []
-
-  for (const q of queries) {
-    let results: OracleResult[]
-    try { results = await oracle.query(q, { limit: 8 }) } catch { continue }
-
-    for (const entry of results) {
-      if (seen.has(entry.id)) continue
-      seen.add(entry.id)
-
-      const text = entry.decision ?? entry.key_insight
-      bearings.push({
-        id: `bearing-${entry.id.slice(0, 8)}`,
-        title: entry.topic ?? text.slice(0, 60),
-        summary: text,
-        area: entry.scope?.[0],
-        evidence: [
-          {
-            id: randomUUID().slice(0, 8),
-            kind: "chronicle",
-            source: ".chronicle/committed",
-            entry_id: entry.id,
-            summary: text,
-            confidence: entry.confidence,
-          },
-        ],
-        confidence: entry.confidence,
-      })
-    }
-  }
-
-  return bearings
-}
-
-// ── Terrain from source scanners ──────────────────────────────────────────────
-
-export interface TerrainResult {
-  findings: ProductSourceFinding[]
-  evidenceRefs: CompassEvidenceRef[]
-}
-
-export async function collectTerrain(
-  sources: ProductSource[],
-  rootDir: string,
-  area?: string,
-): Promise<TerrainResult> {
-  const allFindings: ProductSourceFinding[] = []
-
-  for (const source of sources) {
-    const found = await source.scan({ rootDir, area })
-    allFindings.push(...found)
-  }
-
-  const evidenceRefs: CompassEvidenceRef[] = allFindings.map(f => ({
-    id: f.id,
-    kind: f.kind,
-    source: f.source,
-    path: f.path,
-    line: f.line,
-    summary: f.summary,
-    confidence: f.confidence,
-  }))
-
-  return { findings: allFindings, evidenceRefs }
-}
-
-// ── Format helpers for LLM prompts ───────────────────────────────────────────
-
-export function formatBearingsForPrompt(bearings: ProductBearing[]): string {
-  if (bearings.length === 0) return "No Chronicle entries found."
-  return bearings
-    .map(b => `[${b.id}] (confidence: ${b.confidence.toFixed(2)}) ${b.summary}`)
-    .join("\n")
-}
-
-export function formatTerrainForPrompt(findings: ProductSourceFinding[], limit = 40): string {
-  if (findings.length === 0) return "No product behaviour found in sources."
-
-  // Group by kind
-  const groups: Record<string, ProductSourceFinding[]> = {}
-  for (const f of findings.slice(0, limit)) {
-    groups[f.kind] = groups[f.kind] ?? []
-    groups[f.kind].push(f)
-  }
-
-  return Object.entries(groups)
-    .map(([kind, items]) => {
-      const lines = items.slice(0, 10).map(i => `  - ${i.title}: ${i.summary.slice(0, 100)}`)
-      return `${kind.toUpperCase()}:\n${lines.join("\n")}`
-    })
-    .join("\n\n")
-}

package/modules/compass/index.ts

@@ -1,7 +0,0 @@
-export { createCompass } from "./create"
-export { defaultSources, docsSource, packageSource, cliSource, repoSource, testsSource, configSource } from "./sources/index"
-export { mapBehaviorsFromFindings, summarizeBehaviorMap } from "./behavior"
-export { computeScore, scoreToRecommendation, scoreToLabel, explainScore } from "./score"
-export { collectBearings, collectTerrain, formatBearingsForPrompt, formatTerrainForPrompt } from "./evidence/collect"
-export { stageProposal, stageOutcome } from "./propose"
-export * from "./types"