@isaacriehm/cairn-core 0.4.3 → 0.5.0

package/dist/init/source-comments/ingest.js

@@ -1,34 +1,54 @@
 /**
- * Phase 7b orchestrator — walker → classifier → persist.
+ * Phase 7b orchestrator (v0.5.0 SoT model) — walker → classifier →
+ * topic-index lookup → emit-or-cite → strip-replace.
  *
- * Output:
- *   - DEC drafts (one per "rationale" classification with non-empty title)
- *     written to `.cairn/ground/decisions/_inbox/<id>.draft.md`
- *   - Invariant files (one per "constraint" classification with non-empty
- *     suggestedInvariant) written directly to
- *     `.cairn/ground/invariants/INV-<NNNN>.md` with `status: active`. Auto-
- *     promote — the operator can edit / supersede via cairn-attention or
- *     direct edit. Invariants don't go through an `_inbox/` review queue
- *     because the classifier emits hard rules, not policy decisions.
- *   - Canonical-map citations appended to
- *     `.cairn/baseline/canonical-citations-<ISO>.yaml`
- *   - Full audit (every block + classification) at
- *     `.cairn/baseline/source-comments-<ISO>.yaml` — consumed by the
- *     strip-replace stage so it doesn't have to re-walk.
+ * Plan §5.3 algorithm:
+ *   1. Walk source files for prose-bearing comments (existing logic).
+ *   2. Classify via Haiku, kind only — `rationale` / `constraint` /
+ *      `citation` / `license` / `other`. No paraphrased title, no rewritten
+ *      invariant body, no canonical-topic suggestion.
+ *   3. Build a content-fingerprint slug for every rationale + constraint
+ *      block. Look it up in the existing topic-index:
+ *        a. **Cite-existing** — slug already owned by a docs/CLAUDE.md/
+ *           AGENTS.md/rule entry that has been emitted. Strip-replace
+ *           inserts `// §DEC-<existing>` (or `§INV-<existing>`) at the
+ *           comment's offset. No new ground-state file is written.
+ *        b. **Novel** — slug not in the topic-index, or owned by an
+ *           un-emitted entry. Add the block to the topic-index as a
+ *           new source-comment SoT entry; emit a verbatim DEC/INV via
+ *           `emitFromTopicIndex` with `sot_kind: "ledger"`. After emit,
+ *           strip-replace inserts `§DEC-<new>` / `§INV-<new>`.
+ *   4. Auto-promote — every newly-emitted entity ships with
+ *      `status: accepted` (no `_inbox/` draft queue). Plan §1's pivot:
+ *      the inbox-as-blocker was the bug; verbatim bodies + auto-promote
+ *      remove the manual review step.
+ *   5. License + citation + other classifications → no-op (no DEC, no
+ *      strip-replace). License blocks stay verbatim in source.
+ *
+ * Output side-effects (all relative to repoRoot):
+ *   - `.cairn/ground/decisions/<DEC-id>.md`        (one per novel rationale)
+ *   - `.cairn/ground/invariants/<INV-id>.md`       (one per novel constraint)
+ *   - `.cairn/ground/topic-index.yaml`             (extended with source-comment SoT entries)
+ *   - `.cairn/ground/anchor-map.yaml`              (one anchor per novel slug)
+ *   - `.cairn/ground/sot-bindings.yaml`            (forward+reverse for new ids)
+ *   - `.cairn/ground/sot-cache.yaml`               (token cache for Layer A)
+ *   - `.cairn/ground/scope-index.yaml`             (file → ids that landed in source)
+ *   - `.cairn/baseline/source-comments-<ISO>.yaml` (full audit — every block + verdict)
+ *   - source files                                 (stripped & cited per replacement)
  */
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { stringify as stringifyYaml } from "yaml";
-import { computeDecisionId, computeInvariantId, scanExistingDecisionIds, scanExistingInvariantIds, } from "../../decision-capture/id.js";
-import { writeInvariantsLedger } from "../../ground/ledgers.js";
-import { decisionsDir, invariantsDir } from "../../ground/paths.js";
-import { coerceInvariantIds, readScopeIndex, writeScopeIndex, } from "../../ground/scope-index.js";
+import { writeDecisionsLedger, writeInvariantsLedger, } from "../../ground/ledgers.js";
+import { bodyContentHash, deriveLedgerDecId, deriveLedgerInvId, emptyAnchorMap, emptySotBindings, emptySotCache, emptyTopicIndex, readAnchorMap, readSotBindings, readSotCache, readTopicIndex, setAnchor, setSotCacheEntry, setTopic, topicSlug, writeAnchorMap, writeSotBindings, writeSotCache, writeTopicIndex, } from "../../ground/index.js";
+import { coerceDecisionIds, coerceInvariantIds, readScopeIndex, writeScopeIndex, } from "../../ground/scope-index.js";
 import { logger } from "../../logger.js";
