@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/cases/case-links.js

@@ -0,0 +1,794 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256TombstoneFingerprint = sha256TombstoneFingerprint;
+exports.createCaseLink = createCaseLink;
+exports.revokeCaseLink = revokeCaseLink;
+exports.listActiveCaseLinks = listActiveCaseLinks;
+exports.isWikiTombstoneActive = isWikiTombstoneActive;
+exports.unsuppressWikiTombstone = unsuppressWikiTombstone;
+exports.backfillStructuralLinks = backfillStructuralLinks;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+const sqlite_transaction_js_1 = require("./sqlite-transaction.js");
+const store_js_1 = require("./store.js");
+const TERMINAL_CASE_STATUSES = new Set(['merged', 'archived', 'split']);
+const RECONFIRM_TOKEN_TTL_MS = 10 * 60_000;
+function normalizeNow(value) {
+    return value ?? new Date().toISOString();
+}
+function timestampMs(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : Date.now();
+}
+function createdAtMs(value) {
+    return timestampMs(value);
+}
+function randomLinkId() {
+    return `link_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+}
+function randomTombstoneId() {
+    return `tomb_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+}
+function deterministicLinkId(nonce) {
+    return `link_${sha256Hex(`case-link-reconfirm:v1:${nonce}`).slice(0, 32)}`;
+}
+function sha256Hex(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+}
+function hmacHex(secret, value) {
+    return (0, node_crypto_1.createHmac)('sha256', secret).update(value, 'utf8').digest('hex');
+}
+function decodeSecret(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    if (/^[0-9a-f]+$/i.test(trimmed) && trimmed.length % 2 === 0) {
+        const hex = Buffer.from(trimmed, 'hex');
+        if (hex.length >= 32) {
+            return hex;
+        }
+    }
+    const base64 = Buffer.from(trimmed, 'base64');
+    if (base64.length >= 32) {
+        return base64;
+    }
+    const utf8 = Buffer.from(trimmed, 'utf8');
+    if (utf8.length >= 32) {
+        return utf8;
+    }
+    return null;
+}
+function secretKid(secret) {
+    return (0, node_crypto_1.createHash)('sha256').update(secret).digest('hex').slice(0, 16);
+}
+function currentSecret() {
+    const raw = process.env.MAMA_RECONFIRM_TOKEN_SECRET;
+    const secret = raw ? decodeSecret(raw) : null;
+    if (!secret) {
+        throw new Error('MAMA_RECONFIRM_TOKEN_SECRET must be a 32+ byte base64 or hex secret.');
+    }
+    return { kid: secretKid(secret), secret };
+}
+function verificationSecrets() {
+    const secrets = new Map();
+    const current = currentSecret();
+    secrets.set(current.kid, current.secret);
+    for (const raw of (process.env.MAMA_RECONFIRM_TOKEN_OLD_SECRETS ?? '').split(',')) {
+        const secret = decodeSecret(raw);
+        if (secret) {
+            secrets.set(secretKid(secret), secret);
+        }
+    }
+    return secrets;
+}
+function encodeReconfirmToken(payload, secret) {
+    const payloadJson = (0, canonicalize_js_1.canonicalizeJSON)(payload);
+    const envelope = {
+        kid: payload.kid,
+        payload,
+        signature_hex: hmacHex(secret, payloadJson),
+    };
+    return Buffer.from((0, canonicalize_js_1.canonicalizeJSON)(envelope), 'utf8').toString('base64url');
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function readReconfirmEnvelope(token) {
+    try {
+        const parsed = JSON.parse(Buffer.from(token, 'base64url').toString('utf8'));
+        if (!isRecord(parsed) || !isRecord(parsed.payload)) {
+            return null;
+        }
+        const payload = parsed.payload;
+        if (parsed.kid !== payload.kid ||
+            payload.v !== 1 ||
+            typeof parsed.kid !== 'string' ||
+            typeof parsed.signature_hex !== 'string' ||
+            typeof payload.kid !== 'string' ||
+            typeof payload.nonce !== 'string' ||
+            typeof payload.case_id !== 'string' ||
+            payload.target_kind !== 'case_link' ||
+            typeof payload.target_ref_hash_hex !== 'string' ||
+            typeof payload.current_value_hash_hex !== 'string' ||
+            typeof payload.proposed_value_hash_hex !== 'string' ||
+            typeof payload.confirmed_by !== 'string' ||
+            !(payload.session_id === null || typeof payload.session_id === 'string') ||
+            typeof payload.expires_at !== 'string') {
+            return null;
+        }
+        return {
+            kid: parsed.kid,
+            payload: payload,
+            signature_hex: parsed.signature_hex,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function verifyReconfirmToken(input) {
+    const envelope = readReconfirmEnvelope(input.token);
+    if (!envelope) {
+        return null;
+    }
+    const secret = verificationSecrets().get(envelope.kid);
+    if (!secret) {
+        return null;
+    }
+    const expected = Buffer.from(hmacHex(secret, (0, canonicalize_js_1.canonicalizeJSON)(envelope.payload)), 'hex');
+    const actual = Buffer.from(envelope.signature_hex, 'hex');
+    if (actual.length !== expected.length || !(0, node_crypto_1.timingSafeEqual)(actual, expected)) {
+        return null;
+    }
+    const expiresAtMs = Date.parse(envelope.payload.expires_at);
+    if (!Number.isFinite(expiresAtMs) || expiresAtMs <= timestampMs(input.now)) {
+        return null;
+    }
+    if (envelope.payload.case_id !== input.case_id ||
+        envelope.payload.target_ref_hash_hex !== input.target_ref_hash_hex ||
+        envelope.payload.proposed_value_hash_hex !== input.proposed_value_hash_hex ||
+        envelope.payload.confirmed_by !== input.confirmed_by ||
+        envelope.payload.session_id !== input.session_id) {
+        return null;
+    }
+    return envelope.payload;
+}
+function buildRequiresReconfirm(input) {
+    const secret = currentSecret();
+    const expiresAt = new Date(timestampMs(input.now) + RECONFIRM_TOKEN_TTL_MS).toISOString();
+    const payload = {
+        v: 1,
+        kid: secret.kid,
+        nonce: (0, node_crypto_1.randomUUID)(),
+        case_id: input.case_id,
+        target_kind: 'case_link',
+        target_ref_hash_hex: input.target_ref_hash_hex,
+        current_value_hash_hex: sha256Hex(input.current_value_json),
+        proposed_value_hash_hex: sha256Hex(input.proposed_new_value_json),
+        confirmed_by: input.confirmed_by,
+        session_id: input.session_id,
+        expires_at: expiresAt,
+    };
+    return {
+        kind: 'requires_reconfirm',
+        code: 'case.correction_requires_reconfirm',
+        case_id: input.case_id,
+        target_kind: 'case_link',
+        target_ref_json: input.target_ref_json,
+        current_value_json: input.current_value_json,
+        old_value_json: input.old_value_json,
+        proposed_new_value_json: input.proposed_new_value_json,
+        reconfirm_token: encodeReconfirmToken(payload, secret.secret),
+        reconfirm_token_expires_at: expiresAt,
+        message: 'The target changed since the viewed snapshot. Reconfirm against the current value.',
+    };
+}
+function parseJsonValue(value) {
+    return JSON.parse(value);
+}
+function canonicalExpectedJson(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    return (0, canonicalize_js_1.canonicalizeJSON)(parseJsonValue(value));
+}
+function toBuffer(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    throw new Error('Expected SQLite BLOB value to be a Buffer.');
+}
+function nullableString(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return String(value);
+}
+function nullableNumber(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+}
+function mapCaseLinkRow(row) {
+    const fingerprint = toBuffer(row.source_ref_fingerprint);
+    return {
+        link_id: String(row.link_id),
+        case_id_from: String(row.case_id_from),
+        case_id_to: String(row.case_id_to),
+        link_type: String(row.link_type),
+        created_at: String(row.created_at),
+        created_by: String(row.created_by),
+        confidence: nullableNumber(row.confidence),
+        reason_json: nullableString(row.reason_json),
+        source_kind: String(row.source_kind),
+        source_ref: nullableString(row.source_ref),
+        source_ref_fingerprint: fingerprint,
+        source_ref_fingerprint_hex: fingerprint ? fingerprint.toString('hex') : null,
+        revoked_at: nullableString(row.revoked_at),
+        revoked_by: nullableString(row.revoked_by),
+        revoke_reason: nullableString(row.revoke_reason),
+    };
+}
+function placeholders(values) {
+    if (values.length === 0) {
+        throw new Error('Cannot build SQL IN clause for an empty value list.');
+    }
+    return values.map(() => '?').join(', ');
+}
+function loadCase(adapter, caseId) {
+    const row = adapter
+        .prepare(`
+        SELECT case_id, status, canonical_case_id, split_from_case_id, title,
+               current_wiki_path, updated_at
+        FROM case_truth
+        WHERE case_id = ?
+      `)
+        .get(caseId);
+    return row ?? null;
+}
+function caseSnapshot(row) {
+    return {
+        case_id: row.case_id,
+        status: row.status,
+        canonical_case_id: row.canonical_case_id,
+        split_from_case_id: row.split_from_case_id,
+        title: row.title,
+        current_wiki_path: row.current_wiki_path,
+        updated_at: row.updated_at,
+    };
+}
+function reasonJson(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return (0, canonicalize_js_1.canonicalizeJSON)(value);
+}
+function caseLinkTargetRefJson(input) {
+    return (0, canonicalize_js_1.canonicalizeJSON)({
+        kind: 'case_link',
+        case_id_from: input.case_id_from,
+        case_id_to: input.case_id_to,
+        link_type: input.link_type,
+    });
+}
+function activeLinkForTriple(adapter, input) {
+    const row = adapter
+        .prepare(`
+        SELECT *
+        FROM case_links
+        WHERE case_id_from = ?
+          AND case_id_to = ?
+          AND link_type = ?
+          AND revoked_at IS NULL
+        LIMIT 1
+      `)
+        .get(input.case_id_from, input.case_id_to, input.link_type);
+    return row ? mapCaseLinkRow(row) : null;
+}
+function linkExistsById(adapter, linkId) {
+    const row = adapter.prepare('SELECT link_id FROM case_links WHERE link_id = ?').get(linkId);
+    return Boolean(row);
+}
+function activeTombstoneRow(adapter, input, fingerprint = sha256TombstoneFingerprint(input)) {
+    const row = adapter
+        .prepare(`
+        SELECT tombstone_id
+        FROM case_links_revoked_wiki_tombstones
+        WHERE case_id_from = ?
+          AND case_id_to = ?
+          AND link_type = ?
+          AND source_ref_fingerprint = ?
+          AND unsuppressed_at IS NULL
+        LIMIT 1
+      `)
+        .get(input.source_case_id, input.target_case_id, input.link_type, fingerprint);
+    return row ?? null;
+}
+function unsuppressWikiTombstoneInTransaction(adapter, input, fingerprint = sha256TombstoneFingerprint(input)) {
+    const result = adapter
+        .prepare(`
+        UPDATE case_links_revoked_wiki_tombstones
+        SET unsuppressed_at = ?, unsuppressed_by = ?
+        WHERE case_id_from = ?
+          AND case_id_to = ?
+          AND link_type = ?
+          AND source_ref_fingerprint = ?
+          AND unsuppressed_at IS NULL
+      `)
+        .run(input.now, input.unsuppressed_by, input.source_case_id, input.target_case_id, input.link_type, fingerprint);
+    return result.changes;
+}
+function currentCreateValueJson(adapter, input, sourceCase, targetCase) {
+    return (0, canonicalize_js_1.canonicalizeJSON)({
+        source_case: caseSnapshot(sourceCase),
+        target_case: caseSnapshot(targetCase),
+        target_ref: {
+            kind: 'case_link',
+            case_id_from: input.case_id_from,
+            case_id_to: input.case_id_to,
+            link_type: input.link_type,
+        },
+        active_link: activeLinkForTriple(adapter, input),
+        wiki_tombstone_active: isWikiTombstoneActive(adapter, {
+            source_case_id: input.case_id_from,
+            target_case_id: input.case_id_to,
+            link_type: input.link_type,
+        }),
+    });
+}
+function proposedCreateValueJson(input) {
+    return (0, canonicalize_js_1.canonicalizeJSON)({
+        case_id_from: input.case_id_from,
+        case_id_to: input.case_id_to,
+        link_type: input.link_type,
+        confidence: input.confidence ?? null,
+        reason_json: reasonJson(input.reason_json),
+        source_kind: input.source_kind ?? 'manual',
+        source_ref: input.source_ref ?? null,
+    });
+}
+function currentRevokeValueJson(row) {
+    return (0, canonicalize_js_1.canonicalizeJSON)({
+        link_id: row.link_id,
+        case_id_from: row.case_id_from,
+        case_id_to: row.case_id_to,
+        link_type: row.link_type,
+        revoked_at: row.revoked_at,
+        revoked_by: row.revoked_by,
+        revoke_reason: row.revoke_reason,
+        source_kind: row.source_kind,
+        source_ref_fingerprint_hex: row.source_ref_fingerprint_hex,
+    });
+}
+function insertMemoryEvent(input) {
+    input.adapter
+        .prepare(`
+        INSERT INTO memory_events (
+          event_id, event_type, actor, source_turn_id, memory_id, topic,
+          scope_refs, evidence_refs, reason, created_at
+        )
+        VALUES (?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?)
+      `)
+        .run(`me_${(0, node_crypto_1.randomUUID)()}`, input.event_type, input.actor, `case:${input.case_id}`, (0, canonicalize_js_1.canonicalizeJSON)([{ type: 'case', id: input.case_id }]), (0, canonicalize_js_1.canonicalizeJSON)([input.link_id]), (0, canonicalize_js_1.canonicalizeJSON)(input.reason), createdAtMs(input.now));
+}
+function sha256TombstoneFingerprint(input) {
+    return (0, node_crypto_1.createHash)('sha256')
+        .update((0, canonicalize_js_1.canonicalizeJSON)({
+        source_case_id: input.source_case_id,
+        target_case_id: input.target_case_id,
+        link_type: input.link_type,
+    }), 'utf8')
+        .digest();
+}
+function createCaseLink(adapter, input) {
+    const linkAdapter = adapter;
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(linkAdapter, () => {
+        const now = normalizeNow(input.now);
+        const sourceKind = input.source_kind ?? 'manual';
+        if (input.case_id_from === input.case_id_to) {
+            return {
+                kind: 'rejected',
+                code: 'case.self_link',
+                message: 'Case links cannot point to the same case.',
+                case_id: input.case_id_from,
+            };
+        }
+        const sourceCase = loadCase(linkAdapter, input.case_id_from);
+        if (!sourceCase) {
+            return {
+                kind: 'rejected',
+                code: 'case.precompile_gap',
+                message: `Source case ${input.case_id_from} does not exist.`,
+                case_id: input.case_id_from,
+            };
+        }
+        const targetCase = loadCase(linkAdapter, input.case_id_to);
+        if (!targetCase) {
+            return {
+                kind: 'rejected',
+                code: 'case.precompile_gap',
+                message: `Target case ${input.case_id_to} does not exist.`,
+                case_id: input.case_id_to,
+            };
+        }
+        for (const row of [sourceCase, targetCase]) {
+            if (TERMINAL_CASE_STATUSES.has(row.status)) {
+                return {
+                    kind: 'rejected',
+                    code: 'case.terminal_status',
+                    message: `Case links cannot target terminal case status ${row.status}.`,
+                    case_id: row.case_id,
+                };
+            }
+        }
+        const targetRefJson = caseLinkTargetRefJson(input);
+        const targetRefHashHex = sha256Hex(targetRefJson);
+        const currentValueJson = currentCreateValueJson(linkAdapter, input, sourceCase, targetCase);
+        const canonicalExpectedCurrent = canonicalExpectedJson(input.expected_current_value_json);
+        const proposedNewValueJson = proposedCreateValueJson(input);
+        let linkId = input.link_id ?? randomLinkId();
+        if (canonicalExpectedCurrent !== null && canonicalExpectedCurrent !== currentValueJson) {
+            const token = input.reconfirm_token ?? null;
+            if (!token) {
+                return buildRequiresReconfirm({
+                    case_id: input.case_id_from,
+                    target_ref_json: targetRefJson,
+                    target_ref_hash_hex: targetRefHashHex,
+                    current_value_json: currentValueJson,
+                    old_value_json: input.expected_current_value_json ?? null,
+                    proposed_new_value_json: proposedNewValueJson,
+                    confirmed_by: input.created_by,
+                    session_id: input.session_id ?? null,
+                    now,
+                });
+            }
+            const payload = verifyReconfirmToken({
+                token,
+                case_id: input.case_id_from,
+                target_ref_hash_hex: targetRefHashHex,
+                proposed_value_hash_hex: sha256Hex(proposedNewValueJson),
+                confirmed_by: input.created_by,
+                session_id: input.session_id ?? null,
+                now,
+            });
+            if (!payload || payload.current_value_hash_hex !== sha256Hex(currentValueJson)) {
+                return buildRequiresReconfirm({
+                    case_id: input.case_id_from,
+                    target_ref_json: targetRefJson,
+                    target_ref_hash_hex: targetRefHashHex,
+                    current_value_json: currentValueJson,
+                    old_value_json: input.expected_current_value_json ?? null,
+                    proposed_new_value_json: proposedNewValueJson,
+                    confirmed_by: input.created_by,
+                    session_id: input.session_id ?? null,
+                    now,
+                });
+            }
+            linkId = deterministicLinkId(payload.nonce);
+            if (linkExistsById(linkAdapter, linkId)) {
+                return {
+                    kind: 'rejected',
+                    code: 'case.reconfirm_token_replayed',
+                    message: 'Reconfirm token has already been consumed.',
+                    case_id: input.case_id_from,
+                };
+            }
+        }
+        const fingerprint = toBuffer(input.source_ref_fingerprint) ??
+            sha256TombstoneFingerprint({
+                source_case_id: input.case_id_from,
+                target_case_id: input.case_id_to,
+                link_type: input.link_type,
+            });
+        if (sourceKind === 'manual') {
+            if (activeLinkForTriple(linkAdapter, input)) {
+                return {
+                    kind: 'rejected',
+                    code: 'case.correction_active_conflict',
+                    message: 'An active case link already exists for this relationship.',
+                    case_id: input.case_id_from,
+                };
+            }
+            const tombstone = activeTombstoneRow(linkAdapter, {
+                source_case_id: input.case_id_from,
+                target_case_id: input.case_id_to,
+                link_type: input.link_type,
+            }, fingerprint);
+            if (tombstone && input.unsuppress_wiki_tombstone !== true) {
+                return {
+                    kind: 'rejected',
+                    code: 'case.wiki_tombstone_conflict',
+                    message: 'A revoked wiki-emitted link tombstone exists for this relationship.',
+                    case_id: input.case_id_from,
+                };
+            }
+            if (tombstone) {
+                unsuppressWikiTombstoneInTransaction(linkAdapter, {
+                    source_case_id: input.case_id_from,
+                    target_case_id: input.case_id_to,
+                    link_type: input.link_type,
+                    unsuppressed_by: input.created_by,
+                    now,
+                }, fingerprint);
+            }
+        }
+        if (activeLinkForTriple(linkAdapter, input)) {
+            return {
+                kind: 'rejected',
+                code: 'case.correction_active_conflict',
+                message: 'An active case link already exists for this relationship.',
+                case_id: input.case_id_from,
+            };
+        }
+        linkAdapter
+            .prepare(`
+          INSERT INTO case_links (
+            link_id, case_id_from, case_id_to, link_type, created_at, created_by,
+            confidence, reason_json, source_kind, source_ref, source_ref_fingerprint,
+            revoked_at, revoked_by, revoke_reason
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)
+        `)
+            .run(linkId, input.case_id_from, input.case_id_to, input.link_type, now, input.created_by, input.confidence ?? null, reasonJson(input.reason_json), sourceKind, input.source_ref ?? null, fingerprint);
+        insertMemoryEvent({
+            adapter: linkAdapter,
+            event_type: 'case.link_created',
+            actor: input.created_by,
+            case_id: input.case_id_from,
+            link_id: linkId,
+            reason: {
+                case_id_from: input.case_id_from,
+                case_id_to: input.case_id_to,
+                link_type: input.link_type,
+                source_kind: sourceKind,
+            },
+            now,
+        });
+        return {
+            kind: 'created',
+            link_id: linkId,
+            source_ref_fingerprint_hex: fingerprint.toString('hex'),
+        };
+    });
+}
+function revokeCaseLink(adapter, input) {
+    const linkAdapter = adapter;
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(linkAdapter, () => {
+        const now = normalizeNow(input.now);
+        const raw = linkAdapter
+            .prepare('SELECT * FROM case_links WHERE link_id = ?')
+            .get(input.link_id);
+        if (!raw) {
+            return {
+                kind: 'rejected',
+                code: 'case.case_link_not_found',
+                message: `Case link ${input.link_id} was not found.`,
+                link_id: input.link_id,
+            };
+        }
+        const row = mapCaseLinkRow(raw);
+        if (row.revoked_at !== null) {
+            return {
+                kind: 'rejected',
+                code: 'case.case_link_not_found',
+                message: `Case link ${input.link_id} is already revoked.`,
+                link_id: input.link_id,
+            };
+        }
+        if (row.source_kind === 'wiki_compiler' && !row.source_ref_fingerprint) {
+            return {
+                kind: 'rejected',
+                code: 'case.wiki_tombstone_fingerprint_missing',
+                message: 'Cannot revoke a wiki compiler link without its stored source_ref_fingerprint.',
+                link_id: input.link_id,
+            };
+        }
+        const targetRefJson = caseLinkTargetRefJson(row);
+        const targetRefHashHex = sha256Hex(targetRefJson);
+        const currentValueJson = currentRevokeValueJson(row);
+        const canonicalExpectedCurrent = canonicalExpectedJson(input.expected_current_value_json);
+        const proposedNewValueJson = (0, canonicalize_js_1.canonicalizeJSON)({
+            link_id: input.link_id,
+            revoked_at: now,
+            revoked_by: input.revoked_by,
+            revoke_reason: input.revoke_reason,
+        });
+        if (canonicalExpectedCurrent !== null && canonicalExpectedCurrent !== currentValueJson) {
+            const token = input.reconfirm_token ?? null;
+            if (!token) {
+                return buildRequiresReconfirm({
+                    case_id: row.case_id_from,
+                    target_ref_json: targetRefJson,
+                    target_ref_hash_hex: targetRefHashHex,
+                    current_value_json: currentValueJson,
+                    old_value_json: input.expected_current_value_json ?? null,
+                    proposed_new_value_json: proposedNewValueJson,
+                    confirmed_by: input.revoked_by,
+                    session_id: input.session_id ?? null,
+                    now,
+                });
+            }
+            const payload = verifyReconfirmToken({
+                token,
+                case_id: row.case_id_from,
+                target_ref_hash_hex: targetRefHashHex,
+                proposed_value_hash_hex: sha256Hex(proposedNewValueJson),
+                confirmed_by: input.revoked_by,
+                session_id: input.session_id ?? null,
+                now,
+            });
+            if (!payload || payload.current_value_hash_hex !== sha256Hex(currentValueJson)) {
+                return buildRequiresReconfirm({
+                    case_id: row.case_id_from,
+                    target_ref_json: targetRefJson,
+                    target_ref_hash_hex: targetRefHashHex,
+                    current_value_json: currentValueJson,
+                    old_value_json: input.expected_current_value_json ?? null,
+                    proposed_new_value_json: proposedNewValueJson,
+                    confirmed_by: input.revoked_by,
+                    session_id: input.session_id ?? null,
+                    now,
+                });
+            }
+        }
+        linkAdapter
+            .prepare(`
+          UPDATE case_links
+          SET revoked_at = ?, revoked_by = ?, revoke_reason = ?
+          WHERE link_id = ?
+            AND revoked_at IS NULL
+        `)
+            .run(now, input.revoked_by, input.revoke_reason, input.link_id);
+        if (row.source_kind === 'wiki_compiler' && row.source_ref_fingerprint) {
+            linkAdapter
+                .prepare(`
+            INSERT OR IGNORE INTO case_links_revoked_wiki_tombstones (
+              tombstone_id, case_id_from, case_id_to, link_type, source_ref_fingerprint,
+              source_ref, created_at, created_by, revoke_reason, unsuppressed_at,
+              unsuppressed_by
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL)
+          `)
+                .run(randomTombstoneId(), row.case_id_from, row.case_id_to, row.link_type, row.source_ref_fingerprint, row.source_ref ?? `case_link:${row.link_id}`, now, input.revoked_by, input.revoke_reason);
+        }
+        insertMemoryEvent({
+            adapter: linkAdapter,
+            event_type: 'case.link_revoked',
+            actor: input.revoked_by,
+            case_id: row.case_id_from,
+            link_id: input.link_id,
+            reason: {
+                case_id_from: row.case_id_from,
+                case_id_to: row.case_id_to,
+                link_type: row.link_type,
+                revoke_reason: input.revoke_reason,
+                tombstone_written: row.source_kind === 'wiki_compiler',
+            },
+            now,
+        });
+        return { kind: 'revoked', link_id: input.link_id };
+    });
+}
+function listActiveCaseLinks(adapter, caseId) {
+    const linkAdapter = adapter;
+    const resolution = (0, store_js_1.resolveCanonicalCaseChain)(linkAdapter, caseId);
+    const chain = (0, store_js_1.expandCaseChainForAssembly)(linkAdapter, resolution.terminal_case_id, resolution.chain);
+    if (chain.length === 0) {
+        return {
+            terminal_case_id: resolution.terminal_case_id,
+            resolved_via_case_id: resolution.resolved_via_case_id,
+            chain,
+            links: [],
+        };
+    }
+    const rows = linkAdapter
+        .prepare(`
+        SELECT *
+        FROM case_links
+        WHERE revoked_at IS NULL
+          AND (
+            case_id_from IN (${placeholders(chain)})
+            OR case_id_to IN (${placeholders(chain)})
+          )
+        ORDER BY created_at DESC, link_id ASC
+      `)
+        .all(...chain, ...chain);
+    return {
+        terminal_case_id: resolution.terminal_case_id,
+        resolved_via_case_id: resolution.resolved_via_case_id,
+        chain,
+        links: rows.map(mapCaseLinkRow),
+    };
+}
+function isWikiTombstoneActive(adapter, input) {
+    return Boolean(activeTombstoneRow(adapter, input));
+}
+function unsuppressWikiTombstone(adapter, input) {
+    const linkAdapter = adapter;
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(linkAdapter, () => ({
+        kind: 'unsuppressed',
+        unsuppressed_count: unsuppressWikiTombstoneInTransaction(linkAdapter, {
+            source_case_id: input.source_case_id,
+            target_case_id: input.target_case_id,
+            link_type: input.link_type,
+            unsuppressed_by: input.unsuppressed_by,
+            now: normalizeNow(input.now),
+        }),
+    }));
+}
+function backfillStructuralLinks(adapter) {
+    const linkAdapter = adapter;
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(linkAdapter, () => {
+        const duplicateResult = linkAdapter
+            .prepare(`
+          INSERT OR IGNORE INTO case_links (
+            link_id, case_id_from, case_id_to, link_type, created_at, created_by,
+            confidence, reason_json, source_kind, source_ref, source_ref_fingerprint,
+            revoked_at, revoked_by, revoke_reason
+          )
+          SELECT
+            'backfill:canonical:' || case_id,
+            case_id,
+            canonical_case_id,
+            'duplicate-of',
+            updated_at,
+            'system',
+            NULL,
+            '{"authority":"case_truth.canonical_case_id"}',
+            'system_backfill',
+            'case_truth.canonical_case_id',
+            NULL,
+            NULL,
+            NULL,
+            NULL
+          FROM case_truth
+          WHERE canonical_case_id IS NOT NULL
+            AND canonical_case_id <> case_id
+        `)
+            .run();
+        const splitResult = linkAdapter
+            .prepare(`
+          INSERT OR IGNORE INTO case_links (
+            link_id, case_id_from, case_id_to, link_type, created_at, created_by,
+            confidence, reason_json, source_kind, source_ref, source_ref_fingerprint,
+            revoked_at, revoked_by, revoke_reason
+          )
+          SELECT
+            'backfill:split:' || case_id,
+            case_id,
+            split_from_case_id,
+            'subcase-of',
+            updated_at,
+            'system',
+            NULL,
+            '{"authority":"case_truth.split_from_case_id"}',
+            'system_backfill',
+            'case_truth.split_from_case_id',
+            NULL,
+            NULL,
+            NULL,
+            NULL
+          FROM case_truth
+          WHERE split_from_case_id IS NOT NULL
+            AND split_from_case_id <> case_id
+        `)
+            .run();
+        return {
+            duplicate_of_inserted: duplicateResult.changes,
+            subcase_of_inserted: splitResult.changes,
+        };
+    });
+}
+//# sourceMappingURL=case-links.js.map