@jungjaehoon/mama-core 1.8.1 → 2.0.0

package/dist/cases/freshness.d.ts

@@ -1,57 +0,0 @@
-import type { DatabaseAdapter } from '../db-manager.js';
-export type CaseFreshnessState = 'fresh' | 'stale' | 'drifted' | 'unknown';
-export interface CaseFreshnessReason {
-    code: 'missing_compile' | 'activity_after_compile' | 'state_update_after_compile' | 'wiki_index_missing' | 'timestamps_absent';
-    penalty: number;
-    detail?: string;
-}
-export interface CaseFreshnessCalculation {
-    freshness_score: number;
-    freshness_state: CaseFreshnessState;
-    freshness_score_is_drifted: 0 | 1;
-    freshness_drift_threshold: number;
-    reasons: CaseFreshnessReason[];
-    freshness_reason_json: string;
-}
-export interface CaseFreshnessResult extends CaseFreshnessCalculation {
-    case_id: string;
-    terminal_case_id: string;
-    resolved_via_case_id: string | null;
-    chain: string[];
-    freshness_checked_at: string;
-    changed: boolean;
-}
-export interface SweepCaseFreshnessInput {
-    case_ids?: string[];
-    now?: string;
-    drift_threshold?: number;
-}
-export interface SweepCaseFreshnessResult {
-    checked: number;
-    fresh: number;
-    stale: number;
-    drifted: number;
-    drifted_case_ids: string[];
-    results: CaseFreshnessResult[];
-    rejected?: Array<{
-        case_id: string;
-        code: 'case.terminal_status';
-        message: string;
-    }>;
-}
-export declare function calculateCaseFreshness(input: {
-    last_activity_at?: string | null;
-    state_updated_at?: string | null;
-    compiled_at?: string | null;
-    wiki_index_updated_at?: string | null;
-    current_wiki_path?: string | null;
-    drift_threshold?: number;
-    now?: string;
-}): CaseFreshnessCalculation;
-export declare function sweepCaseFreshness(adapter: DatabaseAdapter, input?: SweepCaseFreshnessInput): SweepCaseFreshnessResult;
-export declare function listDriftedCases(adapter: DatabaseAdapter): Array<{
-    case_id: string;
-    freshness_score: number;
-    freshness_checked_at: string | null;
-}>;
-//# sourceMappingURL=freshness.d.ts.map

package/dist/cases/freshness.js

