avorelo 0.1.0 → 0.2.0

package/scripts/lib/learning-memory.js

@@ -1,686 +0,0 @@
-"use strict";
-
-// Evidence-Backed Learning Memory v1
-// Local-first, deterministic, evidence-backed learning layer.
-// No cloud calls, no LLM, no daemon. Generates learning candidates
-// from existing Avorelo artifacts only.
-//
-// Artifacts:
-//   .claude/cco/brain/project-brain.json        — avorelo.projectBrain.v1
-//   .claude/cco/learning/decision-register.jsonl — avorelo.decisionRegister.v1
-//   .claude/cco/learning/risk-register.json      — avorelo.riskRegister.v1
-//   .claude/cco/learning/capability-map.json     — avorelo.capabilityMap.v1
-//   .claude/cco/state/learning-summary.json      — avorelo.learningSummary.v1
-//
-// Source-of-truth order (highest to lowest trust):
-//   1. explicit current user instruction
-//   2. canonical product contracts/docs
-//   3. proof/receipts
-//   4. merged PR/commit evidence
-//   5. audit events
-//   6. readiness/support bundle evidence
-//   7. run-improvement signals
-//   8. low-confidence inferred signals
-//
-// LLM output alone is never source of truth.
-// Test fixtures cannot become real learning unless marked test_fixture.
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-const BRAIN_REL = ".claude/cco/brain/project-brain.json";
-const DECISION_REGISTER_REL = ".claude/cco/learning/decision-register.jsonl";
-const RISK_REGISTER_REL = ".claude/cco/learning/risk-register.json";
-const CAPABILITY_MAP_REL = ".claude/cco/learning/capability-map.json";
-const LEARNING_SUMMARY_REL = ".claude/cco/state/learning-summary.json";
-
-const BRAIN_SCHEMA = "avorelo.projectBrain.v1";
-const DECISION_SCHEMA = "avorelo.decisionRegister.v1";
-const RISK_SCHEMA = "avorelo.riskRegister.v1";
-const CAPABILITY_SCHEMA = "avorelo.capabilityMap.v1";
-const SUMMARY_SCHEMA = "avorelo.learningSummary.v1";
-
-const SOURCE_ORDER = [
-  "user_instruction",
-  "canonical_contract",
-  "proof_receipt",
-  "merged_pr_evidence",
-  "audit_event",
-  "readiness_evidence",
-  "run_improvement_signal",
-  "inferred",
-];
-
-const DECISION_STATUSES = ["active", "superseded", "stale", "uncertain", "expired", "test_fixture"];
-
-function nowIso() {
-  return new Date().toISOString();
-}
-
-function buildFingerprint(data) {
-  return crypto
-    .createHash("sha256")
-    .update(JSON.stringify(data))
-    .digest("hex")
-    .slice(0, 16);
-}
-
-// ── Evidence collection ───────────────────────────────────────────────────────
-
-function collectLearningEvidence(cwd) {
-  const evidence = {
-    runImprovements: null,
-    lifecycleReceipt: null,
-    adapterReadiness: null,
-    contextBudget: null,
-    reentryState: null,
-    carryForward: null,
-    outcomeEvents: null,
-  };
-
-  try {
-    const { loadRunImprovements } = require("./run-improvements");
-    evidence.runImprovements = loadRunImprovements(cwd);
-  } catch {}
-
-  try {
-    const { loadLifecycleReceipt } = require("./run-improvements-lifecycle");
-    evidence.lifecycleReceipt = loadLifecycleReceipt(cwd);
-  } catch {}
-
-  try {
-    const { buildAdapterReadinessSurface } = require("./adapter-readiness");
-    evidence.adapterReadiness = buildAdapterReadinessSurface(cwd);
-  } catch {}
-
-  try {
-    const { loadBudgetState } = require("./context-budget-guard");
-    evidence.contextBudget = loadBudgetState(cwd);
-  } catch {}
-
-  try {
-    const { loadReentryState } = require("./reentry-state");
-    evidence.reentryState = loadReentryState(cwd);
-  } catch {}
-
-  try {
-    const { loadCarryForward } = require("./carry-forward-surfacing");
-    evidence.carryForward = loadCarryForward(cwd);
-  } catch {}
-
-  try {
-    const { readOutcomeEvents, aggregateOutcomeEvents } = require("./unified-events");
-    const raw = readOutcomeEvents(cwd);
-    const events = raw.filter((e) => e.category !== "run_improvements");
-    if (events.length > 0) {
-      evidence.outcomeEvents = aggregateOutcomeEvents(events, { days: 7 });
-    }
-  } catch {}
-
-  return evidence;
-}
-
-// ── Decision candidates ───────────────────────────────────────────────────────
-
-function generateDecisionCandidates(evidence) {
-  const now = nowIso();
-  const candidates = [];
-
-  // Applied honesty: do not claim applied without lifecycle receipt
-  const hasReceipt = evidence.lifecycleReceipt !== null;
-  candidates.push({
-    id: "dec_applied_requires_receipt",
-    decision: "Do not claim 'applied' or 'improved' unless a lifecycle receipt exists confirming it.",
-    rationale: hasReceipt
-      ? "Lifecycle receipt present — applied claim is honest."
-      : "No lifecycle receipt — applied must not be claimed.",
-    status: "active",
-    createdAt: now,
-    updatedAt: now,
-    supersededBy: null,
-    evidenceRefs: ["run_improvements_artifact", "lifecycle_receipt"],
-    source: hasReceipt ? "proof_receipt" : "audit_event",
-    confidence: 0.95,
-    reasonCodes: ["LIFECYCLE_HONEST_CLAIM"],
-    affectedSurfaces: ["run-improvements", "status", "dashboard"],
-  });
-
-  // Prepared is honest and useful even without applied
-  if (evidence.runImprovements) {
-    const ri = evidence.runImprovements;
-    if (ri.status === "prepared" || ri.status === "applied") {
-      candidates.push({
-        id: "dec_prepared_is_honest",
-        decision: "Use 'prepared' status when improvements are ready but not yet applied — this is honest and useful.",
-        rationale: `Current artifact status is '${ri.status}'. Prepared communicates readiness without overclaiming.`,
-        status: "active",
-        createdAt: now,
-        updatedAt: now,
-        supersededBy: null,
-        evidenceRefs: ["run_improvements_artifact"],
-        source: "run_improvement_signal",
-        confidence: 0.90,
-        reasonCodes: ["STATUS_HONEST_PREPARED"],
-        affectedSurfaces: ["run-improvements"],
-      });
-    }
-  }
-
-  // Host support: always host-specific, never universal
-  if (evidence.adapterReadiness) {
-    candidates.push({
-      id: "dec_host_support_is_host_specific",
-      decision: "Host support claims must be host-specific. Do not claim universal support across all AI coding hosts.",
-      rationale: "Adapter readiness uses host-specific detection — universal claims would be false.",
-      status: "active",
-      createdAt: now,
-      updatedAt: now,
-      supersededBy: null,
-      evidenceRefs: ["adapter_readiness"],
-      source: "readiness_evidence",
-      confidence: 0.92,
-      reasonCodes: ["HOST_SUPPORT_HOST_SPECIFIC"],
-      affectedSurfaces: ["adapter-readiness", "status"],
-    });
-  }
-
-  // Browser proof: preflight only, not automation
-  candidates.push({
-    id: "dec_browser_proof_is_preflight_only",
-    decision: "Browser proof is a preflight/readiness check only — it does not perform browser automation.",
-    rationale: "Browser capability check boundary from canonical product contract.",
-    status: "active",
-    createdAt: now,
-    updatedAt: now,
-    supersededBy: null,
-    evidenceRefs: ["canonical_contract"],
-    source: "canonical_contract",
-    confidence: 0.95,
-    reasonCodes: ["BROWSER_PREFLIGHT_ONLY"],
-    affectedSurfaces: ["browser-proof", "adapter-readiness"],
-  });
-
-  // Context pressure: prefer carry-forward
-  if (
-    evidence.contextBudget &&
-    (evidence.contextBudget.status === "critical" || evidence.contextBudget.status === "warn")
-  ) {
-    candidates.push({
-      id: "dec_context_pressure_use_carryforward",
-      decision: "Under context pressure, prefer carry-forward summary over full stale context.",
-      rationale: `Context budget at ${evidence.contextBudget.status} — full context risks noise and token waste.`,
-      status: "active",
-      createdAt: now,
-      updatedAt: now,
-      supersededBy: null,
-      evidenceRefs: ["context_budget"],
-      source: "run_improvement_signal",
-      confidence: evidence.contextBudget.status === "critical" ? 0.92 : 0.75,
-      reasonCodes: [`CTX_PRESSURE_${evidence.contextBudget.status.toUpperCase()}`],
-      affectedSurfaces: ["run-improvements", "reentry"],
-    });
-  }
-
-  return candidates;
-}
-
-// ── Risk candidates ───────────────────────────────────────────────────────────
-
-function generateRiskCandidates(evidence) {
-  const now = nowIso();
-  const candidates = [];
-
-  candidates.push({
-    id: "risk_stale_artifacts",
-    category: "artifact_integrity",
-    title: "Stale artifacts can produce false readiness state",
-    severity: "medium",
-    status: "active",
-    firstSeen: now,
-    lastSeen: now,
-    evidenceRefs: ["run_improvements_artifact", "lifecycle_receipt"],
-    mitigation: "Check artifact TTL and source fingerprint before trusting state claims.",
-    ownerSurface: "run-improvements",
-    reasonCodes: ["STALE_ARTIFACT_RISK"],
-  });
-
-  candidates.push({
-    id: "risk_fake_applied_claims",
-    category: "honesty",
-    title: "Claiming 'applied' without lifecycle evidence reduces trust",
-    severity: "high",
-    status: "active",
-    firstSeen: now,
-    lastSeen: now,
-    evidenceRefs: ["lifecycle_receipt"],
-    mitigation: "Only set applied=true when lifecycle receipt confirms it via a supported surface.",
-    ownerSurface: "run-improvements",
-    reasonCodes: ["LIFECYCLE_HONEST_CLAIM"],
-  });
-
-  if (evidence.reentryState && evidence.reentryState.unresolvedRisk) {
-    candidates.push({
-      id: "risk_unresolved_reentry",
-      category: "run_safety",
-      title: "Unresolved risk from previous run increases error probability",
-      severity: "high",
-      status: "active",
-      firstSeen: now,
-      lastSeen: now,
-      evidenceRefs: ["reentry_state"],
-      mitigation: "Resolve unresolved risk before continuing. Ask for confirmation before risky actions.",
-      ownerSurface: "reentry",
-      reasonCodes: ["UNRESOLVED_RISK"],
-    });
-  }
-
-  return candidates;
-}
-
-// ── Capability candidates ─────────────────────────────────────────────────────
-
-function generateCapabilityCandidates(evidence) {
-  const now = nowIso();
-  return [
-    {
-      id: "cap_adapter_readiness",
-      capabilityFamily: "adapter_readiness",
-      taskTypes: ["host_support_check", "adapter_detection"],
-      riskTier: "low",
-      supportedInputs: ["project_cwd"],
-      outputs: ["adapter_status", "host_detection_result"],
-      whenToUse: "When checking which AI coding hosts are available and what capabilities they support.",
-      whenNotToUse: "Do not use to claim universal host support across all hosts — results are host-specific.",
-      evidenceRefs: evidence.adapterReadiness ? ["adapter_readiness"] : [],
-      lastValidated: now,
-      status: "active",
-    },
-    {
-      id: "cap_run_improvements",
-      capabilityFamily: "run_improvements",
-      taskTypes: ["next_run_preparation", "evidence_collection"],
-      riskTier: "low",
-      supportedInputs: ["project_cwd", "mode"],
-      outputs: ["run_improvements_artifact", "next_run_defaults"],
-      whenToUse: "When preparing improvements for the next AI coding run based on evidence from the last.",
-      whenNotToUse: "Do not claim 'improved' without a lifecycle receipt. Do not generate without evidence.",
-      evidenceRefs: evidence.runImprovements ? ["run_improvements_artifact"] : [],
-      lastValidated: now,
-      status: "active",
-    },
-    {
-      id: "cap_proof_receipts",
-      capabilityFamily: "proof_receipts",
-      taskTypes: ["validation_claims", "completion_verification"],
-      riskTier: "low",
-      supportedInputs: ["project_cwd"],
-      outputs: ["proof_receipt", "completion_status"],
-      whenToUse: "When making validation claims or verifying task completion.",
-      whenNotToUse: "Do not claim 'done' without a proof receipt. Proof does not guarantee universal correctness.",
-      evidenceRefs: ["canonical_contract"],
-      lastValidated: now,
-      status: "active",
-    },
-    {
-      id: "cap_browser_proof_preflight",
-      capabilityFamily: "browser_proof_preflight",
-      taskTypes: ["browser_readiness_check"],
-      riskTier: "low",
-      supportedInputs: ["project_cwd"],
-      outputs: ["preflight_result"],
-      whenToUse: "PREFLIGHT ONLY — check browser capability readiness before any browser-dependent task.",
-      whenNotToUse: "Do not use for browser automation. This is a preflight check, not a browser controller.",
-      evidenceRefs: ["canonical_contract"],
-      lastValidated: now,
-      status: "active",
-    },
-  ];
-}
-
-// ── Artifact builders ─────────────────────────────────────────────────────────
-
-function buildProjectBrain(cwd, evidence) {
-  const now = nowIso();
-  const evidenceKeys = Object.keys(evidence).filter((k) => evidence[k] !== null);
-  const fp = buildFingerprint({ evidenceKeys });
-
-  return {
-    schemaVersion: BRAIN_SCHEMA,
-    generatedAt: now,
-    updatedAt: now,
-    projectSummary: "Avorelo local-first AI coding optimization runtime.",
-    activeConstraints: [
-      "No cloud sync",
-      "No daemon or background service",
-      "No LLM as source of truth",
-      "No applied claim without lifecycle receipt",
-      "No universal host support claims",
-      "No raw transcripts or secrets in artifacts",
-    ],
-    canonicalAssumptions: [
-      "Evidence comes from existing local artifacts only.",
-      "Deterministic: same signals produce same results.",
-      "Fail-open: missing evidence returns null, not error.",
-    ],
-    protectedBoundaries: [
-      "Do not touch public website, pricing, or launch copy.",
-      "Do not build Teams, billing, GrowthBook, or marketplace.",
-      "Do not add cloud sync or daemon.",
-      "Do not use LLM output as source of truth.",
-    ],
-    evidenceRefs: evidenceKeys,
-    confidence: evidenceKeys.length > 0 ? 0.85 : 0.50,
-    limitations: [
-      "Project brain is generated from local artifacts at a point in time.",
-      "Constraints and boundaries may evolve — always check canonical docs first.",
-    ],
-    sourceFingerprint: fp,
-  };
-}
-
-function loadDecisionRegister(cwd) {
-  try {
-    const absPath = path.join(cwd, DECISION_REGISTER_REL);
-    if (!fs.existsSync(absPath)) return [];
-    return fs
-      .readFileSync(absPath, "utf8")
-      .split("\n")
-      .filter(Boolean)
-      .map((ln) => {
-        try {
-          return JSON.parse(ln);
-        } catch {
-          return null;
-        }
-      })
-      .filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-function writeDecisionRegister(cwd, decisions) {
-  const absPath = path.join(cwd, DECISION_REGISTER_REL);
-  fs.mkdirSync(path.dirname(absPath), { recursive: true });
-  const lines = decisions.map((d) => JSON.stringify(d)).join("\n");
-  fs.writeFileSync(absPath, lines ? lines + "\n" : "", "utf8");
-}
-
-// Merge new candidates into the existing register.
-// Rules: update if status or decision text changed; append if new id.
-// Stale/superseded decisions are preserved but excluded from next-run influence.
-// Conflicting decisions are not silently overwritten — id collision is an update.
-function mergeDecisions(existing, candidates) {
-  const byId = new Map(existing.map((d) => [d.id, d]));
-  for (const candidate of candidates) {
-    if (byId.has(candidate.id)) {
-      const prev = byId.get(candidate.id);
-      if (prev.status !== candidate.status || prev.decision !== candidate.decision) {
-        byId.set(candidate.id, { ...candidate, updatedAt: candidate.updatedAt });
-      }
-      // If identical, keep existing (preserve history)
-    } else {
-      byId.set(candidate.id, candidate);
-    }
-  }
-  return [...byId.values()];
-}
-
-function loadRiskRegister(cwd) {
-  try {
-    const absPath = path.join(cwd, RISK_REGISTER_REL);
-    const raw = JSON.parse(fs.readFileSync(absPath, "utf8"));
-    if (raw.schemaVersion !== RISK_SCHEMA) return { risks: [] };
-    return raw;
-  } catch {
-    return { risks: [] };
-  }
-}
-
-function buildRiskRegister(cwd, riskCandidates) {
-  const now = nowIso();
-  const existing = loadRiskRegister(cwd);
-  const byId = new Map((existing.risks || []).map((r) => [r.id, r]));
-  for (const candidate of riskCandidates) {
-    if (byId.has(candidate.id)) {
-      byId.set(candidate.id, { ...byId.get(candidate.id), lastSeen: now });
-    } else {
-      byId.set(candidate.id, candidate);
-    }
-  }
-  return {
-    schemaVersion: RISK_SCHEMA,
-    generatedAt: now,
-    updatedAt: now,
-    risks: [...byId.values()],
-  };
-}
-
-function loadCapabilityMap(cwd) {
-  try {
-    const absPath = path.join(cwd, CAPABILITY_MAP_REL);
-    const raw = JSON.parse(fs.readFileSync(absPath, "utf8"));
-    if (raw.schemaVersion !== CAPABILITY_SCHEMA) return { capabilities: [] };
-    return raw;
-  } catch {
-    return { capabilities: [] };
-  }
-}
-
-function buildCapabilityMap(cwd, capabilityCandidates) {
-  const now = nowIso();
-  return {
-    schemaVersion: CAPABILITY_SCHEMA,
-    generatedAt: now,
-    updatedAt: now,
-    capabilities: capabilityCandidates,
-  };
-}
-
-function loadLearningSummary(cwd) {
-  try {
-    const absPath = path.join(cwd, LEARNING_SUMMARY_REL);
-    const raw = JSON.parse(fs.readFileSync(absPath, "utf8"));
-    if (raw.schemaVersion !== SUMMARY_SCHEMA) return null;
-    return raw;
-  } catch {
-    return null;
-  }
-}
-
-function loadProjectBrain(cwd) {
-  try {
-    const absPath = path.join(cwd, BRAIN_REL);
-    const raw = JSON.parse(fs.readFileSync(absPath, "utf8"));
-    if (raw.schemaVersion !== BRAIN_SCHEMA) return null;
-    return raw;
-  } catch {
-    return null;
-  }
-}
-
-function buildLearningSummary(cwd, decisions, riskRegister, capabilities) {
-  const now = nowIso();
-  const risks = (riskRegister && riskRegister.risks) ? riskRegister.risks : riskRegister || [];
-  const activeDecisions = decisions.filter((d) => d.status === "active");
-  const activeRisks = risks.filter((r) => r.status === "active");
-  const staleItems = decisions.filter(
-    (d) => d.status === "stale" || d.status === "superseded"
-  );
-
-  // Top learning signals — bounded, sorted by confidence
-  const topSignals = activeDecisions
-    .sort((a, b) => b.confidence - a.confidence)
-    .slice(0, 3)
-    .map((d) => ({
-      type: "decision",
-      summary: d.decision.slice(0, 120),
-      confidence: d.confidence,
-      reasonCodes: d.reasonCodes,
-    }));
-
-  // How learning influences next-run defaults (bounded, reason-coded)
-  const nextRunInfluence = [];
-
-  const proofRequired = activeDecisions.find((d) => d.id === "dec_applied_requires_receipt");
-  if (proofRequired) {
-    nextRunInfluence.push({
-      type: "require_lifecycle_receipt",
-      text: "Require lifecycle receipt before claiming applied or improved.",
-      reasonCodes: ["LIFECYCLE_HONEST_CLAIM"],
-    });
-  }
-
-  const hostSpecific = activeDecisions.find((d) => d.id === "dec_host_support_is_host_specific");
-  if (hostSpecific) {
-    nextRunInfluence.push({
-      type: "host_support_wording",
-      text: "Host support wording remains host-specific — no universal claims.",
-      reasonCodes: ["HOST_SUPPORT_HOST_SPECIFIC"],
-    });
-  }
-
-  const ctxPressure = activeDecisions.find((d) => d.id === "dec_context_pressure_use_carryforward");
-  if (ctxPressure) {
-    nextRunInfluence.push({
-      type: "prefer_carryforward",
-      text: "Prefer carry-forward summary under context pressure.",
-      reasonCodes: ctxPressure.reasonCodes,
-    });
-  }
-
-  const fp = buildFingerprint({
-    activeDecisionCount: activeDecisions.length,
-    activeRiskCount: activeRisks.length,
-    capabilityCount: capabilities.length,
-  });
-
-  return {
-    schemaVersion: SUMMARY_SCHEMA,
-    generatedAt: now,
-    activeDecisionCount: activeDecisions.length,
-    activeRiskCount: activeRisks.length,
-    capabilityCount: capabilities.length,
-    staleItemCount: staleItems.length,
-    topLearningSignals: topSignals,
-    nextRunInfluence,
-    limitations: [
-      "Learning is evidence-backed but bounded — does not override user instructions.",
-      "Stale or superseded decisions are excluded from next-run influence.",
-      "Conflicting decisions are flagged, not silently overwritten.",
-      "Test fixtures are excluded from real learning candidates.",
-    ],
-    sourceFingerprint: fp,
-  };
-}
-
-// ── Main generate function ────────────────────────────────────────────────────
-
-function generateLearningArtifacts(cwd, options = {}) {
-  const evidence = collectLearningEvidence(cwd);
-
-  const decisionCandidates = generateDecisionCandidates(evidence);
-  const riskCandidates = generateRiskCandidates(evidence);
-  const capabilityCandidates = generateCapabilityCandidates(evidence);
-
-  // Project brain
-  const brain = buildProjectBrain(cwd, evidence);
-  const brainPath = path.join(cwd, BRAIN_REL);
-  fs.mkdirSync(path.dirname(brainPath), { recursive: true });
-  fs.writeFileSync(brainPath, JSON.stringify(brain, null, 2), "utf8");
-
-  // Decision register (merge into existing)
-  const existingDecisions = loadDecisionRegister(cwd);
-  const mergedDecisions = mergeDecisions(existingDecisions, decisionCandidates);
-  writeDecisionRegister(cwd, mergedDecisions);
-
-  // Risk register (merge into existing)
-  const riskRegister = buildRiskRegister(cwd, riskCandidates);
-  const riskPath = path.join(cwd, RISK_REGISTER_REL);
-  fs.mkdirSync(path.dirname(riskPath), { recursive: true });
-  fs.writeFileSync(riskPath, JSON.stringify(riskRegister, null, 2), "utf8");
-
-  // Capability map
-  const capabilityMap = buildCapabilityMap(cwd, capabilityCandidates);
-  const capPath = path.join(cwd, CAPABILITY_MAP_REL);
-  fs.mkdirSync(path.dirname(capPath), { recursive: true });
-  fs.writeFileSync(capPath, JSON.stringify(capabilityMap, null, 2), "utf8");
-
-  // Learning summary
-  const summary = buildLearningSummary(
-    cwd,
-    mergedDecisions,
-    riskRegister,
-    capabilityCandidates
-  );
-  const summaryPath = path.join(cwd, LEARNING_SUMMARY_REL);
-  fs.mkdirSync(path.dirname(summaryPath), { recursive: true });
-  fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2), "utf8");
-
-  return {
-    brain,
-    decisions: mergedDecisions,
-    risks: riskRegister,
-    capabilities: capabilityMap,
-    summary,
-  };
-}
-
-function formatLearningSummaryText(cwd) {
-  const summary = loadLearningSummary(cwd);
-  if (!summary) return null;
-
-  const lines = [
-    `Learning: ${summary.activeDecisionCount} active decision(s), ` +
-      `${summary.activeRiskCount} recurring risk(s), ${summary.capabilityCount} capability(ies).`,
-  ];
-
-  if (summary.nextRunInfluence.length > 0) {
-    lines.push(`  Next run influence: ${summary.nextRunInfluence[0].text}`);
-  }
-
-  return lines.join("\n");
-}
-
-function formatLearningSummaryStatusLine(cwd) {
-  const summary = loadLearningSummary(cwd);
-  if (!summary) return null;
-  return (
-    `Learning: ${summary.activeDecisionCount} decision(s), ` +
-    `${summary.activeRiskCount} risk(s), ${summary.capabilityCount} capability(ies)`
-  );
-}
-
-module.exports = {
-  BRAIN_SCHEMA,
-  DECISION_SCHEMA,
-  RISK_SCHEMA,
-  CAPABILITY_SCHEMA,
-  SUMMARY_SCHEMA,
-  BRAIN_REL,
-  DECISION_REGISTER_REL,
-  RISK_REGISTER_REL,
-  CAPABILITY_MAP_REL,
-  LEARNING_SUMMARY_REL,
-  SOURCE_ORDER,
-  DECISION_STATUSES,
-  collectLearningEvidence,
-  generateDecisionCandidates,
-  generateRiskCandidates,
-  generateCapabilityCandidates,
-  buildProjectBrain,
-  loadDecisionRegister,
-  writeDecisionRegister,
-  mergeDecisions,
-  buildRiskRegister,
-  loadRiskRegister,
-  buildCapabilityMap,
-  loadCapabilityMap,
-  buildLearningSummary,
-  loadLearningSummary,
-  loadProjectBrain,
-  generateLearningArtifacts,
-  formatLearningSummaryText,
-  formatLearningSummaryStatusLine,
-};