hippo-memory 1.69.0 → 1.70.0

package/dist/store/compactions.d.ts

@@ -0,0 +1,78 @@
+import type { DatabaseSyncLike } from '../db/index.js';
+export type CompactionStatus = 'started' | 'summarised' | 'done' | 'no-summary';
+export interface CompactionRow {
+    tenant_id: string;
+    id: string;
+    session_id: string;
+    origin_project: string;
+    compact_trigger: string | null;
+    cwd: string | null;
+    transcript_path: string | null;
+    snapshot_saved: number;
+    started_at: string;
+    summarised_at: string | null;
+    summary: string | null;
+    items_json: string | null;
+    items_written: number;
+    status: CompactionStatus;
+}
+export interface HeldMemoryRow {
+    id: string;
+    source_session_id: string | null;
+    content: string;
+}
+export interface StartedCompactionInput {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly originProject: string;
+    readonly trigger: string | null;
+    readonly cwd: string | null;
+    readonly transcriptPath: string | null;
+    readonly startedAt: string;
+}
+export interface SummarisedUpdate {
+    readonly summary: string;
+    readonly itemsJson: string;
+    readonly summarisedAt: string;
+    readonly requestId?: string;
+}
+export interface SummarisedInsert extends SummarisedUpdate {
+    readonly id: string;
+}
+export type SummarisedInsertMeta = Omit<StartedCompactionInput, 'id'>;
+/** A session's newest row, as an array of at most one. */
+export declare function latestCompactionRows(db: DatabaseSyncLike, tenantId: string, sessionId: string): CompactionRow[];
+export declare function compactionRowsByRequest(db: DatabaseSyncLike, tenantId: string, requestId: string): CompactionRow[];
+/** The session's newest `started` row with a start in [`notBefore`, `notAfter`], both ISO strings. */
+export declare function latestStartedRows(db: DatabaseSyncLike, tenantId: string, sessionId: string, notAfter: string, notBefore: string): CompactionRow[];
+/** `summarised` rows whose summary is older than `summarisedBefore`, an ISO string. */
+export declare function stalledSummarisedRows(db: DatabaseSyncLike, tenantId: string, summarisedBefore: string): CompactionRow[];
+/** `started` rows with a transcript whose start lies between `startedAfter` and `startedBefore`, oldest first. */
+export declare function openTranscriptRows(db: DatabaseSyncLike, tenantId: string, startedBefore: string, startedAfter: string): CompactionRow[];
+export declare function insertStartedCompaction(db: DatabaseSyncLike, tenantId: string, start: StartedCompactionInput): void;
+/** Moves a `started` row to `summarised`; false when another process already moved it. */
+export declare function markCompactionSummarised(db: DatabaseSyncLike, tenantId: string, id: string, update: SummarisedUpdate): boolean;
+export declare function insertSummarisedCompaction(db: DatabaseSyncLike, tenantId: string, meta: SummarisedInsertMeta, row: SummarisedInsert): void;
+export declare function markSnapshotSavedRow(db: DatabaseSyncLike, tenantId: string, recordId: string): void;
+export declare function compactionProgress(db: DatabaseSyncLike, tenantId: string, id: string): {
+    status: CompactionStatus;
+    items_written: number;
+} | undefined;
+export declare function markCompactionDone(db: DatabaseSyncLike, tenantId: string, id: string, itemsWritten: number): void;
+/** Rows changed: 1 when the `started` row was closed, 0 when it had already moved. */
+export declare function closeStartedWithoutSummary(db: DatabaseSyncLike, tenantId: string, id: string): number;
+export declare function nextCompactionStart(db: DatabaseSyncLike, tenantId: string, sessionId: string, after: string): string | null;
+/** Live rows of one tenant and origin set that default recall shows. */
+export declare function heldMemoryRows(db: DatabaseSyncLike, tenantId: string, origins: readonly string[]): HeldMemoryRow[];
+export declare function restampCompactionOrigin(db: DatabaseSyncLike, tenantId: string, from: string, into: string): number;
+export declare function compactionTranscripts(db: DatabaseSyncLike, tenantId: string): Array<{
+    transcript: string;
+    cwd: string | null;
+}>;
+export declare function compactionOriginsWithCwd(db: DatabaseSyncLike, tenantId: string): Array<{
+    origin: string;
+    cwd: string;
+}>;
+/** True when `table` holds a row of this tenant under the project name. */
+export declare function holdsOrigin(db: DatabaseSyncLike, table: 'memories' | 'compactions', tenantId: string, name: string): boolean;
+//# sourceMappingURL=compactions.d.ts.map