@@ -1,283 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateCaseFreshness = calculateCaseFreshness;
-exports.sweepCaseFreshness = sweepCaseFreshness;
-exports.listDriftedCases = listDriftedCases;
-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 DEFAULT_DRIFT_THRESHOLD = 0.5;
-const TERMINAL_CASE_STATUSES = new Set(['merged', 'archived', 'split']);
-function parseRequiredTimestamp(value, errorMessage) {
-    const parsed = Date.parse(value);
-    if (!Number.isFinite(parsed)) {
-        throw new Error(errorMessage);
-    }
-    return parsed;
-}
-function normalizeNow(value) {
-    if (value === undefined) {
-        return new Date().toISOString();
-    }
-    return new Date(parseRequiredTimestamp(value, 'invalid now timestamp')).toISOString();
-}
-function createdAtMs(value) {
-    return parseRequiredTimestamp(value, 'invalid now timestamp');
-}
-function timestampMs(value) {
-    if (!value) {
-        return null;
-    }
-    const parsed = Date.parse(value);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function normalizedThreshold(value) {
-    if (value === undefined) {
-        return DEFAULT_DRIFT_THRESHOLD;
-    }
-    if (!Number.isFinite(value) || value < 0 || value > 1) {
-        throw new Error('freshness drift_threshold must be between 0 and 1.');
-    }
-    return Number(value.toFixed(4));
-}
-function score(value) {
-    return Number(Math.max(0, Math.min(1, value)).toFixed(4));
-}
-function resolveChain(adapter, caseId) {
-    try {
-        return (0, store_js_1.resolveCanonicalCaseChain)(adapter, caseId);
-    }
-    catch (error) {
-        if (error instanceof Error && /not found/i.test(error.message)) {
-            return null;
-        }
-        throw error;
-    }
-}
-function loadCase(adapter, caseId) {
-    const row = adapter
-        .prepare(`
-        SELECT case_id, status, current_wiki_path, last_activity_at, state_updated_at,
-               compiled_at, freshness_score, freshness_state, freshness_score_is_drifted,
-               freshness_drift_threshold, freshness_checked_at, freshness_reason_json
-        FROM case_truth
-        WHERE case_id = ?
-      `)
-        .get(caseId);
-    return row ?? null;
-}
-function wikiIndexUpdatedAt(adapter, caseId) {
-    const row = adapter
-        .prepare(`
-        SELECT updated_at
-        FROM wiki_page_index
-        WHERE case_id = ?
-          AND page_type = 'case'
-        ORDER BY updated_at DESC, page_id ASC
-        LIMIT 1
-      `)
-        .get(caseId);
-    return row?.updated_at ?? null;
-}
-function allCandidateCaseIds(adapter) {
-    const rows = adapter
-        .prepare(`
-        SELECT case_id
-        FROM case_truth
-        WHERE status NOT IN ('merged','archived','split')
-        ORDER BY case_id ASC
-      `)
-        .all();
-    return rows.map((row) => row.case_id);
-}
-function insertDriftEvent(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 (?, 'case.freshness_drifted', 'system', NULL, NULL, ?, ?, ?, ?, ?)
-      `)
-        .run(`me_${(0, node_crypto_1.randomUUID)()}`, `case:${input.case_id}`, (0, canonicalize_js_1.canonicalizeJSON)([{ type: 'case', id: input.case_id }]), (0, canonicalize_js_1.canonicalizeJSON)([input.case_id]), (0, canonicalize_js_1.canonicalizeJSON)({
-        freshness_score: input.result.freshness_score,
-        freshness_drift_threshold: input.result.freshness_drift_threshold,
-        reasons: input.result.reasons,
-    }), createdAtMs(input.now));
-}
-function hasFreshnessChanged(row, result) {
-    return (row.freshness_score !== result.freshness_score ||
-        row.freshness_state !== result.freshness_state ||
-        Number(row.freshness_score_is_drifted) !== result.freshness_score_is_drifted ||
-        row.freshness_drift_threshold !== result.freshness_drift_threshold ||
-        row.freshness_reason_json !== result.freshness_reason_json);
-}
-function calculateCaseFreshness(input) {
-    const threshold = normalizedThreshold(input.drift_threshold);
-    const reasons = [];
-    let value = 1.0;
-    const compiledMs = timestampMs(input.compiled_at);
-    const activityMs = timestampMs(input.last_activity_at);
-    const stateUpdatedMs = timestampMs(input.state_updated_at);
-    const wikiUpdatedMs = timestampMs(input.wiki_index_updated_at);
-    const hasWikiPath = Boolean(input.current_wiki_path && input.current_wiki_path.trim().length > 0);
-    if (compiledMs === null) {
-        value -= 0.5;
-        reasons.push({ code: 'missing_compile', penalty: 0.5 });
-    }
-    if (activityMs !== null && compiledMs !== null && activityMs > compiledMs) {
-        value -= 0.35;
-        reasons.push({ code: 'activity_after_compile', penalty: 0.35 });
-    }
-    if (stateUpdatedMs !== null && compiledMs !== null && stateUpdatedMs > compiledMs) {
-        value -= 0.25;
-        reasons.push({ code: 'state_update_after_compile', penalty: 0.25 });
-    }
-    if (hasWikiPath && wikiUpdatedMs === null) {
-        value -= 0.25;
-        reasons.push({
-            code: 'wiki_index_missing',
-            penalty: 0.25,
-            detail: input.current_wiki_path ?? '',
-        });
-    }
-    const timestampsAbsent = compiledMs === null && activityMs === null && stateUpdatedMs === null;
-    if (timestampsAbsent) {
-        reasons.push({ code: 'timestamps_absent', penalty: 0 });
-    }
-    const freshnessScore = score(value);
-    let state;
-    if (timestampsAbsent) {
-        state = 'unknown';
-    }
-    else if (freshnessScore >= 0.8) {
-        state = 'fresh';
-    }
-    else if (freshnessScore < threshold) {
-        state = 'drifted';
-    }
-    else {
-        state = 'stale';
-    }
-    const result = {
-        freshness_score: freshnessScore,
-        freshness_state: state,
-        freshness_score_is_drifted: state === 'drifted' ? 1 : 0,
-        freshness_drift_threshold: threshold,
-        reasons,
-        freshness_reason_json: (0, canonicalize_js_1.canonicalizeJSON)(reasons),
-    };
-    return result;
-}
-function sweepCaseFreshness(adapter, input = {}) {
-    const freshnessAdapter = adapter;
-    return (0, sqlite_transaction_js_1.runImmediateTransaction)(freshnessAdapter, () => {
-        const now = normalizeNow(input.now);
-        const requestedCaseIds = input.case_ids ?? allCandidateCaseIds(freshnessAdapter);
-        const seenTerminalIds = new Set();
-        const results = [];
-        const rejected = [];
-        for (const requestedCaseId of requestedCaseIds) {
-            const resolution = resolveChain(freshnessAdapter, requestedCaseId);
-            if (!resolution) {
-                continue;
-            }
-            if (seenTerminalIds.has(resolution.terminal_case_id)) {
-                continue;
-            }
-            const row = loadCase(freshnessAdapter, resolution.terminal_case_id);
-            if (!row) {
-                continue;
-            }
-            if (TERMINAL_CASE_STATUSES.has(row.status)) {
-                if (input.case_ids) {
-                    rejected.push({
-                        case_id: requestedCaseId,
-                        code: 'case.terminal_status',
-                        message: `Freshness cannot be written to terminal case status ${row.status}.`,
-                    });
-                }
-                continue;
-            }
-            seenTerminalIds.add(resolution.terminal_case_id);
-            const chain = (0, store_js_1.expandCaseChainForAssembly)(freshnessAdapter, resolution.terminal_case_id, resolution.chain);
-            const calculation = calculateCaseFreshness({
-                last_activity_at: row.last_activity_at,
-                state_updated_at: row.state_updated_at,
-                compiled_at: row.compiled_at,
-                wiki_index_updated_at: wikiIndexUpdatedAt(freshnessAdapter, resolution.terminal_case_id),
-                current_wiki_path: row.current_wiki_path,
-                drift_threshold: input.drift_threshold,
-                now,
-            });
-            const changed = hasFreshnessChanged(row, calculation);
-            const driftedTransition = changed && row.freshness_state !== 'drifted' && calculation.freshness_state === 'drifted';
-            if (changed) {
-                freshnessAdapter
-                    .prepare(`
-              UPDATE case_truth
-              SET freshness_score = ?,
-                  freshness_state = ?,
-                  freshness_score_is_drifted = ?,
-                  freshness_drift_threshold = ?,
-                  freshness_checked_at = ?,
-                  freshness_reason_json = ?
-              WHERE case_id = ?
-            `)
-                    .run(calculation.freshness_score, calculation.freshness_state, calculation.freshness_score_is_drifted, calculation.freshness_drift_threshold, now, calculation.freshness_reason_json, resolution.terminal_case_id);
-                if (driftedTransition) {
-                    insertDriftEvent({
-                        adapter: freshnessAdapter,
-                        case_id: resolution.terminal_case_id,
-                        result: calculation,
-                        now,
-                    });
-                }
-            }
-            else {
-                freshnessAdapter
-                    .prepare(`
-              UPDATE case_truth
-              SET freshness_checked_at = ?
-              WHERE case_id = ?
-            `)
-                    .run(now, resolution.terminal_case_id);
-            }
-            results.push({
-                case_id: requestedCaseId,
-                terminal_case_id: resolution.terminal_case_id,
-                resolved_via_case_id: resolution.resolved_via_case_id,
-                chain,
-                freshness_checked_at: now,
-                changed,
-                ...calculation,
-            });
-        }
-        return {
-            checked: results.length,
-            fresh: results.filter((result) => result.freshness_state === 'fresh').length,
-            stale: results.filter((result) => result.freshness_state === 'stale').length,
-            drifted: results.filter((result) => result.freshness_state === 'drifted').length,
-            drifted_case_ids: results
-                .filter((result) => result.freshness_state === 'drifted')
-                .map((result) => result.terminal_case_id),
-            results,
-            ...(rejected.length > 0 ? { rejected } : {}),
-        };
-    });
-}
-function listDriftedCases(adapter) {
-    const rows = adapter
-        .prepare(`
-        SELECT case_id, freshness_score, freshness_checked_at
-        FROM case_truth
-        WHERE freshness_state = 'drifted'
-          AND freshness_score_is_drifted = 1
-          AND status NOT IN ('merged','archived','split')
-        ORDER BY freshness_score ASC, case_id ASC
-      `)
-        .all();
-    return rows;
-}
-//# sourceMappingURL=freshness.js.map

package/dist/cases/live-state.d.ts

@@ -1,48 +0,0 @@
-import type { DatabaseAdapter } from '../db-manager.js';
-import type { CaseFastWriteStatus as CaseFastWriteStatusFromTypes } from './types.js';
-export type CaseFastWriteErrorCode = 'case.precompile_gap' | 'case.lock_held' | 'case.terminal_status' | 'case.correction_active_conflict';
-export interface CaseMembershipWritePlan {
-    source_type: 'decision' | 'event' | 'observation' | 'artifact';
-    source_id: string;
-    role?: 'requester' | 'implementer' | 'reviewer' | 'observer' | 'affected' | null;
-    confidence: number;
-    reason: string;
-    status: 'active' | 'candidate';
-}
-type CaseFastWriteStatus = CaseFastWriteStatusFromTypes;
-export interface WriteCaseLiveStateInput {
-    case_id: string;
-    source_event_id: string;
-    source_type: 'event';
-    status?: CaseFastWriteStatus;
-    last_activity_at?: string;
-    membership?: CaseMembershipWritePlan;
-    actor?: 'memory_agent';
-    now?: string;
-}
-export type WriteCaseLiveStateResult = {
-    kind: 'applied';
-    case_id: string;
-    applied_targets: Array<{
-        target_kind: 'case_field' | 'membership';
-        target_ref_json: string;
-    }>;
-    skipped_targets: Array<{
-        target_kind: 'case_field' | 'membership';
-        target_ref_json: string;
-        correction_id: string;
-    }>;
-    audit_event_ids: string[];
-} | {
-    kind: 'precompile_gap';
-    code: 'case.precompile_gap';
-    case_id: string;
-} | {
-    kind: 'rejected';
-    code: CaseFastWriteErrorCode;
-    message: string;
-    case_id: string;
-};
-export declare function writeCaseLiveStateFromEvent(adapter: DatabaseAdapter, input: WriteCaseLiveStateInput): WriteCaseLiveStateResult;
-export {};
-//# sourceMappingURL=live-state.d.ts.map

package/dist/cases/live-state.js

@@ -1,256 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeCaseLiveStateFromEvent = writeCaseLiveStateFromEvent;
-const node_crypto_1 = require("node:crypto");
-const canonicalize_js_1 = require("../canonicalize.js");
-const target_ref_js_1 = require("./target-ref.js");
-const sqlite_transaction_js_1 = require("./sqlite-transaction.js");
-const TERMINAL_CASE_STATUSES = new Set(['merged', 'archived', 'split']);
-const FAST_WRITE_STATUSES = new Set([
-    'active',
-    'blocked',
-    'resolved',
-    'stale',
-]);
-function isCaseFastWriteStatus(value) {
-    return typeof value === 'string' && FAST_WRITE_STATUSES.has(value);
-}
-function normalizeNow(value) {
-    return value ?? new Date().toISOString();
-}
-function createdAtMs(now) {
-    const parsed = Date.parse(now);
-    return Number.isFinite(parsed) ? parsed : Date.now();
-}
-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 toHashKey(value) {
-    return Buffer.from(value).toString('hex');
-}
-function targetPlanForCanonical(target_kind, canonical) {
-    return {
-        target_kind,
-        target_ref_json: canonical.json,
-        target_ref_hash: canonical.hash,
-    };
-}
-function buildTargetPlans(input) {
-    const targets = [];
-    if (input.status !== undefined) {
-        targets.push(targetPlanForCanonical('case_field', (0, target_ref_js_1.canonicalTargetRef)((0, target_ref_js_1.buildCaseFieldTargetRef)('status'))));
-    }
-    if (input.last_activity_at !== undefined) {
-        targets.push(targetPlanForCanonical('case_field', (0, target_ref_js_1.canonicalTargetRef)((0, target_ref_js_1.buildCaseFieldTargetRef)('last_activity_at'))));
-    }
-    if (input.membership) {
-        targets.push(targetPlanForCanonical('membership', (0, target_ref_js_1.canonicalTargetRef)((0, target_ref_js_1.buildMembershipTargetRef)(input.membership.source_type, input.membership.source_id))));
-    }
-    return targets;
-}
-function readCaseChain(adapter, caseId) {
-    const rows = adapter
-        .prepare(`
-        WITH RECURSIVE case_chain(case_id) AS (
-          SELECT case_id
-          FROM case_truth
-          WHERE case_id = ?
-
-          UNION
-
-          SELECT ct.case_id
-          FROM case_truth ct
-          JOIN case_chain cc ON ct.canonical_case_id = cc.case_id
-        )
-        SELECT case_id
-        FROM case_chain
-      `)
-        .all(caseId);
-    return rows.map((row) => row.case_id);
-}
-function readActiveLocks(adapter, chainIds, targets) {
-    if (chainIds.length === 0 || targets.length === 0) {
-        return new Map();
-    }
-    const targetHashes = targets.map((target) => target.target_ref_hash);
-    const rows = adapter
-        .prepare(`
-        SELECT correction_id, case_id, target_kind, field_name, target_ref_json, target_ref_hash
-        FROM case_corrections
-        WHERE case_id IN (${placeholders(chainIds)})
-          AND is_lock_active = 1
-          AND reverted_at IS NULL
-          AND target_ref_hash IN (${placeholders(targetHashes)})
-      `)
-        .all(...chainIds, ...targetHashes);
-    const locks = new Map();
-    for (const row of rows) {
-        locks.set(toHashKey(row.target_ref_hash), row);
-    }
-    return locks;
-}
-function findTarget(targets, target_kind, target_ref_json) {
-    return (targets.find((target) => target.target_kind === target_kind && target.target_ref_json === target_ref_json) ?? null);
-}
-function hasLock(locks, target) {
-    if (!target) {
-        return null;
-    }
-    return locks.get(toHashKey(target.target_ref_hash)) ?? null;
-}
-function insertSkippedAuditEvent(input) {
-    const eventId = `me_${(0, node_crypto_1.randomUUID)()}`;
-    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 (?, 'case.fast_write_lock_skipped', 'memory_agent', ?, NULL, ?, ?, ?, ?, ?)
-      `)
-        .run(eventId, input.source_event_id, `case:${input.case_id}`, (0, canonicalize_js_1.canonicalizeJSON)([{ type: 'case', id: input.case_id }]), (0, canonicalize_js_1.canonicalizeJSON)([input.source_event_id]), (0, canonicalize_js_1.canonicalizeJSON)({ skipped_targets: input.skipped_targets }), createdAtMs(input.now));
-    return eventId;
-}
-function writeCaseLiveStateFromEvent(adapter, input) {
-    const liveAdapter = adapter;
-    return (0, sqlite_transaction_js_1.runImmediateTransaction)(liveAdapter, () => {
-        const caseRow = liveAdapter
-            .prepare(`
-          SELECT case_id, status
-          FROM case_truth
-          WHERE case_id = ?
-        `)
-            .get(input.case_id);
-        if (!caseRow) {
-            return { kind: 'precompile_gap', code: 'case.precompile_gap', case_id: input.case_id };
-        }
-        if (TERMINAL_CASE_STATUSES.has(caseRow.status)) {
-            return {
-                kind: 'rejected',
-                code: 'case.terminal_status',
-                message: `Memory-agent cannot update terminal case status ${caseRow.status}.`,
-                case_id: input.case_id,
-            };
-        }
-        if (input.status !== undefined && !isCaseFastWriteStatus(input.status)) {
-            return {
-                kind: 'rejected',
-                code: 'case.terminal_status',
-                message: `Memory-agent cannot write terminal case status ${String(input.status)}.`,
-                case_id: input.case_id,
-            };
-        }
-        const now = normalizeNow(input.now);
-        const chainIds = readCaseChain(liveAdapter, input.case_id);
-        const targets = buildTargetPlans(input);
-        const locks = readActiveLocks(liveAdapter, chainIds, targets);
-        const applied_targets = [];
-        const skipped_targets = [];
-        const statusTarget = targets[0] ?? null;
-        const lastActivityTarget = input.status !== undefined ? (targets[1] ?? null) : (targets[0] ?? null);
-        const membershipTarget = input.membership
-            ? findTarget(targets, 'membership', (0, target_ref_js_1.canonicalTargetRef)((0, target_ref_js_1.buildMembershipTargetRef)(input.membership.source_type, input.membership.source_id)).json)
-            : null;
-        const statusLock = input.status !== undefined ? hasLock(locks, statusTarget) : null;
-        const lastActivityLock = input.last_activity_at !== undefined ? hasLock(locks, lastActivityTarget) : null;
-        const membershipLock = input.membership ? hasLock(locks, membershipTarget) : null;
-        if (statusLock && statusTarget) {
-            skipped_targets.push({
-                target_kind: statusTarget.target_kind,
-                target_ref_json: statusTarget.target_ref_json,
-                correction_id: statusLock.correction_id,
-            });
-        }
-        if (lastActivityLock && lastActivityTarget) {
-            skipped_targets.push({
-                target_kind: lastActivityTarget.target_kind,
-                target_ref_json: lastActivityTarget.target_ref_json,
-                correction_id: lastActivityLock.correction_id,
-            });
-        }
-        if (membershipLock && membershipTarget) {
-            skipped_targets.push({
-                target_kind: membershipTarget.target_kind,
-                target_ref_json: membershipTarget.target_ref_json,
-                correction_id: membershipLock.correction_id,
-            });
-        }
-        const shouldWriteStatus = input.status !== undefined && !statusLock;
-        const shouldWriteLastActivity = input.last_activity_at !== undefined && !lastActivityLock;
-        if (shouldWriteStatus || shouldWriteLastActivity) {
-            const updateResult = liveAdapter
-                .prepare(`
-            UPDATE case_truth
-               SET status = CASE WHEN ? = 1 THEN ? ELSE status END,
-                   last_activity_at = CASE WHEN ? = 1 THEN ? ELSE last_activity_at END,
-                   state_updated_at = ?,
-                   updated_at = ?
-             WHERE case_id = ?
-               AND status NOT IN ('merged','archived','split')
-          `)
-                .run(shouldWriteStatus ? 1 : 0, input.status ?? null, shouldWriteLastActivity ? 1 : 0, input.last_activity_at ?? null, now, now, input.case_id);
-            if (updateResult.changes > 0) {
-                if (shouldWriteStatus && statusTarget) {
-                    applied_targets.push({
-                        target_kind: statusTarget.target_kind,
-                        target_ref_json: statusTarget.target_ref_json,
-                    });
-                }
-                if (shouldWriteLastActivity && lastActivityTarget) {
-                    applied_targets.push({
-                        target_kind: lastActivityTarget.target_kind,
-                        target_ref_json: lastActivityTarget.target_ref_json,
-                    });
-                }
-            }
-        }
-        if (input.membership && !membershipLock && membershipTarget) {
-            const membershipResult = liveAdapter
-                .prepare(`
-            INSERT INTO case_memberships (
-              case_id, source_type, source_id, role, confidence, reason, status,
-              added_by, added_at, user_locked, updated_at
-            )
-            VALUES (?, ?, ?, ?, ?, ?, ?, 'memory-agent', ?, 0, ?)
-            ON CONFLICT(case_id, source_type, source_id) DO UPDATE SET
-              role = excluded.role,
-              confidence = excluded.confidence,
-              reason = excluded.reason,
-              status = excluded.status,
-              added_by = 'memory-agent',
-              updated_at = excluded.updated_at
-            WHERE case_memberships.user_locked = 0
-              AND case_memberships.status <> 'stale'
-          `)
-                .run(input.case_id, input.membership.source_type, input.membership.source_id, input.membership.role ?? null, input.membership.confidence, input.membership.reason, input.membership.status, now, now);
-            if (membershipResult.changes > 0) {
-                applied_targets.push({
-                    target_kind: membershipTarget.target_kind,
-                    target_ref_json: membershipTarget.target_ref_json,
-                });
-            }
-        }
-        const audit_event_ids = skipped_targets.length > 0
-            ? [
-                insertSkippedAuditEvent({
-                    adapter: liveAdapter,
-                    case_id: input.case_id,
-                    source_event_id: input.source_event_id,
-                    skipped_targets,
-                    now,
-                }),
-            ]
-            : [];
-        return {
-            kind: 'applied',
-            case_id: input.case_id,
-            applied_targets,
-            skipped_targets,
-            audit_event_ids,
-        };
-    });
-}
-//# sourceMappingURL=live-state.js.map