@isaacriehm/cairn-core 0.4.3 → 0.5.0

package/dist/init/rules-merge/ingest.js

@@ -1,36 +1,62 @@
 /**
- * Phase 7c orchestrator — discover + parse + Haiku classify + persist.
+ * Phase 7c orchestrator (v0.5.0 SoT model).
  *
- * Ingests CLAUDE.md, AGENTS.md, .claude/CLAUDE.md, and `.claude/rules/**.md`
- * during init. Each H2/H3 section is classified by Haiku as:
+ * Plan §5.4 algorithm:
+ *   1. Discover sections in `CLAUDE.md`, `AGENTS.md`, `.claude/rules/*.md`.
+ *   2. Topic-index lookup (built by phase 5b) before classification:
+ *      - **Match** — slug already owns a docs/CLAUDE.md/AGENTS.md/rule
+ *        SoT and was emitted by an earlier phase. Phase 7c records the
+ *        cite (no source rewrite — operator's narrative stays intact)
+ *        and skips emit.
+ *      - **Net-new** — slug is in topic-index but not yet emitted.
+ *        Phase 7c classifies the section via Haiku (kind only:
+ *        decision / domain-rule / constraint / informational), emits
+ *        a verbatim DEC/INV via `sot-emit` with `sot_kind: "path"` +
+ *        `sot_path: <file>#<anchor>`, auto-promotes (`status: accepted`).
+ *   3. Conflict detection — for each freshly emitted entity, scan
+ *      accepted DECs/INVs in `sot-cache.yaml` for high Jaccard overlap
+ *      against the new body, then run a Haiku contradiction judge per
+ *      candidate (`contradict | agree | unrelated`). On `contradict`,
+ *      write `.cairn/ground/conflicts/<new>__<other>.md` with both
+ *      prose sides + Haiku reasoning. The cairn-attention skill renders
+ *      these per §5.4.1; **no source rewrite ever fires from conflicts**.
+ *   4. Auto-promote — every novel entity ships `status: accepted`. The
+ *      `_inbox/` draft queue is gone (the v0.4.x review surface was the
+ *      v0.5.0 pivot's primary motivation).
  *
- *   - "rule-net-new"  — section states a rule cairn doesn't have yet (DEC draft to inbox)
- *   - "rule-conflict" — section conflicts with existing cairn state (soft-conflict to attention)
- *   - "informational" — TOC, history, walkthrough — no action
- *   - "operator-keep" — already inside keep-marker block (skipped pre-classification)
- *
- * Net-new rules become DEC drafts in `.cairn/ground/decisions/_inbox/`.
- * Soft conflicts append to `.cairn/baseline/rule-conflicts-<ISO>.yaml`.
- *
- * Resilient: a single Haiku failure marks the section "informational" and
- * continues. All output paths captured in the result so the skill can surface
- * them.
+ * Output side-effects (all relative to repoRoot):
+ *   - `.cairn/ground/decisions/<DEC-id>.md`        (one per novel decision/domain-rule)
+ *   - `.cairn/ground/invariants/<INV-id>.md`       (one per novel constraint)
+ *   - `.cairn/ground/topic-index.yaml`             (extended w/ dec_id stamps)
+ *   - `.cairn/ground/sot-bindings.yaml`            (forward+reverse for new ids)
+ *   - `.cairn/ground/sot-cache.yaml`               (token cache for Layer A)
+ *   - `.cairn/ground/conflicts/<a>__<b>.md`        (one per contradiction)
+ *   - `.cairn/baseline/rules-merge-<ISO>.yaml`     (full audit)
  */
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { stringify as stringifyYaml } from "yaml";
 import { runClaude } from "../../claude/index.js";
-import { computeDecisionId, scanExistingDecisionIds, } from "../../decision-capture/id.js";
-import { decisionsDir } from "../../ground/paths.js";
+import { conflictsDir, emptyAnchorMap, emptySotBindings, emptySotCache, emptyTopicIndex, readAnchorMap, readSotBindings, readSotCache, readTopicIndex, setSotCacheEntry, topicSlug, writeAnchorMap, writeSotBindings, writeSotCache, writeTopicIndex, } from "../../ground/index.js";
+import { writeDecisionsLedger, writeInvariantsLedger } from "../../ground/ledgers.js";
 import { logger } from "../../logger.js";