package/dist/store/compactions.js

@@ -0,0 +1,93 @@
+import { originInSql } from '../core/project-identity.js';
+import { scopeAdmitSql } from './recall-scope.js';
+const COLUMNS = 'tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, snapshot_saved, started_at, summarised_at, summary, items_json, items_written, status';
+function selectRows(db, where, ...params) {
+    // SAFETY: the SELECT names exactly COLUMNS, matching CompactionRow's field set.
+    return db.prepare(`SELECT ${COLUMNS} FROM compactions WHERE ${where}`).all(...params);
+}
+/** A session's newest row, as an array of at most one. */
+export function latestCompactionRows(db, tenantId, sessionId) {
+    return selectRows(db, 'tenant_id = ? AND session_id = ? ORDER BY started_at DESC, id DESC LIMIT 1', tenantId, sessionId);
+}
+export function compactionRowsByRequest(db, tenantId, requestId) {
+    return selectRows(db, 'tenant_id = ? AND request_id = ?', tenantId, requestId);
+}
+/** The session's newest `started` row with a start in [`notBefore`, `notAfter`], both ISO strings. */
+export function latestStartedRows(db, tenantId, sessionId, notAfter, notBefore) {
+    return selectRows(db, `tenant_id = ? AND session_id = ? AND status = 'started' AND started_at <= ? AND started_at >= ? ORDER BY started_at DESC, id DESC LIMIT 1`, tenantId, sessionId, notAfter, notBefore);
+}
+/** `summarised` rows whose summary is older than `summarisedBefore`, an ISO string. */
+export function stalledSummarisedRows(db, tenantId, summarisedBefore) {
+    return selectRows(db, `tenant_id = ? AND status = 'summarised' AND summarised_at < ?`, tenantId, summarisedBefore);
+}
+/** `started` rows with a transcript whose start lies between `startedAfter` and `startedBefore`, oldest first. */
+export function openTranscriptRows(db, tenantId, startedBefore, startedAfter) {
+    return selectRows(db, `tenant_id = ? AND status = 'started' AND started_at < ? AND started_at > ? AND transcript_path IS NOT NULL ORDER BY started_at`, tenantId, startedBefore, startedAfter);
+}
+export function insertStartedCompaction(db, tenantId, start) {
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(tenantId, start.id, start.sessionId, start.originProject, start.trigger, start.cwd, start.transcriptPath, start.startedAt);
+}
+/** Moves a `started` row to `summarised`; false when another process already moved it. */
+export function markCompactionSummarised(db, tenantId, id, update) {
+    const { summary, itemsJson, summarisedAt, requestId } = update;
+    // Only a caller names the column, so a store from before it was added still takes local writes.
+    const stamp = requestId === undefined ? [] : [requestId];
+    const result = db.prepare(`UPDATE compactions SET summary = ?, items_json = ?, summarised_at = ?, status = 'summarised'${stamp.length === 0 ? '' : ', request_id = ?'}
+     WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(summary, itemsJson, summarisedAt, ...stamp, tenantId, id);
+    return (result.changes ?? 0) > 0;
+}
+export function insertSummarisedCompaction(db, tenantId, meta, row) {
+    const { id, summary, itemsJson, summarisedAt, requestId } = row;
+    // Only a caller names the column, so a store from before it was added still takes local writes.
+    const stamp = requestId === undefined ? [] : [requestId];
+    const [col, mark] = stamp.length === 0 ? ['', ''] : [', request_id', ', ?'];
+    db.prepare(`INSERT INTO compactions(tenant_id, id, session_id, origin_project, compact_trigger, cwd, transcript_path, started_at, summarised_at, summary, items_json, status${col})
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'summarised'${mark})`).run(tenantId, id, meta.sessionId, meta.originProject, meta.trigger, meta.cwd, meta.transcriptPath, meta.startedAt, summarisedAt, summary, itemsJson, ...stamp);
+}
+export function markSnapshotSavedRow(db, tenantId, recordId) {
+    db.prepare(`UPDATE compactions SET snapshot_saved = 1 WHERE tenant_id = ? AND id = ?`).run(tenantId, recordId);
+}
+export function compactionProgress(db, tenantId, id) {
+    return db.prepare(`SELECT status, items_written FROM compactions WHERE tenant_id = ? AND id = ?`)
+        .get(tenantId, id);
+}
+export function markCompactionDone(db, tenantId, id, itemsWritten) {
+    db.prepare(`UPDATE compactions SET items_written = ?, status = 'done' WHERE tenant_id = ? AND id = ?`).run(itemsWritten, tenantId, id);
+}
+/** Rows changed: 1 when the `started` row was closed, 0 when it had already moved. */
+export function closeStartedWithoutSummary(db, tenantId, id) {
+    const result = db.prepare(`UPDATE compactions SET status = 'no-summary' WHERE tenant_id = ? AND id = ? AND status = 'started'`).run(tenantId, id);
+    return Number(result.changes ?? 0);
+}
+export function nextCompactionStart(db, tenantId, sessionId, after) {
+    const row = db.prepare(`SELECT MIN(started_at) AS at FROM compactions WHERE tenant_id = ? AND session_id = ? AND started_at > ?`)
+        .get(tenantId, sessionId, after);
+    return row?.at ?? null;
+}
+/** Live rows of one tenant and origin set that default recall shows. */
+export function heldMemoryRows(db, tenantId, origins) {
+    const deny = scopeAdmitSql('');
+    // SAFETY: the SELECT names the id, source_session_id and content columns.
+    return db.prepare(`SELECT id, source_session_id, content FROM memories WHERE tenant_id = ? AND ${originInSql(origins)} AND superseded_by IS NULL AND kind != 'raw'
+       AND ${deny.sql}`).all(tenantId, ...origins, ...deny.params);
+}
+export function restampCompactionOrigin(db, tenantId, from, into) {
+    return Number(db.prepare(`UPDATE compactions SET origin_project = ? WHERE tenant_id = ? AND origin_project = ?`)
+        .run(into, tenantId, from).changes ?? 0);
+}
+export function compactionTranscripts(db, tenantId) {
+    // SAFETY: the SELECT names the two columns of the row type.
+    return db.prepare(`SELECT DISTINCT transcript_path AS transcript, cwd FROM compactions WHERE tenant_id = ? AND transcript_path IS NOT NULL`)
+        .all(tenantId);
+}
+export function compactionOriginsWithCwd(db, tenantId) {
+    // SAFETY: the SELECT names the two columns of the row type.
+    return db.prepare(`SELECT DISTINCT origin_project AS origin, cwd FROM compactions WHERE tenant_id = ? AND origin_project <> '' AND cwd IS NOT NULL`)
+        .all(tenantId);
+}
+/** True when `table` holds a row of this tenant under the project name. */
+export function holdsOrigin(db, table, tenantId, name) {
+    return db.prepare(`SELECT 1 FROM ${table} WHERE tenant_id = ? AND origin_project = ? LIMIT 1`).get(tenantId, name) !== undefined;
+}
+//# sourceMappingURL=compactions.js.map

package/dist/store/conflicts.d.ts

@@ -1,6 +1,16 @@
-import { type DatabaseSyncLike } from '../db.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import type { MemoryEntry } from '../core/memory.js';
 import { type MemoryConflict } from './rows.js';
 export declare function listMemoryConflicts(hippoRoot: string, status?: string, tenantId?: string): MemoryConflict[];
+/** How many open conflicts listMemoryConflicts returns for a tenant, without loading one. */
+export declare function countOpenConflicts(hippoRoot: string, tenantId: string): number;
+/** One open conflict of a memory, with the row on its other side. */
+export interface OpenConflictOf {
+    conflict: MemoryConflict;
+    other: MemoryEntry;
+}
+/** A tenant's open conflicts naming `memoryId`, in listMemoryConflicts' order, each with its other member read in one batch. */
+export declare function loadOpenConflictsOf(hippoRoot: string, tenantId: string, memoryId: string): OpenConflictOf[];
 /** Conflicts whose two rows `actor` may both touch; someone else's personal row hides its whole pair. */
 export declare function listTouchableConflicts(hippoRoot: string, status: string, tenantId: string, actor: {
     owner?: string;
@@ -18,10 +28,6 @@ export interface ConflictRefreshReads {
     sameTenant: SameTenant;
     storedRefs: ReadonlyMap<string, string | null>;
 }
-/** The refresh's read of the whole memories table, kept out of the write lock because it grows with the store. */
-export declare function readConflictRefresh(db: DatabaseSyncLike): ConflictRefreshReads;
-/** Under the write lock: the memory_conflicts rows, then each memory whose refs change; returns the ids it rewrote. */
-export declare function writeConflictRefresh(db: DatabaseSyncLike, reads: ConflictRefreshReads, detected: readonly DetectedConflict[], detectedAt: string): string[];
 /**
  * AT1 (plan §5): additive-optional opts for resolveConflict.
  * `rejectLoserValue` implies removal of the loser regardless of
@@ -55,5 +61,16 @@ export declare function resolveConflict(hippoRoot: string, conflictId: number, k
     conflict: MemoryConflict;
     loserId: string;
 } | null;
+/** The conflict and loser ids every conflict_resolve audit row names. */
+export declare function conflictResolveAuditsAt(db: DatabaseSyncLike): Array<{
+    conflictId: number;
+    loserId: string;
+}>;
+/** Every resolved conflict with both sides. */
+export declare function resolvedConflictsAt(db: DatabaseSyncLike): Array<{
+    id: number;
+    memory_a_id: string;
+    memory_b_id: string;
+}>;
 export {};
 //# sourceMappingURL=conflicts.d.ts.map

package/dist/store/conflicts.js

@@ -1,20 +1,63 @@
-import { closeHippoDb, openHippoDb } from '../db.js';
-import { rejectionDigest, insertRejectedValue, normalizeValueForRejection } from '../rejection.js';
-import { archiveRawMemory } from '../raw-archive.js';
+import { closeHippoDb, openHippoDb, withWriteScope } from '../db/index.js';
+import { rejectionDigest, insertRejectedValue, normalizeValueForRejection } from './rejection.js';
+import { archiveRawMemory } from './raw-archive.js';
 import { rowToMemoryConflict } from './rows.js';
 import { audit } from './audit-event.js';
 import { syncChangedMirrors, purgeMirrorBestEffort } from './mirrors.js';
 import { selectEntriesByIds } from './entry-reads.js';
 import { openStore } from './open.js';
 import { deleteEntryCore } from './delete-and-batch.js';
-import { BadRequestError } from '../api-errors.js';
-import { canTouchScope, isPersonalScope } from '../recall-scope.js';
+import { BadRequestError } from '../core/api-errors.js';
+import { canTouchScope, isPersonalScope } from './recall-scope.js';
 import { selectMemoryReach } from './tenant-lookup.js';
 function canonicalConflictPair(aId, bId) {
     return aId < bId
         ? { memory_a_id: aId, memory_b_id: bId }
         : { memory_a_id: bId, memory_b_id: aId };
 }
+function selectConflictRowsInTenant(db, status, allStatuses, tenantId) {
+    // Tenanted query — JOIN to memories on both conflict members and require
+    // each in-tenant, so neither a normal cross-tenant pair nor a stale
+    // pre-fix row surfaces (consistent with resolveConflict).
+    // SAFETY: both branches select the same eight mc.* columns (aliased
+    // to MemoryConflictRow's field names) from memory_conflicts.
+    return allStatuses
+        ? db.prepare(`
+        SELECT mc.id, mc.memory_a_id, mc.memory_b_id, mc.reason, mc.score,
+               mc.status, mc.detected_at, mc.updated_at
+        FROM memory_conflicts mc
+        JOIN memories ma ON ma.id = mc.memory_a_id
+        JOIN memories mb ON mb.id = mc.memory_b_id
+        WHERE ma.tenant_id = ? AND mb.tenant_id = ?
+        ORDER BY mc.updated_at DESC, mc.id DESC
+      `).all(tenantId, tenantId)
+        : db.prepare(`
+        SELECT mc.id, mc.memory_a_id, mc.memory_b_id, mc.reason, mc.score,
+               mc.status, mc.detected_at, mc.updated_at
+        FROM memory_conflicts mc
+        JOIN memories ma ON ma.id = mc.memory_a_id
+        JOIN memories mb ON mb.id = mc.memory_b_id
+        WHERE mc.status = ? AND ma.tenant_id = ? AND mb.tenant_id = ?
+        ORDER BY mc.updated_at DESC, mc.id DESC
+      `).all(status, tenantId, tenantId);
+}
+function selectConflictRowsUnscoped(db, status, allStatuses) {
+    // Unscoped query — legacy direct-mode (CLI, tests, consolidate).
+    // SAFETY: both branches select the same eight columns matching
+    // MemoryConflictRow's field set.
+    return allStatuses
+        ? db.prepare(`
+        SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+        FROM memory_conflicts
+        ORDER BY updated_at DESC, id DESC
+      `).all()
+        : db.prepare(`
+        SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
+        FROM memory_conflicts
+        WHERE status = ?
+        ORDER BY updated_at DESC, id DESC
+      `).all(status);
+}
 export function listMemoryConflicts(hippoRoot, status = 'open', tenantId) {
     const db = openStore(hippoRoot);
     try {
@@ -23,56 +66,55 @@ export function listMemoryConflicts(hippoRoot, status = 'open', tenantId) {
         // so this sentinel is purely additive. The 4 SQL branches below cover
         // {tenanted | unscoped} × {all-statuses | specific-status}.
         const allStatuses = status === '*';
-        let rows;
-        if (tenantId !== undefined) {
-            // Tenanted query — JOIN to memories on both conflict members and require
-            // each in-tenant, so neither a normal cross-tenant pair nor a stale
-            // pre-fix row surfaces (consistent with resolveConflict).
-            // SAFETY: both branches select the same eight mc.* columns (aliased
-            // to MemoryConflictRow's field names) from memory_conflicts.
-            rows = allStatuses
-                ? db.prepare(`
-            SELECT mc.id, mc.memory_a_id, mc.memory_b_id, mc.reason, mc.score,
-                   mc.status, mc.detected_at, mc.updated_at
-            FROM memory_conflicts mc
-            JOIN memories ma ON ma.id = mc.memory_a_id
-            JOIN memories mb ON mb.id = mc.memory_b_id
-            WHERE ma.tenant_id = ? AND mb.tenant_id = ?
-            ORDER BY mc.updated_at DESC, mc.id DESC
-          `).all(tenantId, tenantId)
-                : db.prepare(`
-            SELECT mc.id, mc.memory_a_id, mc.memory_b_id, mc.reason, mc.score,
-                   mc.status, mc.detected_at, mc.updated_at
-            FROM memory_conflicts mc
-            JOIN memories ma ON ma.id = mc.memory_a_id
-            JOIN memories mb ON mb.id = mc.memory_b_id
-            WHERE mc.status = ? AND ma.tenant_id = ? AND mb.tenant_id = ?
-            ORDER BY mc.updated_at DESC, mc.id DESC
-          `).all(status, tenantId, tenantId);
-        }
-        else {
-            // Unscoped query — legacy direct-mode (CLI, tests, consolidate).
-            // SAFETY: both branches select the same eight columns matching
-            // MemoryConflictRow's field set.
-            rows = allStatuses
-                ? db.prepare(`
-            SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
-            FROM memory_conflicts
-            ORDER BY updated_at DESC, id DESC
-          `).all()
-                : db.prepare(`
-            SELECT id, memory_a_id, memory_b_id, reason, score, status, detected_at, updated_at
-            FROM memory_conflicts
-            WHERE status = ?
-            ORDER BY updated_at DESC, id DESC
-          `).all(status);
-        }
+        const rows = tenantId !== undefined
+            ? selectConflictRowsInTenant(db, status, allStatuses, tenantId)
+            : selectConflictRowsUnscoped(db, status, allStatuses);
         return rows.map(rowToMemoryConflict);
     }
     finally {
         closeHippoDb(db);
     }
 }
+// listMemoryConflicts' tenanted open set: both members in the tenant.
+const OPEN_IN_TENANT = `FROM memory_conflicts mc
+  JOIN memories ma ON ma.id = mc.memory_a_id
+  JOIN memories mb ON mb.id = mc.memory_b_id
+  WHERE mc.status = 'open' AND ma.tenant_id = ? AND mb.tenant_id = ?`;
+/** How many open conflicts listMemoryConflicts returns for a tenant, without loading one. */
+export function countOpenConflicts(hippoRoot, tenantId) {
+    const db = openStore(hippoRoot);
+    try {
+        // SAFETY: one row with the single aliased count column.
+        const row = db.prepare(`SELECT COUNT(*) AS n ${OPEN_IN_TENANT}`).get(tenantId, tenantId);
+        return Number(row.n);
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
+/** A tenant's open conflicts naming `memoryId`, in listMemoryConflicts' order, each with its other member read in one batch. */
+export function loadOpenConflictsOf(hippoRoot, tenantId, memoryId) {
+    const db = openStore(hippoRoot);
+    try {
+        // SAFETY: selects the eight mc.* columns of MemoryConflictRow.
+        const rows = db.prepare(`SELECT mc.id, mc.memory_a_id, mc.memory_b_id, mc.reason, mc.score, mc.status, mc.detected_at, mc.updated_at
+       ${OPEN_IN_TENANT} AND (mc.memory_a_id = ? OR mc.memory_b_id = ?)
+       ORDER BY mc.updated_at DESC, mc.id DESC`).all(tenantId, tenantId, memoryId, memoryId);
+        const conflicts = rows.map(rowToMemoryConflict);
+        const otherId = (c) => (c.memory_a_id === memoryId ? c.memory_b_id : c.memory_a_id);
+        const others = selectEntriesByIds(db, conflicts.map(otherId), tenantId);
+        const out = [];
+        for (const conflict of conflicts) {
+            const other = others.get(otherId(conflict));
+            if (other)
+                out.push({ conflict, other });
+        }
+        return out;
+    }
+    finally {
+        closeHippoDb(db);
+    }
+}
 /** Conflicts whose two rows `actor` may both touch; someone else's personal row hides its whole pair. */
 export function listTouchableConflicts(hippoRoot, status, tenantId, actor) {
     const conflicts = listMemoryConflicts(hippoRoot, status, tenantId);
@@ -95,7 +137,7 @@ export function replaceDetectedConflicts(hippoRoot, detected, detectedAt = new D
     }
 }
 /** The refresh's read of the whole memories table, kept out of the write lock because it grows with the store. */
-export function readConflictRefresh(db) {
+function readConflictRefresh(db) {
     // Tenant guard (E2): a conflict is meaningful only within one tenant, so cross-tenant pairs are
     // skipped on insert and on rebuild, and a stale cross-tenant row can neither persist nor leak a foreign id.
     const tenantById = new Map();
@@ -114,25 +156,17 @@ export function readConflictRefresh(db) {
     return { sameTenant, storedRefs };
 }
 /** Under the write lock: the memory_conflicts rows, then each memory whose refs change; returns the ids it rewrote. */
-export function writeConflictRefresh(db, reads, detected, detectedAt) {
+function writeConflictRefresh(db, reads, detected, detectedAt) {
     const canonicalDetected = detected.map((conflict) => ({
         ...canonicalConflictPair(conflict.memory_a_id, conflict.memory_b_id),
         reason: conflict.reason,
         score: conflict.score,
     }));
-    db.exec('BEGIN IMMEDIATE');
-    try {
+    return withWriteScope(db, 'replace_conflicts', () => {
         resolveStaleOpenConflicts(db, canonicalDetected, reads.sameTenant, detectedAt);
         upsertDetectedConflicts(db, canonicalDetected, reads.sameTenant, detectedAt);
-        const changedIds = rebuildConflictsWithJson(db, reads);
-        db.exec('COMMIT');
-        return changedIds;
-    }
-    catch (error) {
-        if (db.isTransaction !== false)
-            db.exec('ROLLBACK');
-        throw error;
-    }
+        return rebuildConflictsWithJson(db, reads);
+    });
 }
 function resolveStaleOpenConflicts(db, canonicalDetected, sameTenant, detectedAt) {
     const detectedKeys = new Set(canonicalDetected.map((conflict) => `${conflict.memory_a_id}::${conflict.memory_b_id}`));
@@ -208,6 +242,32 @@ function rebuildConflictsWithJson(db, { sameTenant, storedRefs }) {
     }
     return changedIds;
 }
+// When tenantId is set, the conflict lookup requires BOTH members in-tenant
+// and every memories mutation carries AND tenant_id = ?. A cross-tenant probe
+// then returns null, indistinguishable from a bad id. Omitted tenantId =
+// legacy unscoped behaviour (CLI direct mode, tests, consolidate.ts).
+function conflictMemScope(tenantId) {
+    return {
+        memScope: tenantId !== undefined ? ' AND tenant_id = ?' : '',
+        memArgs: tenantId !== undefined ? [tenantId] : [],
+    };
+}
+function findResolvableConflict(db, conflictId, keepId, tenantId) {
+    const row = selectConflictRow(db, conflictId, tenantId);
+    if (!row)
+        return null;
+    const conflict = rowToMemoryConflict(row);
+    if (conflict.status !== 'open')
+        return null;
+    const loserId = keepId === conflict.memory_a_id
+        ? conflict.memory_b_id
+        : keepId === conflict.memory_b_id
+            ? conflict.memory_a_id
+            : null;
+    if (!loserId)
+        return null;
+    return { conflict, loserId };
+}
 /**
  * Resolve a conflict by keeping one memory and weakening the other.
  * Sets conflict status to 'resolved' and halves the loser's half-life.
@@ -225,50 +285,28 @@ function rebuildConflictsWithJson(db, { sameTenant, storedRefs }) {
  */
 export function resolveConflict(hippoRoot, conflictId, keepId, forgetLoser = false, tenantId, opts) {
     const db = openStore(hippoRoot);
-    // When tenantId is set, the conflict lookup requires BOTH members in-tenant
-    // and every memories mutation carries AND tenant_id = ?. A cross-tenant probe
-    // then returns null, indistinguishable from a bad id. Omitted tenantId =
-    // legacy unscoped behaviour (CLI direct mode, tests, consolidate.ts).
-    const scope = {
-        memScope: tenantId !== undefined ? ' AND tenant_id = ?' : '',
-        memArgs: tenantId !== undefined ? [tenantId] : [],
-    };
+    const scope = conflictMemScope(tenantId);
     try {
-        const row = selectConflictRow(db, conflictId, tenantId);
-        if (!row)
-            return null;
-        const conflict = rowToMemoryConflict(row);
-        if (conflict.status !== 'open')
+        const resolvable = findResolvableConflict(db, conflictId, keepId, tenantId);
+        if (!resolvable)
             return null;
-        const loserId = keepId === conflict.memory_a_id
-            ? conflict.memory_b_id
-            : keepId === conflict.memory_b_id
-                ? conflict.memory_a_id
-                : null;
-        if (!loserId)
-            return null;
-        db.exec('BEGIN IMMEDIATE');
-        // Mark conflict as resolved
-        db.prepare(`UPDATE memory_conflicts SET status = 'resolved', updated_at = datetime('now') WHERE id = ?`)
-            .run(conflictId);
+        const { conflict, loserId } = resolvable;
         const target = { conflictId, keepId, loserId, scope, opts };
-        const removeLoser = forgetLoser || opts?.rejectLoserValue === true;
-        const removal = removeLoser ? removeConflictLoser(db, target) : weakenConflictLoser(db, target);
-        stripConflictRefs(db, target, removal.loserRemoved);
-        auditConflictResolve(db, target, removal, tenantId);
-        db.exec('COMMIT');
+        const removal = withWriteScope(db, 'resolve_conflict', () => {
+            // Mark conflict as resolved
+            db.prepare(`UPDATE memory_conflicts SET status = 'resolved', updated_at = datetime('now') WHERE id = ?`)
+                .run(conflictId);
+            const removeLoser = forgetLoser || opts?.rejectLoserValue === true;
+            const out = removeLoser ? removeConflictLoser(db, target) : weakenConflictLoser(db, target);
+            stripConflictRefs(db, target, out.loserRemoved);
+            auditConflictResolve(db, target, out, tenantId);
+            return out;
+        });
         syncChangedMirrors(hippoRoot, db, [...selectEntriesByIds(db, [keepId, loserId]).values()]);
         if (removal.loserRemoved)
             purgeRemovedLoserMirrors(hippoRoot, db, loserId, removal);
         return { conflict: { ...conflict, status: 'resolved' }, loserId };
     }
-    catch (error) {
-        try {
-            db.exec('ROLLBACK');
-        }
-        catch { /* ignore */ }
-        throw error;
-    }
     finally {
         closeHippoDb(db);
     }
@@ -340,6 +378,17 @@ function removeConflictLoser(db, t) {
     // the old tenant-scoped DELETE's silent 0-rows-affected behavior.
     return removal;
 }
+function recordRejectedLoserValue(db, t, loserRow, digest, who) {
+    insertRejectedValue(db, {
+        tenantId: loserRow.tenant_id ?? 'default',
+        digest,
+        reason: who.reason,
+        rejectedBy: who.actor,
+        rejectedAt: new Date().toISOString(),
+        sourceMemoryId: t.loserId,
+        normalizedChars: normalizeValueForRejection(loserRow.content).length,
+    });
+}
 /** Tombstones the loser's digest and removes its same-tenant duplicates into `removal`; returns the digest. */
 function tombstoneLoserValue(db, t, loserRow, who, removal) {
     if (isPersonalScope(loserRow.scope)) {
@@ -347,15 +396,7 @@ function tombstoneLoserValue(db, t, loserRow, who, removal) {
     }
     const { actor, reason } = who;
     const rejectedDigest = rejectionDigest(loserRow.content);
-    insertRejectedValue(db, {
-        tenantId: loserRow.tenant_id ?? 'default',
-        digest: rejectedDigest,
-        reason,
-        rejectedBy: actor,
-        rejectedAt: new Date().toISOString(),
-        sourceMemoryId: t.loserId,
-        normalizedChars: normalizeValueForRejection(loserRow.content).length,
-    });
+    recordRejectedLoserValue(db, t, loserRow, rejectedDigest, who);
     // AT1 P1 fix (codex): reject-flow.ts's `rejectValue` removes ALL
     // live same-tenant rows whose normalized digest matches, not just
     // the one id passed — but this branch only ever removed loserId,
@@ -439,7 +480,7 @@ function auditConflictResolve(db, t, removal, tenantId) {
     // index signature) and isn't directly assignable to audit()'s
     // Record<string, JsonValue> metadata param; a spread into a fresh
     // object literal satisfies it without widening the declared type above.
-    audit(db, 'conflict_resolve', t.keepId, { ...conflictResolveMeta }, t.opts?.rejectedBy ?? 'cli', tenantId);
+    audit(db, 'conflict_resolve', { targetId: t.keepId, metadata: { ...conflictResolveMeta }, actor: t.opts?.rejectedBy ?? 'cli', tenantId });
 }
 function purgeRemovedLoserMirrors(hippoRoot, db, loserId, removal) {
     // AT1 P1b fix: mirror purge + reaper stamp for EVERY removed loser, not
@@ -454,7 +495,7 @@ function purgeRemovedLoserMirrors(hippoRoot, db, loserId, removal) {
     // eventually, since archiveRawMemory's own raw_archive insert leaves
     // mirror_cleaned_at NULL) and a plain non-raw --forget left its mirror
     // orphaned FOREVER (no reaper exists for non-raw rows). Same post-commit
-    // purge+reaper pattern as the reject verb (src/reject-flow.ts) and
+    // purge+reaper pattern as the reject verb (src/trust/reject-flow.ts) and
     // api.archiveRaw — reusing removeEntryMirrors + raw_archive bookkeeping.
     // AT1 P1 fix: loop over loserId AND every same-tenant duplicate the
     // rejectLoserValue sweep above removed (extraRemovedIds) — previously
@@ -473,4 +514,14 @@ function purgeRemovedLoserMirrors(hippoRoot, db, loserId, removal) {
         }
     }
 }
+/** The conflict and loser ids every conflict_resolve audit row names. */
+export function conflictResolveAuditsAt(db) {
+    // SAFETY: SELECT of two fields every conflict_resolve audit row carries (ConflictResolveMeta in store.ts).
+    return db.prepare(`SELECT json_extract(metadata_json, '$.conflictId') AS conflictId, json_extract(metadata_json, '$.loserId') AS loserId FROM audit_log WHERE op = 'conflict_resolve'`).all();
+}
+/** Every resolved conflict with both sides. */
+export function resolvedConflictsAt(db) {
+    // SAFETY: SELECT of three columns of resolved conflicts.
+    return db.prepare(`SELECT id, memory_a_id, memory_b_id FROM memory_conflicts WHERE status = 'resolved'`).all();
+}
 //# sourceMappingURL=conflicts.js.map