hippo-memory 2.0.0 → 2.1.0

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

@@ -1,11 +1,10 @@
-import { type DatabaseSyncLike } from '../db/index.js';
 import { type MemoryEntry } from '../core/memory.js';
+import type { ImportTarget } from '../store/port/agent-import.js';
 import { type Tally } from './report.js';
-import type { AgentMemoryTool } from '../core/agent-memory-tools.js';
+import { type AgentMemoryTool } from '../core/agent-memory-tools.js';
 import type { Container } from './types.js';
 export interface StoreSession {
-    readonly db: DatabaseSyncLike;
-    readonly hippoRoot: string;
+    readonly target: ImportTarget;
     readonly tenantId: string;
     readonly baseHalfLifeDays: number;
     /** Stamped on written rows; undefined lets the store stamp its own project. */
@@ -23,7 +22,10 @@ export interface ContainerWork {
     readonly adopt: ReadonlyMap<string, readonly MemoryEntry[]>;
     /** Legacy rows a new row of the key supersedes, by key (second round). */
     readonly replace: ReadonlyMap<string, readonly MemoryEntry[]>;
-    /** This container's prefixes under the project's earlier names; their rows move here, so a new id imports nothing twice. */
+    /**
+     * This container's prefixes under the project's earlier names; their rows move here, so a new id imports nothing
+     * twice.
+     */
     readonly legacyPrefixes: readonly string[];
 }
 export interface ContainerOutcome {

package/dist/agent-memories/apply.js

@@ -1,28 +1,19 @@
-// One container's sync in one transaction on the caller's handle: lookup, plan, then every write (plan designs 6 to 8).
-import { appendAuditEvent } from '../store/audit.js';
-import { withTrialScope, withWriteScope } from '../db/index.js';
-import { deleteDormantRow, dormantSnapshotsBySourcePrefix, readDormantSnapshot, replaceDormantEntry } from '../store/dormant.js';
-import { gatedWrite } from '../store/gated-write.js';
+// One container's sync in one transaction on the target store: lookup, plan, then every write (plan designs 6 to 8).
 import { strengthAblation } from '../core/ablation.js';
 import { Layer, calculateStrength, createMemory } from '../core/memory.js';
-import { findRejectedValue, rejectionDigest } from '../store/rejection.js';
 import { redactSecretsStrict } from '../util/secret-detect.js';
-import { stampOriginProject } from '../store/entry-row.js';
-import { renameEntrySourceAndOriginAt, renameEntrySourceAt, setEntryTagsInTx, supersedeEntryAt } from '../store/entry-writes.js';
-import { SYNC_ACTOR, setAsideRow } from '../store/set-aside.js';
-import { entryIdTakenAt, selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
-import { markSummaryDirtyInTx } from '../store/summary-dirty.js';
 import { itemHash } from './keys.js';
 import { planContainer } from './plan.js';
 import { emptyTally } from './report.js';
 import { MIN_ITEM_CHARS, itemSource, splitSource, storedText } from './source.js';
+import { SYNC_ACTOR } from '../core/agent-memory-tools.js';
 /** Throws SQLITE_BUSY when another writer holds the store past its busy timeout; nothing is written then. */
 export function syncContainer(s, work) {
-    const run = () => new ContainerRun(s, work).run();
-    return s.dryRun ? withTrialScope(s.db, 'sync_container', run) : withWriteScope(s.db, 'sync_container', run);
+    return s.target.inContainer('sync_container', s.dryRun, (tx) => new ContainerRun(s, tx, work).run());
 }
 class ContainerRun {
     s;
+    tx;
     w;
     tally = emptyTally();
     mirror = [];
@@ -30,8 +21,9 @@ class ContainerRun {
     rows = new Map();
     items = new Map();
     tag;
-    constructor(s, w) {
+    constructor(s, tx, w) {
         this.s = s;
+        this.tx = tx;
         this.w = w;
         this.tag = w.tool.tag;
         for (const item of w.container.items)
@@ -41,14 +33,18 @@ class ContainerRun {
         this.adoptLegacy();
         for (const old of this.w.legacyPrefixes)
             this.adoptPrefix(old);
-        const live = selectLiveEntriesBySourcePrefix(this.s.db, this.s.tenantId, this.w.prefix);
+        const live = this.tx.liveBySourcePrefix(this.s.tenantId, this.w.prefix);
         for (const row of [...live, ...[...this.w.replace.values()].flat()])
             this.rows.set(row.id, row);
         const refusals = this.refusals();
         const liveRows = live.map((row) => this.liveRow(row));
         const plan = planContainer({
             textKeyed: this.w.container.textKeyed,
-            items: this.w.container.items.map((item) => ({ key: item.key, hash: itemHash(item.text), refused: refusals.has(item.key) })),
+            items: this.w.container.items.map((item) => ({
+                key: item.key,
+                hash: itemHash(item.text),
+                refused: refusals.has(item.key),
+            })),
             skipped: this.w.container.skipped,
             live: liveRows,
             dormant: this.dormantRows(new Set(liveRows.map((r) => r.key)), refusals),
@@ -84,30 +80,41 @@ class ContainerRun {
                 continue;
             const source = itemSource(this.w.prefix, key, item.text);
             for (const row of rows) {
-                if (renameEntrySourceAt(this.s.db, row.tenant_id, row.id, row.source, source) === 0)
+                if (this.tx.renameSource(row.tenant_id, row.id, row.source, source) === 0)
                     continue;
                 this.tally.adopted++;
                 this.mirror.push({ ...row, source });
             }
         }
     }
-    /** Rows filed under an earlier project name keep their id and history; dormant ones move too, scanned only until this prefix holds live rows. */
+    /**
+     * Rows filed under an earlier project name keep their id and history; dormant ones move too, scanned only until this
+     * prefix holds live rows.
+     */
     adoptPrefix(old) {
         const origin = this.s.originProject ?? null;
         let moved = 0;
-        for (const row of selectLiveEntriesBySourcePrefix(this.s.db, this.s.tenantId, old)) {
+        for (const row of this.tx.liveBySourcePrefix(this.s.tenantId, old)) {
             const source = this.w.prefix + row.source.slice(old.length);
-            if (renameEntrySourceAndOriginAt(this.s.db, row.tenant_id, row.id, { from: row.source, to: source, origin }) === 0)
+            if (this.tx.renameSourceAndOrigin(row.tenant_id, row.id, { from: row.source, to: source, origin }) === 0) {
                 continue;
+            }
             moved++;
             this.mirror.push({ ...row, source, origin_project: origin ?? row.origin_project });
         }
         this.tally.renamed += moved;
-        if (moved === 0 && (this.w.container.items.length === 0 || selectLiveEntriesBySourcePrefix(this.s.db, this.s.tenantId, this.w.prefix).length > 0))
+        if (moved === 0 &&
+            (this.w.container.items.length === 0 ||
+                this.tx.liveBySourcePrefix(this.s.tenantId, this.w.prefix).length > 0)) {
             return;
-        for (const snap of dormantSnapshotsBySourcePrefix(this.s.db, this.s.tenantId, old)) {
+        }
+        for (const snap of this.tx.dormantBySourcePrefix(this.s.tenantId, old)) {
             const source = this.w.prefix + snap.entry.source.slice(old.length);
-            replaceDormantEntry(this.s.db, this.s.tenantId, snap.entry.id, { ...snap.entry, source, origin_project: origin ?? snap.entry.origin_project });
+            this.tx.replaceDormant(this.s.tenantId, snap.entry.id, {
+                ...snap.entry,
+                source,
+                origin_project: origin ?? snap.entry.origin_project,
+            });
         }
     }
     refusals() {
@@ -126,35 +133,51 @@ class ContainerRun {
         // Imported rows reach prompts, so the bar is text leaving the machine: Bearer headers and JWTs count too.
         if (redactSecretsStrict(item.text) !== item.text)
             return 'secret';
-        if (findRejectedValue(this.s.db, this.s.tenantId, rejectionDigest(storedText(item.text))) !== null)
+        if (this.tx.isRejected(this.s.tenantId, storedText(item.text))) {
             return 'rejected';
+        }
         return null;
     }
     liveRow(row) {
-        return { id: row.id, ...splitSource(row.source, this.w.prefix), tagged: row.tags.includes(this.tag), created: row.created };
+        return {
+            id: row.id,
+            ...splitSource(row.source, this.w.prefix),
+            tagged: row.tags.includes(this.tag),
+            created: row.created,
+        };
     }
     /** Read only when a present key has no live row, which after the first import is rare. */
     dormantRows(liveKeys, refusals) {
         const needed = this.w.container.items.some((item) => !refusals.has(item.key) && !liveKeys.has(item.key));
         if (!needed)
             return [];
-        return dormantSnapshotsBySourcePrefix(this.s.db, this.s.tenantId, this.w.prefix)
+        return this.tx.dormantBySourcePrefix(this.s.tenantId, this.w.prefix)
             .filter((snap) => !snap.entry.superseded_by)
-            .map((snap) => ({ id: snap.entry.id, ...splitSource(snap.entry.source, this.w.prefix), dormantAt: snap.dormantAt }));
+            .map((snap) => ({
+            id: snap.entry.id,
+            ...splitSource(snap.entry.source, this.w.prefix),
+            dormantAt: snap.dormantAt,
+        }));
     }
     retag(row) {
         const tagged = { ...row, tags: [...row.tags, this.tag] };
-        setEntryTagsInTx(this.s.db, tagged);
+        this.tx.setTags(tagged);
         this.tally.retagged++;
         this.mirror.push(tagged);
     }
     /** api.supersede's steps on this transaction; false when another writer superseded the row first. */
     supersede(old, newId) {
-        if (!supersedeEntryAt(this.s.db, old.tenant_id, old.id, newId))
+        if (!this.tx.supersede(old.tenant_id, old.id, newId))
             return false;
         if (old.dag_parent_id)
-            markSummaryDirtyInTx(this.s.db, old.dag_parent_id, old.tenant_id, SYNC_ACTOR);
-        appendAuditEvent(this.s.db, { tenantId: old.tenant_id, actor: SYNC_ACTOR, op: 'supersede', targetId: old.id, metadata: { newId } });
+            this.tx.markSummaryDirty(old.dag_parent_id, old.tenant_id, SYNC_ACTOR);
+        this.tx.appendAudit({
+            tenantId: old.tenant_id,
+            actor: SYNC_ACTOR,
+            op: 'supersede',
+            targetId: old.id,
+            metadata: { newId },
+        });
         this.mirror.push({ ...old, superseded_by: newId });
         return true;
     }
@@ -181,10 +204,10 @@ class ContainerRun {
             ? new Date(Math.min(item.updatedAt, Date.parse(base.created))).toISOString()
             : base.created;
         const origin = this.s.originProject === undefined ? {} : { origin_project: this.s.originProject };
-        return stampOriginProject(this.s.hippoRoot, { ...base, created, valid_from: created, ...origin });
+        return this.tx.stampOrigin({ ...base, created, valid_from: created, ...origin });
     }
     gated(entry) {
-        const result = gatedWrite(this.s.db, this.s.hippoRoot, entry, { actor: SYNC_ACTOR, worthCheck: false });
+        const result = this.tx.gatedWrite(entry, { actor: SYNC_ACTOR, worthCheck: false });
         if (result === 'written') {
             this.mirror.push(entry);
             return true;
@@ -194,8 +217,8 @@ class ContainerRun {
     }
     /** A deleted note came back unchanged: its old row returns with its id and history, under the sync's own audit op. */
     restore(key, dormantId) {
-        const snap = readDormantSnapshot(this.s.db, this.s.tenantId, dormantId);
-        const taken = entryIdTakenAt(this.s.db, dormantId);
+        const snap = this.tx.readDormant(this.s.tenantId, dormantId);
+        const taken = this.tx.entryIdTaken(dormantId);
         if (snap === null || taken) {
             this.write({ key, hash: '', supersedes: [] });
             return;
@@ -208,10 +231,14 @@ class ContainerRun {
             tags: [...tags, this.tag],
             last_retrieved: now.toISOString(),
         };
-        if (!this.gated(stampOriginProject(this.s.hippoRoot, { ...revived, strength: calculateStrength(revived, now, { ablation: strengthAblation() }) })))
+        if (!this.gated(this.tx.stampOrigin({
+            ...revived,
+            strength: calculateStrength(revived, now, { ablation: strengthAblation() }),
+        }))) {
             return;
-        deleteDormantRow(this.s.db, this.s.tenantId, dormantId);
-        appendAuditEvent(this.s.db, {
+        }
+        this.tx.deleteDormant(this.s.tenantId, dormantId);
+        this.tx.appendAudit({
             tenantId: this.s.tenantId,
             actor: SYNC_ACTOR,
             op: 'agent_memory_restore',
@@ -222,7 +249,7 @@ class ContainerRun {
     }
     setAside(row) {
         const why = this.items.has(splitSource(row.source, this.w.prefix).key) ? 'note-changed' : 'note-gone';
-        const result = setAsideRow(this.s.db, this.tag, row, why);
+        const result = this.tx.setAside(this.tag, row, why);
         if (result.kind === 'untagged') {
             this.tally.untagged++;
             this.mirror.push(result.entry);

package/dist/agent-memories/claude-code.d.ts

@@ -3,10 +3,16 @@ import type { Adapter, AdapterContext, Listing } from './types.js';
 /** Claude Code's rule: a linked worktree shares its main checkout's folder, or the git folder's when that sits outside
  * a checkout (a bare repository, or --separate-git-dir); any other checkout, a submodule included, keeps its own. */
 export declare function claudeCheckoutRoot(top: string, gitDir: string, common: string): string;
-/** Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a base-36 hash of the whole path. */
+/**
+ * Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a
+ * base-36 hash of the whole path.
+ */
 export declare function claudeFolderName(root: string): string;
 export declare const claudeCodeAdapter: Adapter;
-/** A session's own notes folder and nothing else, with no git call, so post-compact can read it inside the hook's time limit. */
+/**
+ * A session's own notes folder and nothing else, with no git call, so post-compact can read it inside the hook's time
+ * limit.
+ */
 export declare function claudeTranscriptListing(ctx: AdapterContext, transcriptPath: string): Listing;
 /** The project a session folder's notes belong to: the one Claude named the folder
  * for, the session's start folder, else cwd or a parent; null when none matches. */

package/dist/agent-memories/claude-code.js

@@ -1,4 +1,5 @@
-// Claude Code's auto memory: frontmatter `.md` notes in a per-project folder, plus the `autoMemoryDirectory` user folder.
+// Claude Code's auto memory: frontmatter `.md` notes in a per-project folder, plus the `autoMemoryDirectory` user
+// folder.
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolveProjectIdentity } from '../core/project-identity.js';
@@ -13,7 +14,10 @@ import { errorMessage } from '../util/log.js';
 const NAME_SLUG_MAX_CHARS = 200;
 // Keeps a pinned name from carrying a separator or `..` out of the projects folder.
 const PROJECT_DIR_NAME = /^[A-Za-z0-9_-]{1,64}$/;
-/** Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself outside a repository. */
+/**
+ * Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself
+ * outside a repository.
+ */
 function claudeMemoryFolderNames(projectRoot, platform) {
     const roots = [projectRoot, realpathOrResolve(projectRoot)];
     const layout = gitLayout(projectRoot);
@@ -30,7 +34,10 @@ export function claudeCheckoutRoot(top, gitDir, common) {
         return path.dirname(common);
     return fs.existsSync(path.join(common, '.git')) ? top : common;
 }
-/** Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a base-36 hash of the whole path. */
+/**
+ * Claude Code's folder name for a path: non-alphanumerics made '-', and a name over 200 characters cut to 200 plus a
+ * base-36 hash of the whole path.
+ */
 export function claudeFolderName(root) {
     const full = path.resolve(root);
     const name = full.replace(/[^a-zA-Z0-9]/g, '-');
@@ -50,11 +57,19 @@ export const claudeCodeAdapter = {
         return { tool: 'claude-code', home: config, containers: readFolders(folders, scope, ctx.platform), warnings };
     },
 };
-/** A session's own notes folder and nothing else, with no git call, so post-compact can read it inside the hook's time limit. */
+/**
+ * A session's own notes folder and nothing else, with no git call, so post-compact can read it inside the hook's time
+ * limit.
+ */
 export function claudeTranscriptListing(ctx, transcriptPath) {
     const config = claudeConfigDir(ctx.home, ctx.env);
     const folder = path.join(path.dirname(transcriptPath), 'memory');
-    return { tool: 'claude-code', home: config, containers: readFolders([folder], 'project', ctx.platform), warnings: [] };
+    return {
+        tool: 'claude-code',
+        home: config,
+        containers: readFolders([folder], 'project', ctx.platform),
+        warnings: [],
+    };
 }
 /** The project a session folder's notes belong to: the one Claude named the folder
  * for, the session's start folder, else cwd or a parent; null when none matches. */
@@ -71,15 +86,19 @@ export function transcriptNotesProject(transcriptPath, cwd, machine) {
     for (const from of [start, cwd]) {
         for (let dir = from === null ? null : path.resolve(from); dir !== null; dir = path.dirname(dir) === dir ? null : path.dirname(dir)) {
             // A folder gone from disk resolves to its bare name, never the project it was in, so it decides nothing.
-            if ([dir, realpathOrResolve(dir)].some((d) => fold(claudeFolderName(d)) === folder))
+            if ([dir, realpathOrResolve(dir)].some((d) => fold(claudeFolderName(d)) === folder)) {
                 return fs.existsSync(dir) ? resolveProjectIdentity(dir) : null;
+            }
         }
     }
     return null;
 }
 // Claude writes the cwd on each message line after a few header lines; 64 KB holds the first with room to spare.
 const START_SCAN_BYTES = 64 * 1024;
-/** The cwd on the transcript's first line that has one: the folder Claude named the session folder for, which a folder name alone cannot give back. */
+/**
+ * The cwd on the transcript's first line that has one: the folder Claude named the session folder for, which a folder
+ * name alone cannot give back.
+ */
 function transcriptStartCwd(transcriptPath) {
     let fd;
     try {

package/dist/agent-memories/copilot.js

@@ -1,4 +1,5 @@
-// GitHub Copilot Chat in VS Code: memory-tool files under VS Code's own data folders, one set per product and workspace.
+// GitHub Copilot Chat in VS Code: memory-tool files under VS Code's own data folders, one set per product and
+// workspace.
 import fs from 'node:fs';
 import path from 'node:path';
 import { readTextFile } from './files.js';

package/dist/agent-memories/files.js

@@ -7,7 +7,8 @@ const MAX_DEPTH = 8;
 /** A file's text, or why it was skipped: empty, too big, holds a NUL byte (not text), or unreadable. */
 export function readTextFile(file) {
     try {
-        // O_NONBLOCK opens a FIFO at once, for the file check to turn away; Windows has no such flag and the OR adds nothing.
+        // O_NONBLOCK opens a FIFO at once, for the file check to turn away; Windows has no such flag and the OR adds
+        // nothing.
         const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
         try {
             return readOpenTextFile(file, fd);

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

@@ -1,5 +1,5 @@
-import type { DatabaseSyncLike } from '../db/index.js';
 import type { MemoryEntry } from '../core/memory.js';
+import type { ImportTarget } from '../store/port/agent-import.js';
 import type { Listing } from './types.js';
 export declare const LEGACY_SOURCE_PREFIX = "claude-memory:";
 export interface ContainerLegacy {
@@ -12,6 +12,9 @@ export interface LegacyWork {
     /** Rows about to take a note's key, which stop counting as text another path stored. */
     readonly adopted: ReadonlySet<string>;
 }
-/** Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its row inside one. */
-export declare function legacyWork(db: DatabaseSyncLike, tenantId: string, listings: readonly Listing[]): LegacyWork;
+/**
+ * Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its
+ * row inside one.
+ */
+export declare function legacyWork(target: ImportTarget, listings: readonly Listing[]): LegacyWork;
 //# sourceMappingURL=legacy.d.ts.map

package/dist/agent-memories/legacy.js

@@ -2,40 +2,61 @@
 import path from 'node:path';
 import { duplicateKey } from '../util/same-text.js';
 import { maskEmails } from '../util/secret-detect.js';
-import { selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
 import { matchLegacy } from './plan.js';
 import { MIN_ITEM_CHARS, storedText } from './source.js';
 export const LEGACY_SOURCE_PREFIX = 'claude-memory:';
 const LEGACY_TAG = 'claude-code-memory';
-/** Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its row inside one. */
-export function legacyWork(db, tenantId, listings) {
-    const containers = listings.filter((l) => l.tool === 'claude-code').flatMap((l) => l.containers).filter((c) => c.readable);
-    const rows = containers.length === 0
-        ? []
-        : selectLiveEntriesBySourcePrefix(db, tenantId, LEGACY_SOURCE_PREFIX).filter((r) => r.tags.includes(LEGACY_TAG));
-    const byContainer = new Map();
-    if (rows.length === 0)
-        return { byContainer, adopted: new Set() };
+function legacyTargets(containers) {
     const refs = [];
     const targets = [];
     for (const container of containers) {
         for (const item of container.items) {
             if (item.text.trim().length < MIN_ITEM_CHARS)
                 continue;
-            targets.push({ ref: String(refs.length), file: path.posix.basename(item.key), textKey: duplicateKey(storedText(item.text)) });
+            targets.push({
+                ref: String(refs.length),
+                file: path.posix.basename(item.key),
+                textKey: duplicateKey(storedText(item.text)),
+            });
             refs.push({ dir: container.path, key: item.key });
         }
     }
+    return { refs, targets };
+}
+/**
+ * Matched once across all the store's Claude folders, before any container's transaction; each adoption re-checks its
+ * row inside one.
+ */
+export function legacyWork(target, listings) {
+    const containers = listings
+        .filter((l) => l.tool === 'claude-code')
+        .flatMap((l) => l.containers)
+        .filter((c) => c.readable);
+    const rows = containers.length === 0
+        ? []
+        : target.liveBySourcePrefix(LEGACY_SOURCE_PREFIX).filter((r) => r.tags.includes(LEGACY_TAG));
+    const byContainer = new Map();
+    if (rows.length === 0)
+        return { byContainer, adopted: new Set() };
+    const { refs, targets } = legacyTargets(containers);
     const match = matchLegacy(
-    // The old import kept emails in clear, and targets are masked; without the mask those rows never matched and imported twice.
-    rows.map((r) => ({ id: r.id, file: r.source.slice(LEGACY_SOURCE_PREFIX.length), textKey: duplicateKey(maskEmails(r.content)) })), targets);
+    // The old import kept emails in clear, and targets are masked; without the mask those rows never matched and
+    // imported twice.
+    rows.map((r) => ({
+        id: r.id,
+        file: r.source.slice(LEGACY_SOURCE_PREFIX.length),
+        textKey: duplicateKey(maskEmails(r.content)),
+    })), targets);
     const byId = new Map(rows.map((r) => [r.id, r]));
     const add = (pick, ref, id) => {
         const { dir, key } = refs[Number(ref)];
         const row = byId.get(id);
         if (row === undefined)
             return;
-        const found = byContainer.get(dir) ?? { adopt: new Map(), replace: new Map() };
+        const found = byContainer.get(dir) ?? {
+            adopt: new Map(),
+            replace: new Map(),
+        };
         byContainer.set(dir, found);
         found[pick].set(key, [...(found[pick].get(key) ?? []), row]);
     };

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

@@ -1,4 +1,6 @@
-/** Splits one markdown memory file into items (a top-level bullet or a paragraph), each tagged with its heading. Pure. */
+/**
+ * Splits one markdown memory file into items (a top-level bullet or a paragraph), each tagged with its heading. Pure.
+ */
 export interface MarkdownItem {
     readonly heading: string;
     readonly headingSlug: string;

package/dist/agent-memories/markdown.js

@@ -1,4 +1,6 @@
-/** Splits one markdown memory file into items (a top-level bullet or a paragraph), each tagged with its heading. Pure. */
+/**
+ * Splits one markdown memory file into items (a top-level bullet or a paragraph), each tagged with its heading. Pure.
+ */
 const HEADING = /^#{1,6}\s+/;
 // Column 0 only: an indented marker is a sub-bullet and stays inside its item.
 const BULLET = /^(?:[-*+]|\d+[.)]) /;

package/dist/agent-memories/openclaw.js

@@ -11,7 +11,8 @@ export const openclawAdapter = {
         return { tool: 'openclaw', home, containers: scope === 'user' ? userContainers(home) : [], warnings: [] };
     },
 };
-// SHORTCUT: agents.defaults.workspace in openclaw.json is not read (the file allows comments, and there is no parser for that here); read it if users ask.
+// SHORTCUT: agents.defaults.workspace in openclaw.json is not read (the file allows comments, and there is no parser
+// for that here); read it if users ask.
 function workspaceDir(ctx) {
     const { OPENCLAW_WORKSPACE_DIR: workspace } = ctx.env;
     return path.resolve(workspace || path.join(stateDir(ctx), 'workspace'));
@@ -29,7 +30,9 @@ function userContainers(workspace) {
         return [];
     const read = readTextFile(file);
     if (!read.ok) {
-        return [{ scope: 'user', path: file, readable: false, items: [], skipped: [], warnings: [read.reason], textKeyed: true }];
+        return [
+            { scope: 'user', path: file, readable: false, items: [], skipped: [], warnings: [read.reason], textKeyed: true },
+        ];
     }
     const stored = splitMarkdownItems(read.text).map(({ heading, headingSlug, text }) => ({
         headingSlug,

package/dist/agent-memories/plan.js

@@ -2,7 +2,17 @@
 export function planContainer(input) {
     const live = groupByKey(input.live);
     const dormant = groupByKey(input.dormant);
-    const draft = { unchanged: 0, retag: [], collapse: [], writes: [], fresh: [], restores: [], setAside: [], duplicates: 0, refused: 0 };
+    const draft = {
+        unchanged: 0,
+        retag: [],
+        collapse: [],
+        writes: [],
+        fresh: [],
+        restores: [],
+        setAside: [],
+        duplicates: 0,
+        refused: 0,
+    };
     for (const item of input.items)
         planItem(input, item, live.get(item.key) ?? [], dormant.get(item.key) ?? [], draft);
     const read = new Set([...input.items.map((i) => i.key), ...input.skipped]);

package/dist/agent-memories/project-folds.js

@@ -1,4 +1,5 @@
-// Project names folded into others, read from the audit trail: the sync files imports under the surviving name, and `hippo projects` repair agrees.
+// Project names folded into others, read from the audit trail: the sync files imports under the surviving name, and
+// `hippo projects` repair agrees.
 import { isObjectLike, isStringValue } from '../core/capture-contract.js';
 function foldOf(value) {
     if (!isObjectLike(value) || Array.isArray(value))

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

@@ -48,6 +48,9 @@ export declare function mergeReports(into: ImportReport, from: ImportReport): vo
 export declare function totalTally(report: ImportReport): Tally;
 /** `hippo import --agents`: each tool's home, its folders and what moved; in a dry run, what would have. */
 export declare function detailLines(report: ImportReport, dryRun: boolean): string[];
-/** "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 declare function summaryLine(report: ImportReport): string | null;
 //# sourceMappingURL=report.d.ts.map

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