+import { jaccard, tokenize } from "../../text/jaccard.js";
+import { emitFromTopicIndex } from "../sot-emit.js";
 import { discoverRuleSources } from "./discover.js";
 import { parseRuleSections } from "./parse-sections.js";
 const log = logger("init.rules-merge.ingest");
 const PER_SECTION_TIMEOUT_MS = 60_000;
 const SECTION_BODY_CAP = 4_000;
 const CONCURRENCY = 4;
+const CAPTURE_SOURCE = "init-rules-merge";
+/** Conflict-scan tuning. */
+const CONFLICT_JACCARD_THRESHOLD = 0.4;
+const CONFLICT_MAX_CANDIDATES_PER_EMIT = 3;
+const CONFLICT_MAX_JUDGE_CALLS = 25;
+const CONFLICT_BODY_CAP = 1_500;
+const PER_CONTRADICTION_TIMEOUT_MS = 30_000;
 /* -------------------------------------------------------------------------- */
-/* Schema + prompt                                                            */
+/* Schemas + prompts                                                          */
 /* -------------------------------------------------------------------------- */
 const CLASSIFY_SCHEMA = {
     type: "object",
@@ -39,29 +65,40 @@ const CLASSIFY_SCHEMA = {
     properties: {
         kind: {
             type: "string",
-            enum: ["rule-net-new", "rule-conflict", "informational", "operator-keep"],
+            enum: ["decision", "domain-rule", "constraint", "informational"],
         },
-        proposed_dec_title: { type: "string" },
-        proposed_rationale: { type: "string" },
-        conflicts_with: { type: "string" },
     },
 };
-const CLASSIFY_SYSTEM = `You classify markdown sections of project-rule files for Cairn adoption.
+const CLASSIFY_SYSTEM = `You classify markdown sections of project-rule files for Cairn's Single-Source-of-Truth ledger.
+
+Each section comes from CLAUDE.md, AGENTS.md, or a .claude/rules/*.md file.
 
-Each section comes from one of: CLAUDE.md, AGENTS.md, .claude/CLAUDE.md, or a .claude/rules/*.md file.
+Return JSON matching the schema. \`kind\` choices:
+  - "decision"       paragraph describes a binding decision or architectural choice
+  - "domain-rule"    paragraph states a domain rule developers must follow (treated as a decision in the ledger)
+  - "constraint"     paragraph states a hard constraint / invariant (must / must not / never / always)
+  - "informational"  TOC, walkthrough, history, formatting notes — nothing actionable
+
+Be conservative — false-positive ledger entries pollute ground state worse than missed capture.
+Default to "informational" when uncertain.`;
+const CONTRADICTION_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["verdict"],
+    properties: {
+        verdict: { type: "string", enum: ["contradict", "agree", "unrelated"] },
+        reasoning: { type: "string" },
+    },
+};
+const CONTRADICTION_SYSTEM = `You compare two project-rule statements for contradiction.
 
-Return JSON matching the schema. \`kind\` must be exactly one of:
-  - "rule-net-new"   the section states a binding rule cairn doesn't yet have
-  - "rule-conflict"  the section contradicts an existing cairn rule (provide conflicts_with id when known)
-  - "informational"  TOC, walkthrough, history, formatting notes — nothing to ingest
-  - "operator-keep"  the section is wrapped in keep-markers (rare — caller usually filters first)
+Return JSON: { "verdict": "contradict" | "agree" | "unrelated", "reasoning": "<one sentence>" }.
 
-Optional fields:
-  - proposed_dec_title  5-10 word imperative title (only when kind = "rule-net-new")
-  - proposed_rationale  2-3 sentence summary (only when kind = "rule-net-new")
-  - conflicts_with      DEC-NNNN or §INV-NNNN id (only when kind = "rule-conflict")
+  - "contradict"  the two statements cannot both be true / followed at once
+  - "agree"       the two statements describe the same rule with compatible wording
+  - "unrelated"   the statements address different topics
 
-Be conservative. When in doubt, "informational".`;
+Be conservative on "contradict" — only flag a true logical contradiction (one says X, the other says NOT X). Surface-level differences in tone or scope are NOT contradictions.`;
 /* -------------------------------------------------------------------------- */
 /* Public                                                                     */
 /* -------------------------------------------------------------------------- */
@@ -69,7 +106,10 @@ export async function runRulesMerge(args) {
     const repoRoot = args.repoRoot;
     const nowIso = args.nowIso ?? new Date().toISOString();
     const tsSlug = nowIso.replace(/[:.]/g, "-").slice(0, 19);
+    // ── 1. Discover + walk sections ──────────────────────────────────
     const sources = discoverRuleSources(repoRoot);
+    const ruleFilesSet = new Set(sources.map((s) => s.path));
+    const sectionsBySlug = new Map();
     const allClassifications = [];
     const jobs = [];
     for (const source of sources) {
@@ -84,27 +124,43 @@ export async function runRulesMerge(args) {
         const sections = parseRuleSections(body);
         for (const section of sections) {
             if (section.level === 0)
-                continue; // skip preamble
+                continue;
             if (section.protectedByKeepMarker) {
                 allClassifications.push({
                     source: source.path,
                     level: section.level,
                     title: section.title,
                     startOffset: section.startOffset,
+                    slug: "",
                     kind: "operator-keep",
-                    proposedDecTitle: "",
-                    proposedRationale: "",
-                    conflictsWith: "",
                     failed: false,
                 });
                 continue;
             }
-            jobs.push({ source, section });
+            const bodyMinusHeading = stripLeadingHeading(section.body);
+            if (bodyMinusHeading.length === 0) {
+                // Empty body after heading strip — nothing to classify or fingerprint.
+                continue;
+            }
+            const slug = topicSlug(bodyMinusHeading);
+            const anchor = headingToAnchor(section.title);
+            const job = { source, section, slug, bodyMinusHeading, anchor };
+            jobs.push(job);
+            sectionsBySlug.set(slug, {
+                sourcePath: source.path,
+                sectionTitle: section.title,
+                anchor,
+                bodyMinusHeading,
+            });
         }
     }
+    // ── 2. Classify each non-keep section ────────────────────────────
     if (args.mockClassify !== undefined) {
         for (const [idx, job] of jobs.entries()) {
-            allClassifications.push(args.mockClassify(job.section, job.source));
+            const cls = args.mockClassify(job.section, job.source);
+            // Mock callers may not stamp `slug`; fill it in for them so the
+            // emit filter has something to look up.
+            allClassifications.push({ ...cls, slug: cls.slug.length > 0 ? cls.slug : job.slug });
             args.onSectionProgress?.({ index: idx + 1, total: jobs.length });
         }
     }
@@ -118,7 +174,7 @@ export async function runRulesMerge(args) {
                 const job = jobs[idx];
                 if (job === undefined)
                     continue;
-                const cls = await classifySection(job.source, job.section);
+                const cls = await classifySection(job);
                 allClassifications.push(cls);
                 completed += 1;
                 args.onSectionProgress?.({ index: completed, total });
@@ -127,53 +183,156 @@ export async function runRulesMerge(args) {
         const workers = Array.from({ length: Math.min(CONCURRENCY, jobs.length) }, () => worker());
         await Promise.all(workers);
     }
-    // Persist DEC drafts + conflicts.
-    const decDraftsWritten = [];
-    const conflictRows = [];
-    const existingIds = args.existingDecIds ?? scanExistingDecisionIds(repoRoot);
+    const kindBySlug = new Map();
     for (const cls of allClassifications) {
-        if (cls.kind === "rule-net-new" && cls.proposedDecTitle.length > 0) {
-            const id = computeDecisionId({
-                title: cls.proposedDecTitle,
-                rationale: cls.proposedRationale,
-                capture_source: "init-rules-merge",
-                source_file: cls.source,
-                source_offset: cls.startOffset,
-                raw: cls.title,
-            }, existingIds);
-            existingIds.add(id);
-            if (args.dryRun !== true) {
-                const written = writeDecDraft({
-                    repoRoot,
-                    id,
-                    classification: cls,
-                    generatedAt: nowIso,
-                });
-                decDraftsWritten.push({ id, path: written.relPath, sourceFile: cls.source });
+        if (cls.slug.length > 0)
+            kindBySlug.set(cls.slug, cls.kind);
+    }
+    // ── 3. Read ground state + identify cite-existing slugs ──────────
+    let topicIndex = readTopicIndex(repoRoot);
+    if (Object.keys(topicIndex.topics).length === 0)
+        topicIndex = emptyTopicIndex();
+    let anchorMap = readAnchorMap(repoRoot);
+    if (Object.keys(anchorMap.anchors).length === 0)
+        anchorMap = emptyAnchorMap();
+    const citesEmitted = [];
+    for (const [slug, ctx] of sectionsBySlug) {
+        const entry = topicIndex.topics[slug];
+        if (entry !== undefined && entry.dec_id !== undefined && !ruleFilesSet.has(entry.sot_source)) {
+            // Slug already SoT'd by phase 6 (docs); operator's CLAUDE.md / AGENTS.md
+            // section is a cite of the same fact. No source rewrite — operator's
+            // narrative stays intact. Plan §5.4.1.
+            citesEmitted.push({ id: entry.dec_id, sourceFile: ctx.sourcePath, slug });
+        }
+    }
+    // ── 4. Emit (sot-emit, sot_kind=path) ────────────────────────────
+    const emit = await emitFromTopicIndex({
+        repoRoot,
+        topicIndex,
+        anchorMap,
+        filter: (entry) => entry.dec_id === undefined &&
+            ruleFilesSet.has(entry.sot_source) &&
+            kindBySlug.has(entry.slug) &&
+            isEmittableKind(kindBySlug.get(entry.slug)),
+        classifier: async ({ entry }) => {
+            const ctx = sectionsBySlug.get(entry.slug);
+            const k = kindBySlug.get(entry.slug);
+            if (k === undefined || ctx === undefined)
+                return { kind: "skip", title: "" };
+            if (k === "constraint")
+                return { kind: "constraint", title: ctx.sectionTitle };
+            if (k === "decision" || k === "domain-rule") {
+                return { kind: "decision", title: ctx.sectionTitle };
             }
-            else {
-                decDraftsWritten.push({
-                    id,
-                    path: `.cairn/ground/decisions/_inbox/${id}.draft.md`,
-                    sourceFile: cls.source,
+            return { kind: "skip", title: "" };
+        },
+        sot_kind: "path",
+        capture_source: CAPTURE_SOURCE,
+    });
+    topicIndex = emit.topicIndex;
+    if (args.dryRun !== true) {
+        persistGroundState({
+            repoRoot,
+            topicIndex,
+            anchorMap,
+            bindings: emit.bindings,
+            cache: emit.cache,
+        });
+    }
+    // ── 5. Build emitted records ─────────────────────────────────────
+    const decsWritten = [];
+    const invsWritten = [];
+    for (const rec of emit.emitted) {
+        const ctx = sectionsBySlug.get(rec.slug);
+        const target = {
+            id: rec.id,
+            path: rec.kind === "DEC"
+                ? `.cairn/ground/decisions/${rec.id}.md`
+                : `.cairn/ground/invariants/${rec.id}.md`,
+            sourceFile: ctx?.sourcePath ?? rec.source_file,
+            slug: rec.slug,
+            status: "accepted",
+        };
+        if (rec.kind === "DEC")
+            decsWritten.push(target);
+        else
+            invsWritten.push(target);
+    }
+    // ── 6. Conflict scan ─────────────────────────────────────────────
+    const conflicts = [];
+    if (args.dryRun !== true && emit.emitted.length > 0) {
+        let judgeCalls = 0;
+        for (const rec of emit.emitted) {
+            if (judgeCalls >= CONFLICT_MAX_JUDGE_CALLS)
+                break;
+            const candidates = jaccardCandidates({
+                newId: rec.id,
+                newBody: rec.body,
+                cache: emit.cache,
+                threshold: CONFLICT_JACCARD_THRESHOLD,
+                topK: CONFLICT_MAX_CANDIDATES_PER_EMIT,
+            });
+            for (const cand of candidates) {
+                if (judgeCalls >= CONFLICT_MAX_JUDGE_CALLS)
+                    break;
+                judgeCalls += 1;
+                const candBody = readEmittedBody(repoRoot, cand.id);
+                if (candBody === null)
+                    continue;
+                const verdict = await runContradictionJudge({
+                    newBody: rec.body,
+                    candidateId: cand.id,
+                    candidateBody: candBody,
+                    mock: args.mockContradictionJudge,
                 });
+                if (verdict.verdict === "contradict") {
+                    const conflictPath = writeConflictFile({
+                        repoRoot,
+                        newId: rec.id,
+                        newBody: rec.body,
+                        newSourceFile: rec.source_file,
+                        otherId: cand.id,
+                        otherBody: candBody,
+                        otherSotPath: cand.sot_path,
+                        reasoning: verdict.reasoning,
+                        generatedAt: nowIso,
+                    });
+                    conflicts.push({
+                        newId: rec.id,
+                        otherId: cand.id,
+                        conflictPath,
+                        reasoning: verdict.reasoning,
+                    });
+                }
             }
         }
-        if (cls.kind === "rule-conflict") {
-            conflictRows.push({
-                source_file: cls.source,
-                section_title: cls.title,
-                section_offset: cls.startOffset,
-                conflicts_with: cls.conflictsWith,
-            });
+    }
+    // ── 7. Ledger rebuilds ───────────────────────────────────────────
+    if (args.dryRun !== true) {
+        if (decsWritten.length > 0) {
+            try {
+                writeDecisionsLedger({ repoRoot });
+            }
+            catch (err) {
+                log.warn({ err: err instanceof Error ? err.message : String(err) }, "decisions ledger rebuild failed");
+            }
+        }
+        if (invsWritten.length > 0) {
+            try {
+                writeInvariantsLedger({ repoRoot });
+            }
+            catch (err) {
+                log.warn({ err: err instanceof Error ? err.message : String(err) }, "invariants ledger rebuild failed");
+            }
         }
     }
+    // ── 8. Audit yaml ───────────────────────────────────────────────
     const auditRelPath = `.cairn/baseline/rules-merge-${tsSlug}.yaml`;
     const auditPath = join(repoRoot, auditRelPath);
-    let conflictsPath = null;
     const kindCounts = {
-        "rule-net-new": 0,
-        "rule-conflict": 0,
+        decision: 0,
+        "domain-rule": 0,
+        constraint: 0,
         informational: 0,
         "operator-keep": 0,
     };
@@ -186,58 +345,52 @@ export async function runRulesMerge(args) {
             sources: sources.map((s) => ({ path: s.path, kind: s.kind, size: s.size })),
             sections_total: allClassifications.length,
             kind_counts: kindCounts,
+            decs_written: decsWritten.length,
+            invs_written: invsWritten.length,
+            cites_emitted: citesEmitted.length,
+            conflicts: conflicts.length,
             classifications: allClassifications.map((c) => ({
                 source: c.source,
                 title: c.title,
                 level: c.level,
                 kind: c.kind,
+                slug: c.slug,
                 start_offset: c.startOffset,
-                proposed_dec_title: c.proposedDecTitle,
-                proposed_rationale: c.proposedRationale,
-                conflicts_with: c.conflictsWith,
                 failed: c.failed,
                 ...(c.errorMessage !== undefined ? { error: c.errorMessage } : {}),
             })),
         });
-        if (conflictRows.length > 0) {
-            const rel = `.cairn/baseline/rule-conflicts-${tsSlug}.yaml`;
-            conflictsPath = join(repoRoot, rel);
-            writeYaml(conflictsPath, {
-                run_at: nowIso,
-                conflicts: conflictRows,
-            });
-        }
     }
     log.info({
         sources: sources.length,
         sections: allClassifications.length,
         kindCounts,
-        decDrafts: decDraftsWritten.length,
-        conflicts: conflictRows.length,
+        decs: decsWritten.length,
+        invs: invsWritten.length,
+        cites: citesEmitted.length,
+        conflicts: conflicts.length,
     }, "rules merge complete");
     return {
         sources,
         sectionsTotal: allClassifications.length,
         classifications: allClassifications,
-        decDraftsWritten,
-        conflictsRecorded: conflictRows.length,
-        conflictsPath,
+        decsWritten,
+        invsWritten,
+        citesEmitted,
+        conflicts,
         auditPath,
         auditRelPath,
         kindCounts,
     };
 }
-/* -------------------------------------------------------------------------- */
-/* Classify single section (Haiku)                                            */
-/* -------------------------------------------------------------------------- */
-async function classifySection(source, section) {
-    const body = section.body.length > SECTION_BODY_CAP
-        ? `${section.body.slice(0, SECTION_BODY_CAP)}\n…[truncated]`
-        : section.body;
+async function classifySection(job) {
+    const body = job.bodyMinusHeading.length > SECTION_BODY_CAP
+        ? `${job.bodyMinusHeading.slice(0, SECTION_BODY_CAP)}\n…[truncated]`
+        : job.bodyMinusHeading;
     const prompt = [
-        `Source: ${source.path}`,
-        `Section title: ${section.title || "(preamble)"}`,
-        `Heading level: ${section.level}`,
+        `Source: ${job.source.path}`,
+        `Section title: ${job.section.title || "(preamble)"}`,
+        `Heading level: ${job.section.level}`,
         "",
         "Body:",
         body,
@@ -253,94 +406,235 @@ async function classifySection(source, section) {
         });
         const parsed = result.parsed;
         if (typeof parsed !== "object" || parsed === null) {
-            return informational({
-                source: source.path,
-                section,
-                failed: true,
-                errorMessage: "non-object response",
-            });
+            return informational(job, true, "non-object response");
         }
         const r = parsed;
         const kindRaw = r["kind"];
-        const kind = kindRaw === "rule-net-new" ||
-            kindRaw === "rule-conflict" ||
-            kindRaw === "operator-keep"
+        const kind = kindRaw === "decision" ||
+            kindRaw === "domain-rule" ||
+            kindRaw === "constraint"
             ? kindRaw
             : "informational";
         return {
-            source: source.path,
-            level: section.level,
-            title: section.title,
-            startOffset: section.startOffset,
+            source: job.source.path,
+            level: job.section.level,
+            title: job.section.title,
+            startOffset: job.section.startOffset,
+            slug: job.slug,
             kind,
-            proposedDecTitle: typeof r["proposed_dec_title"] === "string" ? r["proposed_dec_title"] : "",
-            proposedRationale: typeof r["proposed_rationale"] === "string" ? r["proposed_rationale"] : "",
-            conflictsWith: typeof r["conflicts_with"] === "string" ? r["conflicts_with"] : "",
             failed: false,
         };
     }
     catch (err) {
-        return informational({
-            source: source.path,
-            section,
-            failed: true,
-            errorMessage: err instanceof Error ? err.message : String(err),
-        });
+        return informational(job, true, err instanceof Error ? err.message : String(err));
     }
 }
-function informational(args) {
+function informational(job, failed, errorMessage) {
     return {
-        source: args.source,
-        level: args.section.level,
-        title: args.section.title,
-        startOffset: args.section.startOffset,
+        source: job.source.path,
+        level: job.section.level,
+        title: job.section.title,
+        startOffset: job.section.startOffset,
+        slug: job.slug,
         kind: "informational",
-        proposedDecTitle: "",
-        proposedRationale: "",
-        conflictsWith: "",
-        failed: args.failed,
-        ...(args.errorMessage !== undefined ? { errorMessage: args.errorMessage } : {}),
+        failed,
+        ...(errorMessage !== undefined ? { errorMessage } : {}),
     };
 }
-function writeDecDraft(args) {
-    const dir = decisionsDir(args.repoRoot);
-    const inboxDir = join(dir, "_inbox");
-    mkdirSync(inboxDir, { recursive: true });
-    const filename = `${args.id}.draft.md`;
-    const abs = join(inboxDir, filename);
-    const rel = `.cairn/ground/decisions/_inbox/${filename}`;
+function isEmittableKind(kind) {
+    return kind === "decision" || kind === "domain-rule" || kind === "constraint";
+}
+function jaccardCandidates(args) {
+    const newTokens = tokenize(args.newBody, { codeAware: true });
+    const scored = [];
+    for (const [id, entry] of Object.entries(args.cache.entries)) {
+        if (id === args.newId)
+            continue;
+        const candidateTokens = new Set(entry.tokens);
+        const score = jaccard(newTokens, candidateTokens);
+        if (score < args.threshold)
+            continue;
+        scored.push({ id, sot_path: entry.sot_path, similarity: score });
+    }
+    scored.sort((a, b) => b.similarity - a.similarity);
+    return scored.slice(0, args.topK);
+}
+async function runContradictionJudge(args) {
+    if (args.mock !== undefined) {
+        const verdict = await args.mock({
+            newBody: args.newBody,
+            candidateId: args.candidateId,
+            candidateBody: args.candidateBody,
+        });
+        return { verdict, reasoning: `(mock judge → ${verdict})` };
+    }
+    const a = capBody(args.newBody);
+    const b = capBody(args.candidateBody);
+    const prompt = [
+        "Statement A (newly captured by phase 7c):",
+        a,
+        "",
+        `Statement B (already accepted as ${args.candidateId}):`,
+        b,
+        "",
+        "Do these statements logically contradict each other?",
+    ].join("\n");
+    try {
+        const result = await runClaude({
+            tier: "haiku",
+            system: CONTRADICTION_SYSTEM,
+            prompt,
+            jsonSchema: CONTRADICTION_SCHEMA,
+            timeoutMs: PER_CONTRADICTION_TIMEOUT_MS,
+            isolateAmbientContext: true,
+        });
+        const parsed = result.parsed;
+        if (typeof parsed !== "object" || parsed === null) {
+            return { verdict: "unrelated", reasoning: "(non-object judge response)" };
+        }
+        const r = parsed;
+        const verdictRaw = r["verdict"];
+        const verdict = verdictRaw === "contradict" || verdictRaw === "agree"
+            ? verdictRaw
+            : "unrelated";
+        const reasoning = typeof r["reasoning"] === "string" ? r["reasoning"] : "";
+        return { verdict, reasoning };
+    }
+    catch (err) {
+        log.warn({
+            candidateId: args.candidateId,
+            err: err instanceof Error ? err.message : String(err),
+        }, "contradiction judge failed; treating as unrelated");
+        return { verdict: "unrelated", reasoning: "(judge failed)" };
+    }
+}
+function capBody(body) {
+    return body.length > CONFLICT_BODY_CAP
+        ? `${body.slice(0, CONFLICT_BODY_CAP)}\n…[truncated]`
+        : body;
+}
+function writeConflictFile(args) {
+    const dir = conflictsDir(args.repoRoot);
+    mkdirSync(dir, { recursive: true });
+    const filename = `${args.newId}__${args.otherId}.md`;
+    const abs = join(dir, filename);
+    const rel = `.cairn/ground/conflicts/${filename}`;
     const fm = {
-        id: args.id,
-        title: args.classification.proposedDecTitle || `(untitled — from ${args.classification.source})`,
-        type: "adr",
-        status: "draft-from-rules-merge",
-        audience: "dual",
-        generated: args.generatedAt,
-        "verified-at": args.generatedAt,
-        decided_at: args.generatedAt,
-        decided_by: "cairn-init",
-        capture_source: "init-rules-merge",
-        capture_confidence: "medium",
-        sourceFile: args.classification.source,
-        sectionTitle: args.classification.title,
+        a_id: args.newId,
+        a_source: args.newSourceFile,
+        a_capture_source: CAPTURE_SOURCE,
+        b_id: args.otherId,
+        b_sot_path: args.otherSotPath,
+        detected_at: args.generatedAt,
+        detector: "phase-7c-contradiction-judge",
+        severity: "soft",
+        reasoning: args.reasoning,
     };
     const lines = [];
     lines.push("---");
     lines.push(stringifyYaml(fm).trimEnd());
     lines.push("---");
     lines.push("");
-    lines.push(`# ${args.id} — ${fm["title"]}`);
+    lines.push(`# Conflict — ${args.newId} vs ${args.otherId}`);
     lines.push("");
-    lines.push("## Source section");
+    lines.push(`## ${args.newId} (just captured from \`${args.newSourceFile}\`)`);
     lines.push("");
-    lines.push(`From \`${args.classification.source}\`, section "${args.classification.title}".`);
+    lines.push("```");
+    lines.push(args.newBody.trimEnd());
+    lines.push("```");
     lines.push("");
-    lines.push("## Proposed rationale");
+    lines.push(`## ${args.otherId} (already accepted, sot_path: \`${args.otherSotPath}\`)`);
     lines.push("");
-    lines.push(args.classification.proposedRationale);
+    lines.push("```");
+    lines.push(args.otherBody.trimEnd());
+    lines.push("```");
+    lines.push("");
+    lines.push("## Judge reasoning");
+    lines.push("");
+    lines.push(args.reasoning.trim().length > 0 ? args.reasoning.trim() : "(no reasoning provided)");
     lines.push("");
     writeFileSync(abs, lines.join("\n"), "utf8");
-    return { absPath: abs, relPath: rel };
+    return rel;
+}
+function readEmittedBody(repoRoot, id) {
+    const isDec = id.startsWith("DEC-");
+    const dir = isDec
+        ? join(repoRoot, ".cairn", "ground", "decisions")
+        : join(repoRoot, ".cairn", "ground", "invariants");
+    const abs = join(dir, `${id}.md`);
+    if (!existsSync(abs))
+        return null;
+    let raw;
+    try {
+        raw = readFileSync(abs, "utf8");
+    }
+    catch {
+        return null;
+    }
+    // Strip frontmatter — body is everything past the second `---` line.
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n?/);
+    if (fmMatch === null)
+        return raw.trim();
+    return raw.slice(fmMatch[0].length).trim();
+}
+function persistGroundState(args) {
+    const { repoRoot } = args;
+    // Re-read each ground-state file right before write so concurrent
+    // writers (phase 6 / 7b) don't get clobbered. parallel-678 runs the
+    // three phases sequentially under v0.5.0; this merge is defense in
+    // depth for the individual phase tools.
+    const freshTopic = readTopicIndex(repoRoot);
+    const baseTopic = Object.keys(freshTopic.topics).length > 0 ? freshTopic : emptyTopicIndex();
+    for (const [slug, entry] of Object.entries(args.topicIndex.topics)) {
+        baseTopic.topics[slug] = entry;
+    }
+    baseTopic.generated = new Date().toISOString();
+    writeTopicIndex(repoRoot, baseTopic);
+    const freshAnchor = readAnchorMap(repoRoot);
+    const baseAnchor = Object.keys(freshAnchor.anchors).length > 0 ? freshAnchor : emptyAnchorMap();
+    for (const [slug, anchor] of Object.entries(args.anchorMap.anchors)) {
+        baseAnchor.anchors[slug] = anchor;
+    }
+    baseAnchor.generated = new Date().toISOString();
+    writeAnchorMap(repoRoot, baseAnchor);
+    const freshBindings = readSotBindings(repoRoot);
+    const baseBindings = Object.keys(freshBindings.forward).length > 0 ? freshBindings : emptySotBindings();
+    for (const [decId, sotPath] of Object.entries(args.bindings.forward)) {
+        baseBindings.forward[decId] = sotPath;
+    }
+    for (const [sotPath, decIds] of Object.entries(args.bindings.reverse)) {
+        const seen = new Set(baseBindings.reverse[sotPath] ?? []);
+        for (const id of decIds)
+            seen.add(id);
+        baseBindings.reverse[sotPath] = Array.from(seen);
+    }
+    baseBindings.generated = new Date().toISOString();
+    writeSotBindings(repoRoot, baseBindings);
+    const freshCache = readSotCache(repoRoot);
+    let baseCache = Object.keys(freshCache.entries).length > 0 ? freshCache : emptySotCache();
+    for (const [decId, entry] of Object.entries(args.cache.entries)) {
+        baseCache = setSotCacheEntry(baseCache, decId, entry);
+    }
+    baseCache.generated = new Date().toISOString();
+    writeSotCache(repoRoot, baseCache);
+}
+function stripLeadingHeading(body) {
+    // parseRuleSections always pushes the heading line as the first entry
+    // of `body`; strip it so the slug + emitted DEC body match phase 5b's
+    // section fingerprint convention (heading excluded from fingerprint).
+    const newlineIdx = body.indexOf("\n");
+    const trimmedFirst = body.slice(0, newlineIdx === -1 ? body.length : newlineIdx).trim();
+    if (trimmedFirst.startsWith("#")) {
+        return body.slice(newlineIdx === -1 ? body.length : newlineIdx + 1).trim();
+    }
+    return body.trim();
+}
+function headingToAnchor(line) {
+    return line
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-");
 }
 function writeYaml(path, payload) {
     mkdirSync(dirname(path), { recursive: true });