hippo-memory 1.72.0 → 2.1.0

package/dist/agent-memories/report.js

@@ -2,8 +2,24 @@
 import { AGENT_MEMORY_TOOLS } from '../core/agent-memory-tools.js';
 export function emptyTally() {
     return {
-        imported: 0, replaced: 0, restored: 0, setAside: 0, untagged: 0, unchanged: 0, adopted: 0, renamed: 0, collapsed: 0, retagged: 0,
-        handedOver: 0, duplicate: 0, secret: 0, short: 0, rejected: 0, unread: 0, unreadable: 0, busy: 0,
+        imported: 0,
+        replaced: 0,
+        restored: 0,
+        setAside: 0,
+        untagged: 0,
+        unchanged: 0,
+        adopted: 0,
+        renamed: 0,
+        collapsed: 0,
+        retagged: 0,
+        handedOver: 0,
+        duplicate: 0,
+        secret: 0,
+        short: 0,
+        rejected: 0,
+        unread: 0,
+        unreadable: 0,
+        busy: 0,
     };
 }
 const TALLY_FIELDS = Object.keys(emptyTally()).filter(isTallyField);
@@ -46,11 +62,24 @@ export function totalTally(report) {
 }
 const plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
 const TALLY_WORDS = {
-    imported: 'new', replaced: 'replaced', restored: 'brought back', setAside: 'set aside', untagged: 'pinned and kept',
-    unchanged: 'unchanged', adopted: 'taken over from the old Claude import', renamed: 'moved to the project id', collapsed: 'duplicates folded',
+    imported: 'new',
+    replaced: 'replaced',
+    restored: 'brought back',
+    setAside: 'set aside',
+    untagged: 'pinned and kept',
+    unchanged: 'unchanged',
+    adopted: 'taken over from the old Claude import',
+    renamed: 'moved to the project id',
+    collapsed: 'duplicates folded',
     retagged: 'retagged',
-    handedOver: 'handed over from the global store', duplicate: 'already stored', secret: 'skipped for a secret', short: 'too short',
-    rejected: 'skipped as rejected', unread: 'files skipped', unreadable: 'unreadable folders', busy: 'busy folders',
+    handedOver: 'handed over from the global store',
+    duplicate: 'already stored',
+    secret: 'skipped for a secret',
+    short: 'too short',
+    rejected: 'skipped as rejected',
+    unread: 'files skipped',
+    unreadable: 'unreadable folders',
+    busy: 'busy folders',
 };
 /** `hippo import --agents`: each tool's home, its folders and what moved; in a dry run, what would have. */
 export function detailLines(report, dryRun) {
@@ -64,12 +93,17 @@ export function detailLines(report, dryRun) {
         const moved = TALLY_FIELDS.filter((f) => t.tally[f] > 0).map((f) => `${t.tally[f]} ${TALLY_WORDS[f]}`);
         if (moved.length > 0)
             lines.push(`    ${dryRun ? 'would be ' : ''}${moved.join(', ')}`);
-        if (t.unlisted > 0)
-            lines.push(`    ${plural(t.unlisted, 'kept row sits', 'kept rows sit')} in folders not listed this run (a moved project's old copy)`);
+        if (t.unlisted > 0) {
+            lines.push(`    ${plural(t.unlisted, 'kept row sits', 'kept rows sit')} in folders not listed this run (a moved ` +
+                `project's old copy)`);
+        }
     }
     return lines;
 }