-import { scoreDecDraft, scoreInvariant, } from "../../attention/scoring.js";
+import { emitFromTopicIndex } from "../sot-emit.js";
 import { applyStripReplace, formatBareCitation, } from "./strip-replace.js";
 import { classifyBlocks } from "./classify.js";
 import { walkSourceComments } from "./walker.js";
 const log = logger("init.source-comments.ingest");
+const CAPTURE_SOURCE = "init-source-comments";
 /* -------------------------------------------------------------------------- */
 /* Public                                                                     */
 /* -------------------------------------------------------------------------- */
@@ -36,6 +56,7 @@ export async function runSourceCommentsIngestion(args) {
     const repoRoot = args.repoRoot;
     const nowIso = args.nowIso ?? new Date().toISOString();
     const tsSlug = nowIso.replace(/[:.]/g, "-").slice(0, 19);
+    // ── 1. Walk ──────────────────────────────────────────────────────
     const walkOpts = { repoRoot };
     if (args.walkOptions?.fileCap !== undefined) {
         walkOpts.fileCap = args.walkOptions.fileCap;
@@ -44,6 +65,7 @@ export async function runSourceCommentsIngestion(args) {
         walkOpts.onlyFiles = args.walkOptions.onlyFiles;
     }
     const walk = walkSourceComments(walkOpts);
+    // ── 2. Classify (kind only) ─────────────────────────────────────
     const classifyResult = await classifyBlocks({
         blocks: walk.blocks,
         repoRoot,
@@ -64,141 +86,250 @@ export async function runSourceCommentsIngestion(args) {
             continue;
         kindCounts[c.kind] = (kindCounts[c.kind] ?? 0) + 1;
     }
-    const decDraftsWritten = [];
-    const invariantsWritten = [];
-    const invariantProposals = [];
-    const canonicalCitations = [];
-    // Strip-replace items collected during the classification loop —
-    // applied in one batch at the end so a single dirty-check round
-    // covers all files. Each item points at the original constraint
-    // comment block; replacement is `// §INV-NNNN`.
-    const invariantStripItems = [];
-    const existingIds = args.existingDecIds ?? scanExistingDecisionIds(repoRoot);
-    const existingInvariantIds = args.existingInvIds ?? scanExistingInvariantIds(repoRoot);
-    for (let i = 0; i < walk.blocks.length; i++) {
+    // ── 3. Topic-index lookup + extension ────────────────────────────
+    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 resolutionByBlockId = new Map();
+    const skipped = [];
+    const emitKindBySlug = new Map();
+    for (let i = 0; i < walk.blocks.length; i += 1) {
         const block = walk.blocks[i];
         const cls = classifyResult.classifications[i];
         if (block === undefined || cls === undefined)
             continue;
-        if (cls.kind === "rationale" && cls.suggestedDecDraft.length > 0) {
-            const id = computeDecisionId({
-                title: cls.suggestedDecDraft,
-                rationale: block.prose,
-                capture_source: "init-source-comments",
-                source_file: block.file,
-                source_offset: block.startLine,
-                raw: block.raw,
-            }, existingIds);
-            existingIds.add(id);
-            const confidence = args.globs !== undefined
-                ? scoreDecDraft({
-                    sourceFile: block.file,
-                    prose: block.prose,
-                    title: cls.suggestedDecDraft,
-                    rawComment: block.raw,
-                    globs: args.globs,
-                    ...(args.pilotModule !== undefined ? { pilotModule: args.pilotModule } : {}),
-                })
-                : undefined;
-            if (args.dryRun !== true) {
-                const written = writeDecDraft({
-                    repoRoot,
-                    id,
-                    block,
-                    classification: cls,
-                    generatedAt: nowIso,
-                    ...(confidence !== undefined ? { confidence } : {}),
-                });
-                decDraftsWritten.push({
-                    id,
-                    path: written.relPath,
-                    sourceFile: block.file,
-                });
-            }
-            else {
-                decDraftsWritten.push({
-                    id,
-                    path: `.cairn/ground/decisions/_inbox/${id}.draft.md`,
-                    sourceFile: block.file,
-                });
-            }
+        if (cls.kind !== "rationale" && cls.kind !== "constraint") {
+            skipped.push({ blockId: block.id, reason: `kind=${cls.kind}` });
+            continue;
         }
-        if (cls.kind === "constraint" && cls.suggestedInvariant.length > 0) {
-            invariantProposals.push({
-                block_id: block.id,
-                source_file: block.file,
-                start_line: block.startLine,
-                end_line: block.endLine,
-                proposed: cls.suggestedInvariant,
-                canonical_topic: cls.suggestedCanonicalTopic,
+        if (cls.failed) {
+            skipped.push({
+                blockId: block.id,
+                reason: `classifier failed: ${cls.errorMessage ?? "unknown"}`,
             });
-            const invId = computeInvariantId({
-                title: cls.suggestedInvariant,
-                source_file: block.file,
-                source_offset: block.startLine,
-                raw: block.raw,
-            }, existingInvariantIds);
-            existingInvariantIds.add(invId);
-            const invConfidence = args.globs !== undefined
-                ? scoreInvariant({
-                    sourceFile: block.file,
-                    prose: cls.suggestedInvariant,
-                    title: cls.suggestedInvariant.split("\n")[0] ?? "",
-                    rawComment: block.raw,
-                    globs: args.globs,
-                    ...(args.pilotModule !== undefined ? { pilotModule: args.pilotModule } : {}),
-                })
-                : undefined;
-            if (args.dryRun !== true) {
-                const written = writeInvariantFile({
-                    repoRoot,
-                    id: invId,
-                    block,
-                    classification: cls,
-                    generatedAt: nowIso,
-                    ...(invConfidence !== undefined ? { confidence: invConfidence } : {}),
-                });
-                invariantsWritten.push({
-                    id: invId,
-                    path: written.relPath,
-                    sourceFile: block.file,
-                });
-            }
-            else {
-                invariantsWritten.push({
-                    id: invId,
-                    path: `.cairn/ground/invariants/${invId}.md`,
-                    sourceFile: block.file,
-                });
-            }
-            // Stage strip-replace for the source comment so the file ends
-            // up carrying `// §INV-NNNN` (or `# §INV-NNNN` in hash-comment
-            // languages) instead of the original essay block. Run after
-            // the loop so all items go through one applyStripReplace pass.
-            invariantStripItems.push({
+            continue;
+        }
+        const slug = topicSlug(block.prose);
+        const existing = topicIndex.topics[slug];
+        if (existing !== undefined && existing.dec_id !== undefined) {
+            // Cite-existing — another source already owns this topic + emitted.
+            resolutionByBlockId.set(block.id, {
+                kind: "cite",
+                existingId: existing.dec_id,
+                slug,
+            });
+            continue;
+        }
+        const emitKind = cls.kind === "constraint" ? "constraint" : "decision";
+        if (existing !== undefined) {
+            // Slug already in topic-index but not yet emitted (e.g. phase 5b
+            // walked it as some other kind). Keep the existing entry, just
+            // remember the emit kind so the classifier callback below maps
+            // the entry to the right phase-7b verdict.
+            emitKindBySlug.set(slug, emitKind);
+            resolutionByBlockId.set(block.id, { kind: "emit", slug, emitKind });
+            continue;
+        }
+        // Novel topic — register a fresh source-comment entry.
+        const lineRange = [block.startLine, block.endLine];
+        const newEntry = {
+            slug,
+            sot_source: block.file,
+            candidates: [
+                {
+                    file: block.file,
+                    kind: "source-comment",
+                    line_range: lineRange,
+                },
+            ],
+            created_at: nowIso,
+        };
+        topicIndex = setTopic(topicIndex, slug, newEntry);
+        anchorMap = setAnchor(anchorMap, slug, {
+            file: block.file,
+            content_hash: bodyContentHash(block.prose),
+            line_range: lineRange,
+            kind: "source-comment",
+        });
+        emitKindBySlug.set(slug, emitKind);
+        resolutionByBlockId.set(block.id, { kind: "emit", slug, emitKind });
+    }
+    // ── 4. Emit (sot-emit, sot_kind=ledger) ──────────────────────────
+    const emit = await emitFromTopicIndex({
+        repoRoot,
+        topicIndex,
+        anchorMap,
+        filter: (entry) => entry.dec_id === undefined &&
+            isSourceCommentEntry(entry) &&
+            emitKindBySlug.has(entry.slug),
+        classifier: async ({ entry }) => {
+            const k = emitKindBySlug.get(entry.slug);
+            if (k === undefined)
+                return { kind: "skip", title: "" };
+            return { kind: k === "constraint" ? "constraint" : "decision", title: "" };
+        },
+        sot_kind: "ledger",
+        capture_source: CAPTURE_SOURCE,
+        idDeriver: ({ entry, kind }) => {
+            const sot = entry.candidates.find((c) => c.file === entry.sot_source);
+            const range = sot?.line_range;
+            const offset = range !== undefined ? range[0] : 0;
+            const inputs = {
+                source_file: entry.sot_source,
+                source_offset: offset,
+                capture_source: CAPTURE_SOURCE,
+            };
+            return kind === "constraint"
+                ? deriveLedgerInvId(inputs)
+                : deriveLedgerDecId(inputs);
+        },
+    });
+    topicIndex = emit.topicIndex;
+    if (args.dryRun !== true) {
+        persistGroundState({
+            repoRoot,
+            topicIndex,
+            anchorMap,
+            bindings: emit.bindings,
+            cache: emit.cache,
+        });
+    }
+    // ── 5. Build emit / cite records keyed by slug ──────────────────
+    const decsWritten = [];
+    const invsWritten = [];
+    const emittedIdBySlug = new Map();
+    for (const rec of emit.emitted) {
+        emittedIdBySlug.set(rec.slug, rec.id);
+        const target = {
+            id: rec.id,
+            path: rec.kind === "DEC"
+                ? `.cairn/ground/decisions/${rec.id}.md`
+                : `.cairn/ground/invariants/${rec.id}.md`,
+            sourceFile: rec.source_file,
+            slug: rec.slug,
+            status: "accepted",
+        };
+        if (rec.kind === "DEC")
+            decsWritten.push(target);
+        else
+            invsWritten.push(target);
+    }
+    for (const sk of emit.skipped) {
+        skipped.push({ blockId: `slug:${sk.slug}`, reason: sk.reason });
+    }
+    // ── 6. Strip-replace ─────────────────────────────────────────────
+    const citesEmitted = [];
+    const stripItems = [];
+    for (let i = 0; i < walk.blocks.length; i += 1) {
+        const block = walk.blocks[i];
+        if (block === undefined)
+            continue;
+        const resolution = resolutionByBlockId.get(block.id);
+        if (resolution === undefined)
+            continue;
+        const targetId = resolution.kind === "cite"
+            ? resolution.existingId
+            : emittedIdBySlug.get(resolution.slug);
+        if (targetId === undefined) {
+            skipped.push({
                 blockId: block.id,
-                file: block.file,
-                startOffset: block.startOffset,
-                endOffset: block.endOffset,
-                replacement: formatBareCitation(block.lang, invId),
-                expectedRaw: block.raw,
+                reason: `emit produced no id for slug ${resolution.slug}`,
+            });
+            continue;
+        }
+        if (resolution.kind === "cite") {
+            citesEmitted.push({
+                id: targetId,
+                sourceFile: block.file,
+                lineRange: [block.startLine, block.endLine],
+                slug: resolution.slug,
             });
         }
-        if (cls.kind === "citation" && cls.suggestedCanonicalTopic.length > 0) {
-            canonicalCitations.push({
-                block_id: block.id,
-                source_file: block.file,
-                start_line: block.startLine,
-                end_line: block.endLine,
-                topic: cls.suggestedCanonicalTopic,
-                excerpt: block.prose.slice(0, 240),
+        stripItems.push({
+            blockId: block.id,
+            file: block.file,
+            startOffset: block.startOffset,
+            endOffset: block.endOffset,
+            replacement: formatBareCitation(block.lang, targetId),
+            expectedRaw: block.raw,
+        });
+    }
+    let stripFilesModified = 0;
+    let stripItemsApplied = 0;
+    let stripItemsSkipped = 0;
+    let stripOutcomes = [];
+    let stripError = null;
+    if (args.dryRun !== true && stripItems.length > 0) {
+        log.info({
+            items: stripItems.length,
+            files: [...new Set(stripItems.map((it) => it.file))],
+        }, "strip-replace: starting");
+        try {
+            const dirtyDecisions = {};
+            for (const item of stripItems)
+                dirtyDecisions[item.file] = "overwrite";
+            const result = applyStripReplace({
+                repoRoot,
+                items: stripItems,
+                dirtyDecisions,
             });
+            stripFilesModified = result.filesModified;
+            stripItemsApplied = result.itemsApplied;
+            stripItemsSkipped = result.itemsSkipped;
+            stripOutcomes = result.files.map((o) => ({
+                file: o.file,
+                applied: o.itemsApplied,
+                skipped: o.itemsSkipped.map((s) => ({
+                    blockId: s.blockId,
+                    reason: s.reason,
+                })),
+                fileSkipReason: o.fileSkipReason ?? null,
+            }));
+            log.info({
+                filesModified: result.filesModified,
+                itemsApplied: result.itemsApplied,
+                itemsSkipped: result.itemsSkipped,
+            }, "strip-replace: complete");
+            try {
+                updateScopeIndexFromStripItems(repoRoot, stripItems);
+            }
+            catch (err) {
+                log.warn({ err: err instanceof Error ? err.message : String(err) }, "scope-index update from strip items failed");
+            }
+        }
+        catch (err) {
+            stripError = err instanceof Error ? err.message : String(err);
+            log.warn({ err: stripError }, "strip-replace failed");
+        }
+    }
+    else if (stripItems.length === 0) {
+        log.info("strip-replace: no items (no rationale/constraint blocks classified)");
+    }
+    // ── 7. Ledger rebuilds ───────────────────────────────────────────
+    if (args.dryRun !== true) {
+        if (invsWritten.length > 0) {
+            try {
+                writeInvariantsLedger({ repoRoot });
+            }
+            catch (err) {
+                log.warn({ err: err instanceof Error ? err.message : String(err) }, "invariants ledger rebuild failed");
+            }
+        }
+        if (decsWritten.length > 0) {
+            try {
+                writeDecisionsLedger({ repoRoot });
+            }
+            catch (err) {
+                log.warn({ err: err instanceof Error ? err.message : String(err) }, "decisions ledger rebuild failed");
+            }
         }
     }
+    // ── 8. Audit yaml ───────────────────────────────────────────────
     const auditRelPath = `.cairn/baseline/source-comments-${tsSlug}.yaml`;
     const auditPath = join(repoRoot, auditRelPath);
-    let invariantProposalsPath = null;
-    let canonicalCitationsPath = null;
     if (args.dryRun !== true) {
         writeYaml(auditPath, {
             run_at: nowIso,
@@ -213,6 +344,9 @@ export async function runSourceCommentsIngestion(args) {
             batches_failed: classifyResult.batchesFailed,
             input_tokens: classifyResult.inputTokens,
             output_tokens: classifyResult.outputTokens,
+            decs_written: decsWritten.length,
+            invs_written: invsWritten.length,
+            cites_emitted: citesEmitted.length,
             blocks: walk.blocks.map((b, idx) => ({
                 block_id: b.id,
                 file: b.file,
@@ -227,123 +361,36 @@ export async function runSourceCommentsIngestion(args) {
                 end_offset: b.endOffset,
                 raw: b.raw,
                 classification: classifyResult.classifications[idx] ?? null,
+                resolution: serializeResolution(resolutionByBlockId.get(b.id)),
             })),
         });
-        if (invariantProposals.length > 0) {
-            const rel = `.cairn/baseline/invariant-proposals-${tsSlug}.yaml`;
-            invariantProposalsPath = join(repoRoot, rel);
-            writeYaml(invariantProposalsPath, {
-                run_at: nowIso,
-                proposals: invariantProposals,
-            });
-        }
-        if (canonicalCitations.length > 0) {
-            const rel = `.cairn/baseline/canonical-citations-${tsSlug}.yaml`;
-            canonicalCitationsPath = join(repoRoot, rel);
-            writeYaml(canonicalCitationsPath, {
-                run_at: nowIso,
-                citations: canonicalCitations,
-            });
-        }
     }
     log.info({
         files: walk.files.length,
         blocks: walk.blocks.length,
         kindCounts,
-        decDrafts: decDraftsWritten.length,
-        invariantProposals: invariantProposals.length,
-        canonicalCitations: canonicalCitations.length,
+        decs: decsWritten.length,
+        invs: invsWritten.length,
+        cites: citesEmitted.length,
+        stripApplied: stripItemsApplied,
+        stripSkipped: stripItemsSkipped,
         inputTokens: classifyResult.inputTokens,
         outputTokens: classifyResult.outputTokens,
     }, "source-comments ingestion complete");
-    // Rebuild the invariants ledger after writing new INV-<NNNN>.md files so
-    // that §INV-NNNN tokens are resolvable before the strip-replace stage writes
-    // bare citations into source. Lens + MCP read tools resolve through the
-    // ledger, not by re-walking the dir.
-    if (args.dryRun !== true && invariantsWritten.length > 0) {
-        try {
-            writeInvariantsLedger({ repoRoot });
-        }
-        catch (err) {
-            log.warn({ err: err instanceof Error ? err.message : String(err) }, "invariants ledger rebuild failed");
-        }
-    }
-    // Strip the original constraint comment from each source file and
-    // replace with a bare `// §INV-NNNN` cite. Adoption assumes a clean
-    // working tree (init phase 1's preflight); pass `overwrite` for
-    // every file so dirty-skip doesn't bite us — the operator
-    // consented to source mutation when they consented to adoption.
-    let invariantStripFilesModified = 0;
-    let invariantStripItemsApplied = 0;
-    let invariantStripItemsSkipped = 0;
-    let invariantStripOutcomes = [];
-    let invariantStripError = null;
-    if (args.dryRun !== true && invariantStripItems.length > 0) {
-        log.info({
-            items: invariantStripItems.length,
-            files: [...new Set(invariantStripItems.map((it) => it.file))],
-        }, "invariant strip-replace: starting");
-        try {
-            const dirtyDecisions = {};
-            for (const item of invariantStripItems)
-                dirtyDecisions[item.file] = "overwrite";
-            const result = applyStripReplace({
-                repoRoot,
-                items: invariantStripItems,
-                dirtyDecisions,
-            });
-            invariantStripFilesModified = result.filesModified;
-            invariantStripItemsApplied = result.itemsApplied;
-            invariantStripItemsSkipped = result.itemsSkipped;
-            invariantStripOutcomes = result.files.map((o) => ({
-                file: o.file,
-                applied: o.itemsApplied,
-                skipped: o.itemsSkipped.map((s) => ({ blockId: s.blockId, reason: s.reason })),
-                fileSkipReason: o.fileSkipReason ?? null,
-            }));
-            log.info({
-                filesModified: result.filesModified,
-                itemsApplied: result.itemsApplied,
-                itemsSkipped: result.itemsSkipped,
-                outcomes: invariantStripOutcomes,
-            }, "invariant strip-replace: complete");
-            // Now that we know which §INV-NNNN landed in which file, populate
-            // the scope-index for those files. Phase 3 mapper ran before any
-            // invariants existed, so its scope_index entries for these files
-            // had empty `invariants: []` arrays. Without this update the
-            // read-enricher legend's "Invariants in scope" header stays blank
-            // even though the source carries the cite tokens.
-            try {
-                updateScopeIndexFromStripItems(repoRoot, invariantStripItems);
-            }
-            catch (err) {
-                log.warn({ err: err instanceof Error ? err.message : String(err) }, "scope-index update from strip items failed");
-            }
-        }
-        catch (err) {
-            invariantStripError = err instanceof Error ? err.message : String(err);
-            log.warn({ err: invariantStripError }, "invariant strip-replace failed");
-        }
-    }
-    else if (invariantStripItems.length === 0) {
-        log.info("invariant strip-replace: no items (no constraint blocks classified)");
-    }
     return {
         walk,
         classifications: classifyResult.classifications,
-        decDraftsWritten,
-        invariantsWritten,
-        invariantStripFilesModified,
-        invariantStripItemsApplied,
-        invariantStripItemsSkipped,
-        invariantStripOutcomes,
-        invariantStripError,
-        invariantProposalsAdded: invariantProposals.length,
-        canonicalCitationsAdded: canonicalCitations.length,
+        decsWritten,
+        invsWritten,
+        citesEmitted,
+        skipped,
+        stripFilesModified,
+        stripItemsApplied,
+        stripItemsSkipped,
+        stripOutcomes,
+        stripError,
         auditPath,
         auditRelPath,
-        invariantProposalsPath,
-        canonicalCitationsPath,
         inputTokens: classifyResult.inputTokens,
         outputTokens: classifyResult.outputTokens,
         batchesRun: classifyResult.batchesRun,
@@ -352,56 +399,121 @@ export async function runSourceCommentsIngestion(args) {
     };
 }
 /* -------------------------------------------------------------------------- */
-/* Scope-index post-population                                                */
+/* Helpers                                                                    */
 /* -------------------------------------------------------------------------- */
+function isSourceCommentEntry(entry) {
+    const sot = entry.candidates.find((c) => c.file === entry.sot_source);
+    return sot?.kind === "source-comment";
+}
+function serializeResolution(resolution) {
+    if (resolution === undefined)
+        return null;
+    if (resolution.kind === "cite") {
+        return { kind: "cite", existing_id: resolution.existingId, slug: resolution.slug };
+    }
+    return { kind: "emit", slug: resolution.slug, emit_kind: resolution.emitKind };
+}
+function persistGroundState(args) {
+    const { repoRoot } = args;
+    // Re-read each file right before write so we merge with any other phase
+    // that committed concurrently. parallel-678 still uses Promise.allSettled
+    // across phases 6/7b/7c; sequential individual phase tools are race-free.
+    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);
+}
 /**
- * After the strip-replace pass inserts `// §INV-NNNN` cites into source
- * files, fold those IDs into `.cairn/ground/scope-index.yaml`. The Phase
- * 3 mapper that originally seeded scope-index ran before any invariants
- * existed, so its `invariants: []` arrays for these files were correctly
- * empty. Now that the cite tokens are landed, the read-enricher's
- * "Invariants in scope" header should reflect them.
- *
- * Each file's existing invariants array gets unioned with the new IDs,
- * de-duplicated, and re-coerced (defense-in-depth). Files absent from
- * the scope-index get a fresh entry. Decisions arrays are left
- * untouched — DEC strips happen at accept-time via cairn-attention,
- * not in this Phase 7b bulk pass.
+ * After the strip-replace pass inserts cites into source files, fold those
+ * IDs into `.cairn/ground/scope-index.yaml`. Phase 3 mapper that originally
+ * seeded scope-index ran before any DECs/INVs existed, so its `decisions:
+ * []` / `invariants: []` arrays for these files were correctly empty. Now
+ * that the cite tokens are landed, the read-enricher's "in scope" headers
+ * should reflect them.
  */
 function updateScopeIndexFromStripItems(repoRoot, items) {
     if (items.length === 0)
         return;
-    const idsByFile = new Map();
-    const idMatch = /§(INV-[0-9a-f]{7,})/;
+    const decsByFile = new Map();
+    const invsByFile = new Map();
+    const decMatch = /§(DEC-[0-9a-f]{7,})/;
+    const invMatch = /§(INV-[0-9a-f]{7,})/;
     for (const item of items) {
-        const m = item.replacement.match(idMatch);
-        if (m === null)
-            continue;
-        const id = m[1];
-        if (id === undefined)
-            continue;
-        let set = idsByFile.get(item.file);
-        if (set === undefined) {
-            set = new Set();
-            idsByFile.set(item.file, set);
+        const decM = item.replacement.match(decMatch);
+        const invM = item.replacement.match(invMatch);
+        if (decM !== null) {
+            const id = decM[1];
+            if (id !== undefined) {
+                let set = decsByFile.get(item.file);
+                if (set === undefined) {
+                    set = new Set();
+                    decsByFile.set(item.file, set);
+                }
+                set.add(id);
+            }
+        }
+        if (invM !== null) {
+            const id = invM[1];
+            if (id !== undefined) {
+                let set = invsByFile.get(item.file);
+                if (set === undefined) {
+                    set = new Set();
+                    invsByFile.set(item.file, set);
+                }
+                set.add(id);
+            }
         }
-        set.add(id);
     }
-    if (idsByFile.size === 0)
+    if (decsByFile.size === 0 && invsByFile.size === 0)
         return;
     const existing = readScopeIndex(repoRoot) ?? {
         generated: new Date().toISOString(),
         files: {},
     };
-    for (const [file, ids] of idsByFile) {
+    const allFiles = new Set([...decsByFile.keys(), ...invsByFile.keys()]);
+    for (const file of allFiles) {
         const prior = existing.files[file];
-        const merged = coerceInvariantIds([
+        const mergedDecs = coerceDecisionIds([
+            ...(prior?.decisions ?? []),
+            ...(decsByFile.get(file) ?? []),
+        ]);
+        const mergedInvs = coerceInvariantIds([
             ...(prior?.invariants ?? []),
-            ...ids,
+            ...(invsByFile.get(file) ?? []),
         ]);
         const next = {
-            decisions: prior?.decisions ?? [],
-            invariants: merged,
+            decisions: mergedDecs,
+            invariants: mergedInvs,
         };
         if (prior?.unscoped === true)
             next.unscoped = true;
@@ -412,92 +524,11 @@ function updateScopeIndexFromStripItems(repoRoot, items) {
         files: existing.files,
     };
     writeScopeIndex(repoRoot, updated);
-    log.info({ files: idsByFile.size }, "scope-index updated with §INV cite tokens from strip-replace");
-}
-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}`;
-    const fm = {
-        id: args.id,
-        title: args.classification.suggestedDecDraft || `(untitled — from ${args.block.file})`,
-        type: "adr",
-        status: "draft-from-source-comment",
-        audience: "dual",
-        generated: args.generatedAt,
-        "verified-at": args.generatedAt,
-        decided_at: args.generatedAt,
-        decided_by: "cairn-init",
-        capture_source: "init-source-comments",
-        capture_confidence: args.confidence ?? "medium",
-        sourceFile: args.block.file,
-        sourceRange: `${args.block.startLine}-${args.block.endLine}`,
-        blockId: args.block.id,
-        canonicalTopic: args.classification.suggestedCanonicalTopic,
-    };
-    const lines = [];
-    lines.push("---");
-    lines.push(stringifyYaml(fm).trimEnd());
-    lines.push("---");
-    lines.push("");
-    lines.push(`# ${args.id} — ${fm["title"]}`);
-    lines.push("");
-    lines.push("## Source comment");
-    lines.push("");
-    lines.push("```");
-    lines.push(args.block.raw);
-    lines.push("```");
-    lines.push("");
-    lines.push("## Proposed rationale");
-    lines.push("");
-    lines.push(args.block.prose);
-    lines.push("");
-    writeFileSync(abs, lines.join("\n"), "utf8");
-    return { absPath: abs, relPath: rel };
-}
-function writeInvariantFile(args) {
-    const dir = invariantsDir(args.repoRoot);
-    mkdirSync(dir, { recursive: true });
-    const filename = `${args.id}.md`;
-    const abs = join(dir, filename);
-    const rel = `.cairn/ground/invariants/${filename}`;
-    const fm = {
-        id: args.id,
-        title: args.classification.suggestedInvariant.split("\n")[0]?.slice(0, 120) ?? args.id,
-        type: "invariant",
-        status: "active",
-        audience: "dual",
-        generated: args.generatedAt,
-        "verified-at": args.generatedAt,
-        capture_confidence: args.confidence ?? "medium",
-        source_decision: null,
-        sourceFile: args.block.file,
-        sourceRange: `${args.block.startLine}-${args.block.endLine}`,
-        blockId: args.block.id,
-        canonicalTopic: args.classification.suggestedCanonicalTopic,
-    };
-    const lines = [];
-    lines.push("---");
-    lines.push(stringifyYaml(fm).trimEnd());
-    lines.push("---");
-    lines.push("");
-    lines.push(`# §${args.id} — ${fm["title"]}`);
-    lines.push("");
-    lines.push("## Constraint");
-    lines.push("");
-    lines.push(args.classification.suggestedInvariant.trim());
-    lines.push("");
-    lines.push("## Source comment");
-    lines.push("");
-    lines.push("```");
-    lines.push(args.block.raw);
-    lines.push("```");
-    lines.push("");
-    writeFileSync(abs, lines.join("\n"), "utf8");
-    return { absPath: abs, relPath: rel };
+    log.info({
+        files: allFiles.size,
+        decs: Array.from(decsByFile.values()).reduce((acc, s) => acc + s.size, 0),
+        invs: Array.from(invsByFile.values()).reduce((acc, s) => acc + s.size, 0),
+    }, "scope-index updated with cite tokens from strip-replace");
 }
 function writeYaml(path, payload) {
     mkdirSync(dirname(path), { recursive: true });