@manehorizons/cadence-core 1.6.0 → 1.7.0

package/dist/intelligence/store.js

@@ -1,701 +0,0 @@
-import { mkdir, readFile, stat } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { AssumptionLedgerZ, EvidenceLedgerZ, IntelligenceDecisionLedgerZ, MilestoneLedgerZ, RecommendationLedgerZ, emptyAssumptionLedger, emptyEvidenceLedger, emptyIntelligenceDecisionLedger, emptyMilestoneLedger, emptyRecommendationLedger, } from '@manehorizons/cadence-types';
-import { atomicWriteJSON, atomicWriteText } from '../state/atomic-write.js';
-import { renderRecommendationsMd } from './render.js';
-import { renderMilestonesMd } from './render-milestone.js';
-import { renderAssumptionsMd } from './render-assumption.js';
-import { renderDecisionsMd } from './render-decision.js';
-const INTELLIGENCE_DIR = '.cadence/intelligence';
-const RECOMMENDATIONS_JSON = 'recommendations.json';
-const EVIDENCE_JSON = 'evidence.json';
-const RECOMMENDATIONS_MD = 'RECOMMENDATIONS.md';
-const ASSUMPTIONS_JSON = 'assumptions.json';
-const DECISIONS_JSON = 'decisions.json';
-const ASSUMPTIONS_MD = 'ASSUMPTIONS.md';
-const DECISIONS_MD = 'DECISIONS.md';
-export function intelligenceDir(root) {
-    return join(root, INTELLIGENCE_DIR);
-}
-function recommendationsPath(root) {
-    return join(intelligenceDir(root), RECOMMENDATIONS_JSON);
-}
-function evidencePath(root) {
-    return join(intelligenceDir(root), EVIDENCE_JSON);
-}
-function assumptionsPath(root) {
-    return join(intelligenceDir(root), ASSUMPTIONS_JSON);
-}
-function decisionsPath(root) {
-    return join(intelligenceDir(root), DECISIONS_JSON);
-}
-function recommendationsMdPath(root) {
-    return join(intelligenceDir(root), RECOMMENDATIONS_MD);
-}
-function assumptionsMdPath(root) {
-    return join(intelligenceDir(root), ASSUMPTIONS_MD);
-}
-function decisionsMdPath(root) {
-    return join(intelligenceDir(root), DECISIONS_MD);
-}
-export async function readRecommendationLedger(root) {
-    const path = recommendationsPath(root);
-    if (!existsSync(path))
-        return emptyRecommendationLedger();
-    const raw = await readFile(path, 'utf8');
-    return RecommendationLedgerZ.parse(JSON.parse(raw));
-}
-export async function readEvidenceLedger(root) {
-    const path = evidencePath(root);
-    if (!existsSync(path))
-        return emptyEvidenceLedger();
-    const raw = await readFile(path, 'utf8');
-    return EvidenceLedgerZ.parse(JSON.parse(raw));
-}
-export async function readAssumptionLedger(root) {
-    const path = assumptionsPath(root);
-    if (!existsSync(path))
-        return emptyAssumptionLedger();
-    const raw = await readFile(path, 'utf8');
-    return AssumptionLedgerZ.parse(JSON.parse(raw));
-}
-export async function readIntelligenceDecisionLedger(root) {
-    const path = decisionsPath(root);
-    if (!existsSync(path))
-        return emptyIntelligenceDecisionLedger();
-    const raw = await readFile(path, 'utf8');
-    return IntelligenceDecisionLedgerZ.parse(JSON.parse(raw));
-}
-async function writeIntelligenceLedgers(root, ledger, evidenceLedger) {
-    const dir = intelligenceDir(root);
-    await mkdir(dir, { recursive: true });
-    RecommendationLedgerZ.parse(ledger);
-    EvidenceLedgerZ.parse(evidenceLedger);
-    await atomicWriteJSON(recommendationsPath(root), ledger);
-    await atomicWriteJSON(evidencePath(root), evidenceLedger);
-    // Read sibling ledgers so the rec MD renders status-annotated link bullets (Slice 15).
-    const asLedger = await readAssumptionLedger(root);
-    const decLedger = await readIntelligenceDecisionLedger(root);
-    await atomicWriteText(recommendationsMdPath(root), renderRecommendationsMd(ledger, evidenceLedger, asLedger, decLedger));
-}
-function slugDate(now) {
-    return now.toISOString().slice(0, 10).replaceAll('-', '');
-}
-function nextRecommendationId(ledger, now) {
-    const prefix = `rec-${slugDate(now)}-`;
-    const max = ledger.recommendations
-        .map((r) => r.id)
-        .filter((id) => id.startsWith(prefix))
-        .map((id) => Number.parseInt(id.slice(prefix.length), 10))
-        .filter((n) => Number.isFinite(n))
-        .reduce((a, b) => Math.max(a, b), 0);
-    return `${prefix}${String(max + 1).padStart(3, '0')}`;
-}
-function nextEvidenceId(ledger, now) {
-    const prefix = `ev-${slugDate(now)}-`;
-    const max = ledger.evidence
-        .map((ev) => ev.id)
-        .filter((id) => id.startsWith(prefix))
-        .map((id) => Number.parseInt(id.slice(prefix.length), 10))
-        .filter((n) => Number.isFinite(n))
-        .reduce((a, b) => Math.max(a, b), 0);
-    return `${prefix}${String(max + 1).padStart(3, '0')}`;
-}
-function nextAssumptionId(ledger, now) {
-    const prefix = `as-${slugDate(now)}-`;
-    const max = ledger.assumptions
-        .map((a) => a.id)
-        .filter((id) => id.startsWith(prefix))
-        .map((id) => Number.parseInt(id.slice(prefix.length), 10))
-        .filter((n) => Number.isFinite(n))
-        .reduce((a, b) => Math.max(a, b), 0);
-    return `${prefix}${String(max + 1).padStart(3, '0')}`;
-}
-function nextIntelligenceDecisionId(ledger, now) {
-    const prefix = `dec-${slugDate(now)}-`;
-    const max = ledger.decisions
-        .map((d) => d.id)
-        .filter((id) => id.startsWith(prefix))
-        .map((id) => Number.parseInt(id.slice(prefix.length), 10))
-        .filter((n) => Number.isFinite(n))
-        .reduce((a, b) => Math.max(a, b), 0);
-    return `${prefix}${String(max + 1).padStart(3, '0')}`;
-}
-export async function addRecommendation(root, input) {
-    const ledger = await readRecommendationLedger(root);
-    const evidenceLedger = await readEvidenceLedger(root);
-    const now = new Date();
-    const ts = now.toISOString();
-    const recommendationId = nextRecommendationId(ledger, now);
-    const evidence = input.evidenceSummary
-        ? {
-            id: nextEvidenceId(evidenceLedger, now),
-            recommendationId,
-            kind: 'note',
-            summary: input.evidenceSummary,
-            createdAt: ts,
-        }
-        : null;
-    const rec = {
-        id: recommendationId,
-        title: input.title,
-        summary: input.summary,
-        source: 'manual',
-        status: 'candidate',
-        readiness: input.readiness,
-        priority: input.priority,
-        leverageScore: 5,
-        riskScore: 5,
-        confidence: input.evidenceSummary ? 0.7 : 0.4,
-        decayState: 'fresh',
-        affectedAreas: input.affectedAreas,
-        affectedFiles: input.affectedFiles,
-        suggestedBackendAction: 'cadence milestone propose',
-        evidenceIds: evidence ? [evidence.id] : [],
-        assumptionIds: [],
-        decisionIds: [],
-        createdAt: ts,
-        updatedAt: ts,
-    };
-    if (evidence)
-        evidenceLedger.evidence.push(evidence);
-    ledger.recommendations.push(rec);
-    await writeIntelligenceLedgers(root, ledger, evidenceLedger);
-    return rec;
-}
-async function writeAssumptionLedger(root, ledger) {
-    AssumptionLedgerZ.parse(ledger);
-    await mkdir(intelligenceDir(root), { recursive: true });
-    await atomicWriteJSON(assumptionsPath(root), ledger);
-    await atomicWriteText(assumptionsMdPath(root), renderAssumptionsMd(ledger));
-}
-export async function addAssumption(root, input) {
-    const recLedger = await readRecommendationLedger(root);
-    if (!recLedger.recommendations.some((r) => r.id === input.recommendationId)) {
-        throw new Error(`unknown recommendation "${input.recommendationId}"`);
-    }
-    const asLedger = await readAssumptionLedger(root);
-    const now = new Date();
-    const a = {
-        id: nextAssumptionId(asLedger, now),
-        recommendationId: input.recommendationId,
-        text: input.text,
-        status: 'open',
-        createdAt: now.toISOString(),
-    };
-    asLedger.assumptions.push(a);
-    await writeAssumptionLedger(root, asLedger);
-    const decLedger = await readIntelligenceDecisionLedger(root);
-    const evLedger = await readEvidenceLedger(root);
-    const derivedRec = deriveRecommendationLinks(recLedger, asLedger, decLedger);
-    await writeIntelligenceLedgers(root, derivedRec, evLedger);
-    return a;
-}
-const ASSUMPTION_TRANSITION_ALLOWED = {
-    validate: ['open'],
-    reject: ['open'],
-    reopen: ['validated', 'rejected'],
-};
-const ASSUMPTION_TRANSITION_NEXT = {
-    validate: 'validated',
-    reject: 'rejected',
-    reopen: 'open',
-};
-export function applyAssumptionTransition(ledger, id, action, _now) {
-    const target = ledger.assumptions.find((a) => a.id === id);
-    if (!target)
-        return { ok: false, error: `assumption ${id} not found` };
-    if (!ASSUMPTION_TRANSITION_ALLOWED[action].includes(target.status)) {
-        return {
-            ok: false,
-            error: `cannot ${action} assumption in status ${target.status}`,
-        };
-    }
-    const nextStatus = ASSUMPTION_TRANSITION_NEXT[action];
-    const ledgerOut = {
-        schemaVersion: 1,
-        assumptions: ledger.assumptions.map((a) => a.id === id ? { ...a, status: nextStatus } : a),
-    };
-    return { ok: true, ledger: ledgerOut };
-}
-export async function runAssumptionTransition(root, id, action) {
-    const ledger = await readAssumptionLedger(root);
-    const res = applyAssumptionTransition(ledger, id, action, new Date());
-    if (!res.ok)
-        return res;
-    await writeAssumptionLedger(root, res.ledger);
-    // Slice 15: propagate status change into RECOMMENDATIONS.md annotated bullets.
-    await rerenderRecommendationsMdIfPresent(root);
-    return res;
-}
-async function rerenderRecommendationsMdIfPresent(root) {
-    if (!existsSync(recommendationsPath(root)))
-        return;
-    const recLedger = await readRecommendationLedger(root);
-    const evLedger = await readEvidenceLedger(root);
-    const asLedger = await readAssumptionLedger(root);
-    const decLedger = await readIntelligenceDecisionLedger(root);
-    await atomicWriteText(recommendationsMdPath(root), renderRecommendationsMd(recLedger, evLedger, asLedger, decLedger));
-}
-export function deriveRecommendationLinks(recLedger, asLedger, decLedger) {
-    return {
-        schemaVersion: 1,
-        recommendations: recLedger.recommendations.map((r) => ({
-            ...r,
-            assumptionIds: asLedger.assumptions
-                .filter((a) => a.recommendationId === r.id)
-                .map((a) => a.id),
-            decisionIds: decLedger.decisions
-                .filter((d) => d.recommendationId === r.id)
-                .map((d) => d.id),
-        })),
-    };
-}
-async function writeIntelligenceDecisionLedger(root, ledger) {
-    IntelligenceDecisionLedgerZ.parse(ledger);
-    await mkdir(intelligenceDir(root), { recursive: true });
-    await atomicWriteJSON(decisionsPath(root), ledger);
-    await atomicWriteText(decisionsMdPath(root), renderDecisionsMd(ledger));
-}
-export async function addIntelligenceDecision(root, input) {
-    let recLedger = null;
-    if (input.recommendationId !== undefined) {
-        recLedger = await readRecommendationLedger(root);
-        if (!recLedger.recommendations.some((r) => r.id === input.recommendationId)) {
-            throw new Error(`unknown recommendation "${input.recommendationId}"`);
-        }
-    }
-    const decLedger = await readIntelligenceDecisionLedger(root);
-    const now = new Date();
-    // Construct in schema-declaration order so the persisted JSON property
-    // order matches what `IntelligenceDecisionLedgerZ.parse(...)` would produce
-    // on reconcile. Keeps byte-equality between addIntelligenceDecision writes
-    // and reconcile writes (relied on by Slice-17 AC-6).
-    const out = {
-        id: nextIntelligenceDecisionId(decLedger, now),
-        ...(input.recommendationId !== undefined ? { recommendationId: input.recommendationId } : {}),
-        title: input.title,
-        rationale: input.rationale,
-        status: 'active',
-        decidedAt: now.toISOString(),
-        supersedes: [],
-    };
-    decLedger.decisions.push(out);
-    // Slice 31: re-derive supersedes arrays across the whole ledger. New
-    // decisions can't be referenced by older ones yet, but pre-Slice-31
-    // ledgers being loaded for the first time benefit from the field
-    // being populated explicitly on write.
-    const derivedDec = deriveDecisionInverseLinks(decLedger);
-    await writeIntelligenceDecisionLedger(root, derivedDec);
-    if (input.recommendationId !== undefined && recLedger !== null) {
-        const asLedger = await readAssumptionLedger(root);
-        const evLedger = await readEvidenceLedger(root);
-        const derivedRec = deriveRecommendationLinks(recLedger, asLedger, decLedger);
-        await writeIntelligenceLedgers(root, derivedRec, evLedger);
-    }
-    return out;
-}
-const DECISION_TRANSITION_ALLOWED = {
-    supersede: ['active'],
-    rescind: ['active'],
-    reactivate: ['superseded', 'rescinded'],
-};
-const DECISION_TRANSITION_NEXT = {
-    supersede: 'superseded',
-    rescind: 'rescinded',
-    reactivate: 'active',
-};
-function walkSupersededByChain(ledger, startId, forbid) {
-    const chain = [];
-    const seen = new Set();
-    let cursor = startId;
-    while (cursor) {
-        if (cursor === forbid)
-            return { ok: false, chain };
-        if (seen.has(cursor))
-            return { ok: true, chain };
-        seen.add(cursor);
-        chain.push(cursor);
-        const node = ledger.decisions.find((d) => d.id === cursor);
-        cursor = node?.supersededBy;
-    }
-    return { ok: true, chain };
-}
-// Slice 31: pure helper. For every decision D in the ledger, recompute
-// D.supersedes from current supersededBy values — the inverse-link of
-// Slice 28's edge. Mirrors Slice 11's deriveRecommendationLinks shape
-// but operates within one ledger. Idempotent.
-export function deriveDecisionInverseLinks(ledger) {
-    return {
-        schemaVersion: 1,
-        decisions: ledger.decisions.map((d) => ({
-            ...d,
-            supersedes: ledger.decisions
-                .filter((other) => other.supersededBy === d.id)
-                .map((other) => other.id),
-        })),
-    };
-}
-export function applyDecisionTransition(ledger, id, action, by, _now) {
-    const target = ledger.decisions.find((d) => d.id === id);
-    if (!target)
-        return { ok: false, error: `decision ${id} not found` };
-    if (!DECISION_TRANSITION_ALLOWED[action].includes(target.status)) {
-        return {
-            ok: false,
-            error: `cannot ${action} decision in status ${target.status}`,
-        };
-    }
-    if (action === 'supersede' && by !== undefined) {
-        if (by === id) {
-            return {
-                ok: false,
-                error: 'cannot supersede: decision cannot supersede itself',
-            };
-        }
-        const replacement = ledger.decisions.find((d) => d.id === by);
-        if (!replacement) {
-            return {
-                ok: false,
-                error: `cannot supersede: decision ${by} not found`,
-            };
-        }
-        const walk = walkSupersededByChain(ledger, by, id);
-        if (!walk.ok) {
-            return {
-                ok: false,
-                error: `cannot supersede: would create cycle (${[...walk.chain, id].join(' → ')})`,
-            };
-        }
-    }
-    const nextStatus = DECISION_TRANSITION_NEXT[action];
-    const ledgerOut = {
-        schemaVersion: 1,
-        decisions: ledger.decisions.map((d) => {
-            if (d.id !== id)
-                return d;
-            const updated = { ...d, status: nextStatus };
-            if (action === 'supersede') {
-                if (by !== undefined)
-                    updated.supersededBy = by;
-            }
-            else if (action === 'reactivate') {
-                delete updated.supersededBy;
-            }
-            return updated;
-        }),
-    };
-    // Slice 31: re-derive supersedes arrays so the returned ledger is fully
-    // consistent (target's supersededBy update propagates to the replacement's
-    // supersedes array, and reactivate-cleared targets drop out).
-    return { ok: true, ledger: deriveDecisionInverseLinks(ledgerOut) };
-}
-export async function runDecisionTransition(root, id, action, by) {
-    const ledger = await readIntelligenceDecisionLedger(root);
-    const res = applyDecisionTransition(ledger, id, action, by, new Date());
-    if (!res.ok)
-        return res;
-    await writeIntelligenceDecisionLedger(root, res.ledger);
-    // Slice 15: propagate status change into RECOMMENDATIONS.md annotated bullets.
-    await rerenderRecommendationsMdIfPresent(root);
-    return res;
-}
-const RECOMMENDATION_TRANSITION_ALLOWED = {
-    convert: ['candidate', 'accepted'],
-};
-const RECOMMENDATION_TRANSITION_NEXT = {
-    convert: 'converted',
-};
-export function applyRecommendationTransition(ledger, id, action, toPhase, now) {
-    const target = ledger.recommendations.find((r) => r.id === id);
-    if (!target)
-        return { ok: false, error: `recommendation ${id} not found` };
-    if (!RECOMMENDATION_TRANSITION_ALLOWED[action].includes(target.status)) {
-        return {
-            ok: false,
-            error: `cannot ${action} recommendation in status ${target.status}`,
-        };
-    }
-    const nextStatus = RECOMMENDATION_TRANSITION_NEXT[action];
-    const updatedAt = now.toISOString();
-    const ledgerOut = {
-        schemaVersion: 1,
-        recommendations: ledger.recommendations.map((r) => r.id === id
-            ? { ...r, status: nextStatus, convertedToPhaseId: toPhase, updatedAt }
-            : r),
-    };
-    return { ok: true, ledger: ledgerOut };
-}
-// Slice 34.1: existence check for `.cadence/phases/<phaseId>/` lives in the
-// I/O wrapper deliberately — keeps the pure helper disk-free (per Slice 34
-// Decision Log §10 + §11 architectural principle).
-async function phaseDirectoryExists(root, phaseId) {
-    try {
-        const s = await stat(join(root, '.cadence/phases', phaseId));
-        return s.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export async function runRecommendationTransition(root, id, action, toPhase) {
-    // FK check FIRST so a missing phase is caught before any ledger read.
-    // Mirrors Slice 28's --by precedence: validate FK before applying transition.
-    if (!(await phaseDirectoryExists(root, toPhase))) {
-        return { ok: false, error: `cannot convert: phase ${toPhase} not found` };
-    }
-    const ledger = await readRecommendationLedger(root);
-    const res = applyRecommendationTransition(ledger, id, action, toPhase, new Date());
-    if (!res.ok)
-        return res;
-    // writeIntelligenceLedgers handles atomic JSON + RECOMMENDATIONS.md re-render
-    // (Slice 15 annotated form), so we don't need a separate rerender call.
-    const evidenceLedger = await readEvidenceLedger(root);
-    await writeIntelligenceLedgers(root, res.ledger, evidenceLedger);
-    return res;
-}
-const MILESTONES_JSON = 'milestones.json';
-const MILESTONES_MD = 'MILESTONES.md';
-const REC_STATUSES = [
-    'candidate',
-    'accepted',
-    'deferred',
-    'rejected',
-    'converted',
-];
-const REC_READINESSES = [
-    'raw-idea',
-    'needs-evidence',
-    'needs-decision',
-    'ready-for-milestone',
-    'ready-for-cadence-spec',
-    'blocked',
-];
-const EV_KINDS = ['file', 'command', 'cadence-artifact', 'note'];
-const AS_STATUSES = ['open', 'validated', 'rejected'];
-const DEC_STATUSES = [
-    'active',
-    'superseded',
-    'rescinded',
-];
-export function computeIntelligenceStats(recLedger, evLedger, asLedger, decLedger) {
-    const recByStatus = Object.fromEntries(REC_STATUSES.map((s) => [s, 0]));
-    const recByReadiness = Object.fromEntries(REC_READINESSES.map((r) => [r, 0]));
-    for (const r of recLedger.recommendations) {
-        recByStatus[r.status]++;
-        recByReadiness[r.readiness]++;
-    }
-    const evByKind = Object.fromEntries(EV_KINDS.map((k) => [k, 0]));
-    for (const ev of evLedger.evidence)
-        evByKind[ev.kind]++;
-    const asByStatus = Object.fromEntries(AS_STATUSES.map((s) => [s, 0]));
-    for (const a of asLedger.assumptions)
-        asByStatus[a.status]++;
-    const decByStatus = Object.fromEntries(DEC_STATUSES.map((s) => [s, 0]));
-    let decUntied = 0;
-    for (const d of decLedger.decisions) {
-        decByStatus[d.status]++;
-        if (d.recommendationId === undefined)
-            decUntied++;
-    }
-    const asById = new Map(asLedger.assumptions.map((a) => [a.id, a]));
-    const decById = new Map(decLedger.decisions.map((d) => [d.id, d]));
-    const evById = new Map(evLedger.evidence.map((e) => [e.id, e]));
-    let brokenAssumptionLinks = 0;
-    let brokenDecisionLinks = 0;
-    let brokenEvidenceLinks = 0;
-    for (const r of recLedger.recommendations) {
-        for (const id of r.assumptionIds)
-            if (!asById.has(id))
-                brokenAssumptionLinks++;
-        for (const id of r.decisionIds)
-            if (!decById.has(id))
-                brokenDecisionLinks++;
-        for (const id of r.evidenceIds)
-            if (!evById.has(id))
-                brokenEvidenceLinks++;
-    }
-    const perRec = recLedger.recommendations.map((r) => {
-        const ascount = Object.fromEntries(AS_STATUSES.map((s) => [s, 0]));
-        const dccount = Object.fromEntries(DEC_STATUSES.map((s) => [s, 0]));
-        for (const id of r.assumptionIds) {
-            const a = asById.get(id);
-            if (a)
-                ascount[a.status]++;
-        }
-        for (const id of r.decisionIds) {
-            const d = decById.get(id);
-            if (d)
-                dccount[d.status]++;
-        }
-        let evCount = 0;
-        for (const id of r.evidenceIds)
-            if (evById.has(id))
-                evCount++;
-        return {
-            id: r.id,
-            title: r.title,
-            status: r.status,
-            assumptionsByStatus: ascount,
-            decisionsByStatus: dccount,
-            evidenceCount: evCount,
-        };
-    });
-    return {
-        recommendations: {
-            total: recLedger.recommendations.length,
-            byStatus: recByStatus,
-            byReadiness: recByReadiness,
-        },
-        evidence: { total: evLedger.evidence.length, byKind: evByKind },
-        assumptions: {
-            total: asLedger.assumptions.length,
-            byStatus: asByStatus,
-        },
-        decisions: {
-            total: decLedger.decisions.length,
-            byStatus: decByStatus,
-            untied: decUntied,
-        },
-        links: { brokenAssumptionLinks, brokenDecisionLinks, brokenEvidenceLinks },
-        perRec,
-    };
-}
-export const AUDIT_KINDS = [
-    'broken-assumption-link',
-    'broken-decision-link',
-    'broken-evidence-link',
-    'orphan-assumption',
-    'orphan-decision',
-    'orphan-evidence',
-    'stale-supersededby',
-    'stale-converted-phase',
-];
-export function computeIntelligenceAudit(recLedger, evLedger, asLedger, decLedger, existingPhaseIds = new Set()) {
-    const findings = [];
-    const recIds = new Set(recLedger.recommendations.map((r) => r.id));
-    const evIds = new Set(evLedger.evidence.map((e) => e.id));
-    const asIds = new Set(asLedger.assumptions.map((a) => a.id));
-    const decIds = new Set(decLedger.decisions.map((d) => d.id));
-    for (const r of recLedger.recommendations) {
-        for (const id of r.assumptionIds) {
-            if (!asIds.has(id)) {
-                findings.push({ kind: 'broken-assumption-link', recId: r.id, assumptionId: id });
-            }
-        }
-        for (const id of r.decisionIds) {
-            if (!decIds.has(id)) {
-                findings.push({ kind: 'broken-decision-link', recId: r.id, decisionId: id });
-            }
-        }
-        for (const id of r.evidenceIds) {
-            if (!evIds.has(id)) {
-                findings.push({ kind: 'broken-evidence-link', recId: r.id, evidenceId: id });
-            }
-        }
-    }
-    for (const a of asLedger.assumptions) {
-        if (!recIds.has(a.recommendationId)) {
-            findings.push({
-                kind: 'orphan-assumption',
-                assumptionId: a.id,
-                missingRecId: a.recommendationId,
-            });
-        }
-    }
-    for (const d of decLedger.decisions) {
-        if (d.recommendationId !== undefined && !recIds.has(d.recommendationId)) {
-            findings.push({
-                kind: 'orphan-decision',
-                decisionId: d.id,
-                missingRecId: d.recommendationId,
-            });
-        }
-    }
-    for (const ev of evLedger.evidence) {
-        if (!recIds.has(ev.recommendationId)) {
-            findings.push({
-                kind: 'orphan-evidence',
-                evidenceId: ev.id,
-                missingRecId: ev.recommendationId,
-            });
-        }
-    }
-    // Slice 30: stale supersededBy refs (decision.supersededBy points to a missing decision id).
-    for (const d of decLedger.decisions) {
-        if (d.supersededBy !== undefined && !decIds.has(d.supersededBy)) {
-            findings.push({
-                kind: 'stale-supersededby',
-                decisionId: d.id,
-                missingTargetId: d.supersededBy,
-            });
-        }
-    }
-    // Slice 34.2: stale convertedToPhaseId refs (rec converted to a phase that
-    // no longer exists on disk). Phase existence is a filesystem fact; the
-    // caller pre-computes the set so `computeIntelligenceAudit` stays pure-sync.
-    for (const r of recLedger.recommendations) {
-        if (r.convertedToPhaseId !== undefined && !existingPhaseIds.has(r.convertedToPhaseId)) {
-            findings.push({
-                kind: 'stale-converted-phase',
-                recommendationId: r.id,
-                missingPhaseId: r.convertedToPhaseId,
-            });
-        }
-    }
-    const byKind = Object.fromEntries(AUDIT_KINDS.map((k) => [k, []]));
-    for (const f of findings)
-        byKind[f.kind].push(f);
-    return { findings, byKind };
-}
-export async function runIntelligenceReconcile(root) {
-    const recExists = existsSync(recommendationsPath(root));
-    const evExists = existsSync(evidencePath(root));
-    const asExists = existsSync(assumptionsPath(root));
-    const decExists = existsSync(decisionsPath(root));
-    if (!recExists && !evExists && !asExists && !decExists) {
-        return { present: false, recommendations: 0, assumptions: 0, decisions: 0 };
-    }
-    const recLedger = await readRecommendationLedger(root);
-    const evLedger = await readEvidenceLedger(root);
-    const asLedger = await readAssumptionLedger(root);
-    const decLedger = await readIntelligenceDecisionLedger(root);
-    // Re-derive rec link arrays from current subject ledgers (idempotent if already correct).
-    const derivedRec = deriveRecommendationLinks(recLedger, asLedger, decLedger);
-    // Slice 31: re-derive decision inverse-links (supersedes arrays) from
-    // current supersededBy values. Idempotent. Operator's "force re-derive"
-    // command fixes any drift introduced by manual JSON edits.
-    const derivedDec = deriveDecisionInverseLinks(decLedger);
-    // writeIntelligenceLedgers handles atomic JSON + RECOMMENDATIONS.md re-render (Slice 15 annotated form).
-    await writeIntelligenceLedgers(root, derivedRec, evLedger);
-    await writeIntelligenceDecisionLedger(root, derivedDec);
-    // Re-render subject MDs from current ledgers (source-of-truth JSON untouched).
-    await mkdir(intelligenceDir(root), { recursive: true });
-    await atomicWriteText(assumptionsMdPath(root), renderAssumptionsMd(asLedger));
-    await atomicWriteText(decisionsMdPath(root), renderDecisionsMd(derivedDec));
-    return {
-        present: true,
-        recommendations: derivedRec.recommendations.length,
-        assumptions: asLedger.assumptions.length,
-        decisions: derivedDec.decisions.length,
-    };
-}
-function milestonesPath(root) {
-    return join(intelligenceDir(root), MILESTONES_JSON);
-}
-export async function readMilestoneLedger(root) {
-    const path = milestonesPath(root);
-    if (!existsSync(path))
-        return emptyMilestoneLedger();
-    const raw = await readFile(path, 'utf8');
-    return MilestoneLedgerZ.parse(JSON.parse(raw));
-}
-export async function writeMilestoneLedger(root, ledger) {
-    const dir = intelligenceDir(root);
-    await mkdir(dir, { recursive: true });
-    MilestoneLedgerZ.parse(ledger);
-    await atomicWriteJSON(join(dir, MILESTONES_JSON), ledger);
-    await atomicWriteText(join(dir, MILESTONES_MD), renderMilestonesMd(ledger));
-}
-//# sourceMappingURL=store.js.map