hippo-memory 2.0.0 → 2.1.0

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

package/dist/api/assemble.js

@@ -1,13 +1,12 @@
 // Session context assembly under a token budget.
-import { requireGroup } from '../store/index.js';
-import { storeFor } from '../store/sqlite/store.js';
 import { estimateTokens } from '../util/token-text.js';
 import { passesScopeFilterForRecall, assertScopeRequestAllowed, personalScopeOf } from '../core/recall-scope.js';
 import { classifyOriginProject, projectNames } from '../core/project-identity.js';
 const DEFAULT_FRESH_TAIL_COUNT = 10;
 const DEFAULT_ROW_CAP = 5000;
 export const DEFAULT_ASSEMBLE_BUDGET = 4000;
-/** 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 async function assemble(ctx, sessionId, opts = {}) {
     assertScopeRequestAllowed(ctx.actor, opts.scope);
@@ -44,7 +43,7 @@ export async function assemble(ctx, sessionId, opts = {}) {
 async function loadScopedRaws(ctx, sessionId, opts, own) {
     const rowCap = opts.rowCap ?? DEFAULT_ROW_CAP;
     const origins = opts.project ? projectNames(opts.project) : undefined;
-    const dag = requireGroup(storeFor(ctx), 'dagReads');
+    const dag = ctx.store.dagReads;
     const rows = await dag.sessionRawEntries({ tenantId: ctx.tenantId, sessionId, cap: rowCap, origins });
     const truncated = rows.length === rowCap;
     // `scoped.length` under-counts a capped session, so totalRaw falls back to a COUNT below.
@@ -53,7 +52,13 @@ async function loadScopedRaws(ctx, sessionId, opts, own) {
     if (truncated) {
         // The COUNT applies the same default-deny scope rule in SQL, so a no-scope
         // caller cannot infer private rows by comparing totalRaw to items.length.
-        totalRaw = await dag.sessionRawCount({ tenantId: ctx.tenantId, sessionId, scope: opts.scope, ownScope: own, origins });
+        totalRaw = await dag.sessionRawCount({
+            tenantId: ctx.tenantId,
+            sessionId,
+            scope: opts.scope,
+            ownScope: own,
+            origins,
+        });
     }
     else {
         totalRaw = scoped.length;
@@ -90,7 +95,7 @@ async function substituteSummaries(ctx, olderRows, scope, own, project) {
     }
     const eligibleParentIds = Array.from(olderByParent.keys()).filter((pid) => (olderByParent.get(pid)?.length ?? 0) >= 2);
     const parents = eligibleParentIds.length > 0
-        ? (await storeFor(ctx).entriesByIds(eligibleParentIds, ctx.tenantId))
+        ? (await ctx.store.entriesByIds(eligibleParentIds, ctx.tenantId))
             .filter((p) => (p.dag_level ?? 0) === 2 && !p.superseded_by)
             .filter((p) => passesScopeFilterForRecall(p.scope ?? null, scope, own))
             .filter((p) => !project || classifyOriginProject(p.origin_project, project) !== 'cross-project')

package/dist/api/{audit.d.ts → auth/audit.d.ts}

@@ -1,8 +1,8 @@
-import type { AuditEvent, AuditOp } from '../store/audit.js';
-import { type AuditIssue, type AuditResult } from '../core/memory-audit.js';
-import type { QualityRepairResult } from '../store/quality-repair.js';
-import type { KeysetPosition } from '../util/keyset.js';
-import type { Context } from './types.js';
+import type { AuditEvent, AuditOp } from '../../store/audit.js';
+import { type AuditIssue, type AuditResult } from '../../core/memory-audit.js';
+import type { QualityRepairResult } from '../../store/quality-repair.js';
+import type { KeysetPosition } from '../../util/keyset.js';
+import type { ContextWith } from '../types.js';
 export interface AuditListOpts {
     op?: AuditOp;
     /** ISO timestamp lower bound. */
@@ -12,17 +12,19 @@ export interface AuditListOpts {
     after?: KeysetPosition;
 }
 /** Read audit events scoped to `ctx.tenantId` on the store the request runs on. Read-only, no audit emit. */
-export declare function auditList(ctx: Context, opts: AuditListOpts): Promise<AuditEvent[]>;
+export declare function auditList(ctx: ContextWith<'auditLog'>, opts: AuditListOpts): Promise<AuditEvent[]>;
 /** The pass that removes audit errors; it leads the reason on each forget row. */
 export type AuditPass = 'audit --fix' | 'sleep-audit';
-/** Delete the memories an audit marked as errors, each with its own forget row, and answer the ids that went: a pinned or raw row stays. */
-export declare function removeAuditErrors(ctx: Context, pass: AuditPass, issues: readonly AuditIssue[]): Promise<string[]>;
+/** Delete the memories an audit marked as errors, each with its own forget row, and answer the ids that went: a pinned
+ * or raw row stays. */
+export declare function removeAuditErrors(ctx: ContextWith<'auditMaintenance'>, pass: AuditPass, issues: readonly AuditIssue[]): Promise<string[]>;
 /** The caller's memories run through the quality audit; a memory that backs an object is never marked for removal. */
-export declare function auditMemoryQuality(ctx: Context): Promise<AuditResult>;
-/** Audit repair for the caller's tenant: a preview, or with `apply` the moves of certain defects to dormant storage behind a backup. */
-export declare function repairMemoryQuality(ctx: Context, apply: boolean): Promise<QualityRepairResult>;
+export declare function auditMemoryQuality(ctx: ContextWith<'auditMaintenance'>): Promise<AuditResult>;
+/** Audit repair for the caller's tenant: a preview, or with `apply` the moves of certain defects to dormant storage
+ * behind a backup. */
+export declare function repairMemoryQuality(ctx: ContextWith<'auditMaintenance'>, apply: boolean): Promise<QualityRepairResult>;
 /** The repair sleep and the daily runner apply once per store after an upgrade; null when it already ran there. */
-export declare function repairMemoryQualityOnce(ctx: Context): Promise<QualityRepairResult | null>;
+export declare function repairMemoryQualityOnce(ctx: ContextWith<'auditMaintenance'>): Promise<QualityRepairResult | null>;
 export interface PruneAuditOpts {
     /** Cutoff in days. Rows with `ts < (now - N days)` are deleted. */
     olderThanDays: number;
@@ -39,8 +41,8 @@ export interface PruneAuditResult {
 }
 /** Cutoff ISO timestamp for N days ago; exported so tests can pin "now" without mocking Date. */
 export declare function computeCutoff(days: number, now?: Date): string;
-/** Delete the caller's tenant's audit_log rows older than `olderThanDays`, then record an `audit_prune` row as `ctx.actor`; opt-in, since
- *  retention floors (HIPAA, SOX, GDPR) apply. The row is written after the DELETE, so a call never prunes its own record.
- *  Throws on non-positive days or an empty tenant. */
-export declare function pruneAuditLog(ctx: Context, opts: PruneAuditOpts): Promise<PruneAuditResult>;
+/** Delete the caller's tenant's audit_log rows older than `olderThanDays`, then record an `audit_prune` row as
+ * `ctx.actor`; opt-in, since retention floors (HIPAA, SOX, GDPR) apply. The row is written after the DELETE, so a call
+ * never prunes its own record. Throws on non-positive days or an empty tenant. */
+export declare function pruneAuditLog(ctx: ContextWith<'auditMaintenance'>, opts: PruneAuditOpts): Promise<PruneAuditResult>;
 //# sourceMappingURL=audit.d.ts.map