@balpal4495/quorum 2.0.0 → 3.0.1

package/modules/compass/behavior.ts

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,365 @@
+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

@@ -0,0 +1,109 @@
+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

@@ -0,0 +1,7 @@
+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"