-/** "Imported 12 agent memories (Claude Code 10, Codex 2); 1 replaced, 1 set aside, 1 skipped for a secret.", or null when nothing moved. */
+/**
+ * "Imported 12 agent memories (Claude Code 10, Codex 2); 1 replaced, 1 set aside, 1 skipped for a secret.", or null
+ * when nothing moved.
+ */
 export function summaryLine(report) {
     const total = totalTally(report);
     const parts = [

package/dist/agent-memories/source.d.ts

@@ -2,7 +2,10 @@ import { type ToolId } from '../core/agent-memory-tools.js';
 import type { Scope } from './types.js';
 export declare const CONTENT_CAP = 1500;
 export declare const MIN_ITEM_CHARS = 10;
-/** `p-`/`u-` and 12 hex of the real path, so no user path reaches a row; `origin` parts projects sharing a folder in the global store. */
+/**
+ * `p-`/`u-` and 12 hex of the real path, so no user path reaches a row; `origin` parts projects sharing a folder in the
+ * global store.
+ */
 export declare function containerId(dir: string, scope: Scope, platform: NodeJS.Platform, origin?: string): string;
 export declare function containerPrefix(tool: ToolId, container: string): string;
 export declare function itemSource(prefix: string, key: string, text: string): string;
@@ -11,6 +14,9 @@ export declare function splitSource(source: string, prefix: string): {
     readonly key: string;
     readonly hash: string;
 };
-/** The text as stored: emails masked as on every capture path, then the old Claude import's cap; the hash still sees the raw note. */
+/**
+ * The text as stored: emails masked as on every capture path, then the old Claude import's cap; the hash still sees the
+ * raw note.
+ */
 export declare function storedText(text: string): string;
 //# sourceMappingURL=source.d.ts.map

package/dist/agent-memories/source.js

@@ -7,11 +7,16 @@ import { toolSourcePrefix } from '../core/agent-memory-tools.js';
 import { ID_SUFFIX_CHARS } from '../util/token-text.js';
 export const CONTENT_CAP = 1500;
 export const MIN_ITEM_CHARS = 10;
-/** `p-`/`u-` and 12 hex of the real path, so no user path reaches a row; `origin` parts projects sharing a folder in the global store. */
+/**
+ * `p-`/`u-` and 12 hex of the real path, so no user path reaches a row; `origin` parts projects sharing a folder in the
+ * global store.
+ */
 export function containerId(dir, scope, platform, origin = '') {
     const real = realpathOrResolve(dir).replace(/\\/g, '/');
     const folder = platform === 'win32' ? real.toLowerCase() : real;
-    return `${scope === 'project' ? 'p' : 'u'}-${sha256Hex(origin === '' ? folder : `${folder}\n${origin}`).slice(0, ID_SUFFIX_CHARS)}`;
+    const prefix = scope === 'project' ? 'p' : 'u';
+    const hash = sha256Hex(origin === '' ? folder : `${folder}\n${origin}`);
+    return `${prefix}-${hash.slice(0, ID_SUFFIX_CHARS)}`;
 }
 export function containerPrefix(tool, container) {
     return `${toolSourcePrefix(tool)}${container}/`;
@@ -25,7 +30,10 @@ export function splitSource(source, prefix) {
     const cut = rest.lastIndexOf('#');
     return cut < 0 ? { key: rest, hash: '' } : { key: rest.slice(0, cut), hash: rest.slice(cut + 1) };
 }
-/** The text as stored: emails masked as on every capture path, then the old Claude import's cap; the hash still sees the raw note. */
+/**
+ * The text as stored: emails masked as on every capture path, then the old Claude import's cap; the hash still sees the
+ * raw note.
+ */
 export function storedText(text) {
     const masked = maskEmails(text);
     return masked.length > CONTENT_CAP ? `${truncateCodePointSafe(masked, CONTENT_CAP)} [truncated]` : masked;

package/dist/agent-memories/sync.d.ts

@@ -18,7 +18,10 @@ export interface SyncOptions {
     /** How long a busy store is waited on before its containers are skipped. */
     readonly busyWaitMs?: number;
 }
-/** init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the global store the user pass only. */
+/**
+ * init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the
+ * global store the user pass only.
+ */
 export declare function importForStore(hippoRoot: string, opts: SyncOptions): ImportReport;
 /** A local store's project pass with legacy adoption; `init --scan` runs it per repository and the user pass once. */
 export declare function importProjectMemories(hippoRoot: string, opts: SyncOptions): ImportReport;
@@ -30,6 +33,8 @@ export declare function importAtSessionEnd(cwd: string, transcriptPath: string |
 /** The session folder's notes under the project Claude filed them for, never cwd's: a session begun at
  * home keeps its home notes user-global wherever it ends. No git call, so post-compact can run it. */
 export declare function importSessionFolder(hippoRoot: string, transcriptPath: string, cwd: string | null, opts: SyncOptions): ImportReport;
-/** The variable when set (empty or `none` is off); else the tools both the invoking and the target store's config allow. */
+/**
+ * The variable when set (empty or `none` is off); else the tools both the invoking and the target store's config allow.
+ */
 export declare function allowedTools(env: Machine['env'], invoking: string, target: string, warnings: string[]): Set<ToolId>;
 //# sourceMappingURL=sync.d.ts.map

package/dist/agent-memories/sync.js

@@ -1,22 +1,15 @@
-// Runs the adapters and routes each container to its store: the project pass, the user pass and their call sites (plan designs 2, 8, 11).
+// Runs the adapters and routes each container to its store: the project pass, the user pass and their call sites (plan
+// designs 2, 8, 11).
 import { processEnv } from '../util/env.js';
-import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { errorMessage } from '../util/log.js';
 import { loadConfig } from '../core/config.js';
-import { closeHippoDb, isSqliteBusy, openHippoDb, outsideRequestStores, withWriteScope } from '../db/index.js';
 import { namesFoldedInto } from './project-folds.js';
-import { projectTagReads } from '../store/project-tags.js';
 import { isGlobalStoreRoot, isInitialized, projectNames, resolveGlobalRootDir, resolveProjectIdentity, } from '../core/project-identity.js';
 import { duplicateKey, heldTextKeys } from '../util/same-text.js';
-import { removeEntryMirrors } from '../store/mirrors.js';
-import { initStore } from '../store/open.js';
-import { writeEntryMirrors } from '../store/entry-writes.js';
-import { selectLiveEntriesBySourcePrefix, selectRowsOutsideSourcePrefixAt } from '../store/entry-reads.js';
-import { updateStats } from '../store/index-and-stats.js';
-import { resolveTenantId } from '../store/tenant.js';
-import { setAsideRow } from '../store/set-aside.js';
+// The one store import: these entries are the import's composition root for the SQLite store.
+import { sqliteAgentImport } from '../store/sqlite/agent-import.js';
 import { syncContainer } from './apply.js';
 import { claudeCodeAdapter, claudeTranscriptListing, transcriptNotesProject } from './claude-code.js';
 import { codexAdapter } from './codex.js';
@@ -27,14 +20,24 @@ import { openclawAdapter } from './openclaw.js';
 import { qwenCodeAdapter } from './qwen-code.js';
 import { addTally, emptyReport, mergeReports, toolReport } from './report.js';
 import { containerId, containerPrefix, splitSource } from './source.js';
-import { AGENT_MEMORY_SOURCE_PREFIX, AGENT_MEMORY_TOOLS, isToolId, toolSourcePrefix } from '../core/agent-memory-tools.js';
-export const ADAPTERS = [claudeCodeAdapter, codexAdapter, geminiAdapter, copilotAdapter, openclawAdapter, qwenCodeAdapter];
+import { AGENT_MEMORY_SOURCE_PREFIX, AGENT_MEMORY_TOOLS, isToolId, toolSourcePrefix, } from '../core/agent-memory-tools.js';
+export const ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    geminiAdapter,
+    copilotAdapter,
+    openclawAdapter,
+    qwenCodeAdapter,
+];
 /** Overrides config because `hippo init` creates the store in the same command that imports (plan design 11). */
 export const TOOLS_ENV = 'HIPPO_AGENT_MEMORY_TOOLS';
 export function currentMachine() {
     return { home: os.homedir(), env: processEnv(), platform: process.platform };
 }
-/** init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the global store the user pass only. */
+/**
+ * init, sleep, `import --agents` and the daily runner: a local store gets its project pass then the user pass; the
+ * global store the user pass only.
+ */
 export function importForStore(hippoRoot, opts) {
     if (isGlobalStoreRoot(hippoRoot))
         return importUserMemories(hippoRoot, opts);
@@ -45,17 +48,29 @@ export function importForStore(hippoRoot, opts) {
 /** A local store's project pass with legacy adoption; `init --scan` runs it per repository and the user pass once. */
 export function importProjectMemories(hippoRoot, opts) {
     const ctx = context(opts.machine, { projectRoot: path.dirname(hippoRoot) });
-    return runPass({
-        scope: 'project', target: hippoRoot, invoking: hippoRoot, list: (a) => a.list(ctx, 'project'), legacy: true, originProject: undefined,
-        legacyOrigins: [], handover: true,
+    return runPass(sqliteAgentImport, {
+        scope: 'project',
+        target: hippoRoot,
+        invoking: hippoRoot,
+        list: (a) => a.list(ctx, 'project'),
+        legacy: true,
+        originProject: undefined,
+        legacyOrigins: [],
+        handover: true,
     }, opts);
 }
 /** Every tool's user-level memory into the global store, created on demand, with no origin. */
 export function importUserMemories(invokingRoot, opts) {
     const ctx = context(opts.machine, {});
-    return runPass({
-        scope: 'user', target: resolveGlobalRootDir(), invoking: invokingRoot, list: (a) => a.list(ctx, 'user'), legacy: false, originProject: '',
-        legacyOrigins: [], handover: false,
+    return runPass(sqliteAgentImport, {
+        scope: 'user',
+        target: resolveGlobalRootDir(),
+        invoking: invokingRoot,
+        list: (a) => a.list(ctx, 'user'),
+        legacy: false,
+        originProject: '',
+        legacyOrigins: [],
+        handover: false,
     }, opts);
 }
 /** Session end in a folder with no store of its own: the session's project into the
@@ -63,7 +78,7 @@ export function importUserMemories(invokingRoot, opts) {
 export function importAtSessionEnd(cwd, transcriptPath, opts) {
     const globalRoot = resolveGlobalRootDir();
     const ctx = context(opts.machine, { projectRoot: cwd });
-    const report = runPass({
+    const report = runPass(sqliteAgentImport, {
         scope: 'project', target: globalRoot, invoking: globalRoot, list: (a) => a.list(ctx, 'project'), legacy: false,
         ...projectOrigins(resolveProjectIdentity(cwd)), handover: false,
     }, opts);
@@ -78,11 +93,12 @@ export function importSessionFolder(hippoRoot, transcriptPath, cwd, opts) {
     const project = transcriptNotesProject(transcriptPath, cwd, opts.machine);
     if (project === null)
         return emptyReport();
-    // A project store takes its own project's notes; another project's, or home's, go to the global store, which parts them by origin.
+    // A project store takes its own project's notes; another project's, or home's, go to the global store, which parts
+    // them by origin.
     const own = isGlobalStoreRoot(hippoRoot) || project.name === resolveProjectIdentity(path.dirname(hippoRoot)).name;
     const target = own ? hippoRoot : resolveGlobalRootDir();
     const ctx = context(opts.machine, {});
-    return runPass({
+    return runPass(sqliteAgentImport, {
         scope: 'project', target, invoking: hippoRoot, legacy: false, ...projectOrigins(project), handover: false,
         list: (a) => (a.tool === 'claude-code' ? claudeTranscriptListing(ctx, transcriptPath) : null),
     }, opts);
@@ -93,11 +109,18 @@ function projectOrigins(project) {
 function context(machine, extra) {
     return { home: machine.home, env: machine.env, platform: machine.platform, ...extra };
 }
-/** The variable when set (empty or `none` is off); else the tools both the invoking and the target store's config allow. */
+/**
+ * The variable when set (empty or `none` is off); else the tools both the invoking and the target store's config allow.
+ */
 export function allowedTools(env, invoking, target, warnings) {
     const fromEnv = env[TOOLS_ENV];
     if (fromEnv !== undefined) {
-        const listed = fromEnv.trim().toLowerCase() === 'none' ? [] : fromEnv.split(',').map((t) => t.trim()).filter((t) => t !== '');
+        const listed = fromEnv.trim().toLowerCase() === 'none'
+            ? []
+            : fromEnv
+                .split(',')
+                .map((t) => t.trim())
+                .filter((t) => t !== '');
         return knownTools(listed, TOOLS_ENV, warnings);
     }
     const mine = configuredTools(invoking, warnings);
@@ -111,14 +134,17 @@ function configuredTools(root, warnings) {
 function knownTools(ids, where, warnings) {
     const out = new Set();
     for (const id of ids) {
-        if (isToolId(id))
+        if (isToolId(id)) {
             out.add(id);
-        else
-            warnings.push(`${where}: unknown agent memory tool "${id}" ignored (known: ${AGENT_MEMORY_TOOLS.map((t) => t.id).join(', ')})`);
+        }
+        else {
+            warnings.push(`${where}: unknown agent memory tool "${id}" ignored (known: ` +
+                `${AGENT_MEMORY_TOOLS.map((t) => t.id).join(', ')})`);
+        }
     }
     return out;
 }
-function runPass(pass, opts) {
+function runPass(ai, pass, opts) {
     const report = emptyReport();
     const allowed = allowedTools(opts.machine.env, pass.invoking, pass.target, report.warnings);
     const listings = ADAPTERS.filter((a) => allowed.has(a.tool)).flatMap((a) => listSafely(a, pass, report));
@@ -126,18 +152,18 @@ function runPass(pass, opts) {
     let store = null;
     let synced = [];
     try {
-        store = openTarget(pass.target, hasItems, opts);
+        store = openTarget(ai, pass.target, hasItems, opts);
         if (store !== null)
             synced = syncStore(pass, listings, store, opts, report);
     }
     catch (err) {
-        report.warnings.push(`agent memories not synced into ${pass.target}: ${isSqliteBusy(err) ? 'the store was busy' : errorMessage(err)}`);
+        report.warnings.push(`agent memories not synced into ${pass.target}: ${ai.isBusy(err) ? 'the store was busy' : errorMessage(err)}`);
     }
     finally {
-        store?.close();
+        store?.target.close();
     }
     if (pass.handover && !opts.dryRun)
-        handOver(synced, path.dirname(pass.target), opts, report);
+        handOver(ai, synced, path.dirname(pass.target), opts, report);
     return report;
 }
 function listSafely(adapter, pass, report) {
@@ -156,51 +182,48 @@ function listSafely(adapter, pass, report) {
         tool.homes.push(listing.home);
     report.warnings.push(...listing.warnings.map((w) => `${tool.label}: ${w}`));
     for (const c of listing.containers) {
-        tool.containers.push({ scope: c.scope, path: c.path, store: pass.target, items: c.items.length, readable: c.readable });
+        tool.containers.push({
+            scope: c.scope,
+            path: c.path,
+            store: pass.target,
+            items: c.items.length,
+            readable: c.readable,
+        });
         report.warnings.push(...c.warnings.map((w) => `${tool.label}: ${w}`));
     }
     return [listing];
 }
-/** A store that does not exist yet is created only when there is something to put in it; a dry run plans against an empty stand-in. */
-function openTarget(target, hasItems, opts) {
+/**
+ * A store that does not exist yet is created only when there is something to put in it; a dry run plans against an
+ * empty stand-in.
+ */
+function openTarget(ai, target, hasItems, opts) {
     const global = isGlobalStoreRoot(target);
     if (!isInitialized(target)) {
         if (opts.dryRun)
-            return emptyStandIn(global);
+            return { ai, target: ai.openStandIn(), global };
         if (!hasItems)
             return null;
-        initStore(target);
+        ai.create(target);
     }
-    const db = openHippoDb(target, { busyWaitMs: opts.busyWaitMs });
-    return { db, root: target, global, close: () => closeHippoDb(db) };
+    return { ai, target: ai.open(target, { busyWaitMs: opts.busyWaitMs }), global };
 }
-function emptyStandIn(global) {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'hippo-agent-memories-'));
-    // Its folder is deleted at close, so a request scope must not keep the file open past that.
-    const db = outsideRequestStores(() => openHippoDb(root));
+function storeSession(pass, store, opts, legacy) {
     return {
-        db, root, global,
-        close: () => {
-            closeHippoDb(db);
-            fs.rmSync(root, { recursive: true, force: true });
-        },
-    };
-}
-function syncStore(pass, listings, store, opts, report) {
-    const tenantId = resolveTenantId({});
-    const legacy = pass.legacy ? legacyWork(store.db, tenantId, listings) : null;
-    const session = {
-        db: store.db,
-        hippoRoot: store.root,
-        tenantId,
-        baseHalfLifeDays: loadConfig(store.root).defaultHalfLifeDays,
+        target: store.target,
+        tenantId: store.target.tenantId,
+        baseHalfLifeDays: loadConfig(store.target.root).defaultHalfLifeDays,
         originProject: pass.originProject,
-        isDuplicate: duplicateCheck(store, tenantId, [pass.originProject ?? '', ...pass.legacyOrigins], legacy?.adopted ?? new Set()),
+        isDuplicate: duplicateCheck(store, [pass.originProject ?? '', ...pass.legacyOrigins], legacy?.adopted ?? new Set()),
         dryRun: opts.dryRun === true,
     };
+}
+function syncStore(pass, listings, store, opts, report) {
+    const legacy = pass.legacy ? legacyWork(store.target, listings) : null;
+    const session = storeSession(pass, store, opts, legacy);
     // A project's rows in the global store are parted by origin: a worktree and its main checkout share a Claude folder.
-    const partition = store.global && pass.scope === 'project' ? pass.originProject ?? '' : null;
-    const earlier = partition === null || partition === '' ? [] : earlierNames(store.db, tenantId, partition, pass.legacyOrigins);
+    const partition = store.global && pass.scope === 'project' ? (pass.originProject ?? '') : null;
+    const earlier = partition === null || partition === '' ? [] : earlierNames(store.target, partition, pass.legacyOrigins);
     const synced = [];
     let remembered = 0;
     for (const listing of listings) {
@@ -211,28 +234,38 @@ function syncStore(pass, listings, store, opts, report) {
                 out.tally.unreadable++;
                 continue;
             }
-            const work = containerWork(tool, container, { platform: opts.machine.platform, legacy, origin: partition ?? '', earlier });
-            const outcome = syncOne(session, work, out, report);
+            const work = containerWork(tool, container, {
+                platform: opts.machine.platform,
+                legacy,
+                origin: partition ?? '',
+                earlier,
+            });
+            const outcome = syncOne(store.ai, session, work, { out, report });
             if (outcome === null)
                 continue;
             synced.push(work);
             remembered += outcome.tally.imported + outcome.tally.replaced;
             if (!session.dryRun)
-                afterCommit(store.root, outcome, report);
+                afterCommit(store.target, outcome, report);
         }
-        if (session.dryRun)
-            out.unlisted += unlistedRows(store.db, tenantId, {
-                tool, scope: pass.scope, listing, platform: opts.machine.platform, partition: partition === null ? null : [partition, ...earlier],
+        if (session.dryRun) {
+            out.unlisted += unlistedRows(store.target, {
+                tool,
+                scope: pass.scope,
+                listing,
+                platform: opts.machine.platform,
+                partition: partition === null ? null : [partition, ...earlier],
             });
+        }
     }
     if (remembered > 0 && !session.dryRun)
-        bumpRemembered(store.root, remembered, report);
+        bumpRemembered(store.target, remembered, report);
     return synced;
 }
 /** The legacy names plus every name a merge or repair folded into the project; the audit read runs once per pass. */
-function earlierNames(db, tenantId, id, legacyOrigins) {
+function earlierNames(target, id, legacyOrigins) {
     const names = [id, ...legacyOrigins];
-    return [...legacyOrigins, ...namesFoldedInto(projectTagReads(db, tenantId), names)].filter((n) => n !== '' && n !== id);
+    return [...legacyOrigins, ...namesFoldedInto(target.projectTagReads(), names)].filter((n) => n !== '' && n !== id);
 }
 function containerWork(tool, container, options) {
     const { platform, legacy, origin, earlier } = options;
@@ -248,15 +281,18 @@ function containerWork(tool, container, options) {
         legacyPrefixes: earlier.map(prefixOf),
     };
 }
-/** Null when the container was skipped: a busy store waits for the next sync, any other failure is a warning and the sync goes on. */
-function syncOne(session, work, out, report) {
+/**
+ * Null when the container was skipped: a busy store waits for the next sync, any other failure is a warning and the
+ * sync goes on.
+ */
+function syncOne(ai, session, work, { out, report }) {
     try {
         const outcome = syncContainer(session, work);
         addTally(out.tally, outcome.tally);
         return outcome;
     }
     catch (err) {
-        if (isSqliteBusy(err)) {
+        if (ai.isBusy(err)) {
             out.tally.busy++;
             report.warnings.push(`${out.label}: ${work.container.path} skipped, the store was busy`);
         }
@@ -266,12 +302,12 @@ function syncOne(session, work, out, report) {
         return null;
     }
 }
-function afterCommit(root, outcome, report) {
+function afterCommit(target, outcome, report) {
     for (const entry of outcome.mirror)
-        writeEntryMirrors(root, entry);
+        target.writeMirror(entry);
     for (const id of outcome.purge) {
         try {
-            removeEntryMirrors(root, id);
+            target.removeMirror(id);
         }
         catch (err) {
             // rebuildIndex would bring the row back live, and the next sync sets it aside again.
@@ -279,70 +315,74 @@ function afterCommit(root, outcome, report) {
         }
     }
 }
-function bumpRemembered(root, remembered, report) {
+function bumpRemembered(target, remembered, report) {
     try {
-        updateStats(root, { remembered });
+        target.bumpRemembered(remembered);
     }
     catch (err) {
         report.warnings.push(`remembered counter not updated: ${errorMessage(err)}`);
     }
 }
-/** Design 6: only text stored by another path counts, and in the global store only rows visible where the new row goes. */
-function duplicateCheck(store, tenantId, origins, adopted) {
+/**
+ * Design 6: only text stored by another path counts, and in the global store only rows visible where the new row goes.
+ */
+function duplicateCheck(store, origins, adopted) {
     let keys = null;
     return (text) => {
-        keys ??= otherPathKeys(store, tenantId, origins, adopted);
+        keys ??= otherPathKeys(store, origins, adopted);
         return keys.has(duplicateKey(text));
     };
 }
-function otherPathKeys(store, tenantId, origins, adopted) {
-    const rows = selectRowsOutsideSourcePrefixAt(store.db, tenantId, AGENT_MEMORY_SOURCE_PREFIX, store.global ? origins : null);
+function otherPathKeys(store, origins, adopted) {
+    const rows = store.target.rowsOutsideSourcePrefix(AGENT_MEMORY_SOURCE_PREFIX, store.global ? origins : null);
     return new Set(rows.filter((r) => !adopted.has(r.id)).flatMap(heldTextKeys));
 }
-function unlistedRows(db, tenantId, options) {
+function unlistedRows(target, options) {
     const { tool, scope, listing, platform, partition } = options;
     const listed = listing.containers.flatMap((c) => (partition ?? ['']).map((name) => containerPrefix(tool.id, containerId(c.path, c.scope, platform, name))));
-    return selectLiveEntriesBySourcePrefix(db, tenantId, `${toolSourcePrefix(tool.id)}${scope === 'project' ? 'p' : 'u'}-`)
+    return target
+        .liveBySourcePrefix(`${toolSourcePrefix(tool.id)}${scope === 'project' ? 'p' : 'u'}-`)
         .filter((row) => row.tags.includes(tool.tag) && !listed.some((p) => row.source.startsWith(p)))
         .filter((row) => partition === null || partition.includes(row.origin_project ?? '')).length;
 }
-/** Design 2's handover: rows the store-less hook path left in the global store, under this project's origin, for containers its store now syncs. */
-function handOver(synced, projectRoot, opts, report) {
+/**
+ * Design 2's handover: rows the store-less hook path left in the global store, under this project's origin, for
+ * containers its store now syncs.
+ */
+function handOver(ai, synced, projectRoot, opts, report) {
     const globalRoot = resolveGlobalRootDir();
     if (synced.length === 0 || !isInitialized(globalRoot))
         return;
-    let db;
+    let target;
     try {
-        db = openHippoDb(globalRoot, { busyWaitMs: opts.busyWaitMs });
-        const tenantId = resolveTenantId({});
+        target = ai.open(globalRoot, { busyWaitMs: opts.busyWaitMs });
         // A folder with no git and no marker wrote as '' before its store existed, and as its own name after.
         // Names folded into this project's in the global store were its rows too.
         const names = projectNames(resolveProjectIdentity(projectRoot));
-        const origins = [...new Set([...names, ...namesFoldedInto(projectTagReads(db, tenantId), names), ''])];
+        const origins = [...new Set([...names, ...namesFoldedInto(target.projectTagReads(), names), ''])];
         for (const work of synced)
-            handOverContainer(db, globalRoot, tenantId, work, { origins, platform: opts.machine.platform, report });
+            handOverContainer(target, work, { origins, platform: opts.machine.platform, report });
     }
     catch (err) {
-        report.warnings.push(`global copies not handed over: ${isSqliteBusy(err) ? 'the global store was busy' : errorMessage(err)}`);
+        report.warnings.push(`global copies not handed over: ${ai.isBusy(err) ? 'the global store was busy' : errorMessage(err)}`);
     }
     finally {
-        if (db)
-            closeHippoDb(db);
+        target?.close();
     }
 }
-function handOverContainer(db, root, tenantId, work, options) {
+function handOverContainer(target, work, options) {
     const { origins, platform, report } = options;
     // A note the local pass could not read has no local row yet, so its global copy stays until it does.
     const unread = new Set(work.container.skipped);
     const mirror = [];
     const purge = [];
-    withWriteScope(db, 'hand_over_container', () => {
+    target.inContainer('hand_over_container', false, (tx) => {
         for (const origin of origins) {
             const prefix = containerPrefix(work.tool.id, containerId(work.container.path, work.container.scope, platform, origin));
-            for (const row of selectLiveEntriesBySourcePrefix(db, tenantId, prefix)) {
+            for (const row of tx.liveBySourcePrefix(target.tenantId, prefix)) {
                 if (!row.tags.includes(work.tool.tag) || unread.has(splitSource(row.source, prefix).key))
                     continue;
-                const result = setAsideRow(db, work.tool.tag, row, 'handover');
+                const result = tx.setAside(work.tool.tag, row, 'handover');
                 if (result.kind === 'untagged')
                     mirror.push(result.entry);
                 else
@@ -351,7 +391,7 @@ function handOverContainer(db, root, tenantId, work, options) {
         }
     });
     toolReport(report, work.tool.id).tally.handedOver += mirror.length + purge.length;
-    afterCommit(root, { mirror, purge }, report);
+    afterCommit(target, { mirror, purge }, report);
 }
 function toolOf(id) {
     const tool = AGENT_MEMORY_TOOLS.find((t) => t.id === id);

package/dist/api/assemble.d.ts

@@ -1,5 +1,5 @@
 import type { CallerProject } from './prompt-hook.js';
-import type { Context } from './types.js';
+import type { ContextWith } from './types.js';
 export declare const DEFAULT_ASSEMBLE_BUDGET = 4000;
 export interface AssembleOpts {
     /** Token budget. Default DEFAULT_ASSEMBLE_BUDGET. */
@@ -42,14 +42,16 @@ export interface AssembleResult {
     sessionId: string;
     items: AssembledContextItem[];
     tokens: number;
-    /** Tenant + scope-filtered raw row count, uncapped by `rowCap`, so "session has N msgs" stays accurate for a windowed items[]. */
+    /** Tenant + scope-filtered raw row count, uncapped by `rowCap`,
+     * so "session has N msgs" stays accurate for a windowed items[]. */
     totalRaw: number;
     summarized: number;
     evicted: number;
     /** True when `rowCap` truncated the window; the cap keeps the NEWEST rows, so older rows beyond it are absent. */
     truncated: boolean;
 }
-/** Chronological context window for a session; over budget, evicts the lowest-strength non-fresh-tail item first (fresh tail is never evicted).
+/** Chronological context window for a session; over budget, evicts the lowest-strength non-fresh-tail item first (fresh
+ *  tail is never evicted).
  * Returns `items: []` for an empty sessionId, no raws, or when every row fails the scope/tenant filter. */
-export declare function assemble(ctx: Context, sessionId: string, opts?: AssembleOpts): Promise<AssembleResult>;
+export declare function assemble(ctx: ContextWith<'dagReads'>, sessionId: string, opts?: AssembleOpts): Promise<AssembleResult>;
 //# sourceMappingURL=assemble.d.ts.map