hippo-memory 1.69.0 → 1.71.0

package/README.md

@@ -257,7 +257,7 @@ hippo handoff create \
   --summary "Finished schema migration, tests green" \
   --next "Wire handoff injection into context output" \
   --session sess_20260403 \
-  --artifact src/db.ts
+  --artifact src/db/index.ts
 
 hippo handoff latest              # show the most recent handoff
 hippo handoff show 3              # show a specific handoff by ID
@@ -577,7 +577,8 @@ read from the store the token ledger writes to: the project's local store when i
 else the global store. Each per-prompt hook call then records one event (session, turn
 number, whether the block was sent, reused, empty or disabled, counts and token totals) and
 one row per candidate memory: emitted, reused or rejected, with the stage and the
-reason it was dropped. With prompt recall on, recent memories dropped by the quality filter
+reason it was dropped. Each accepted `hippo pre-compact` and `hippo compact-resume` call
+records one event too, with no candidate rows. With prompt recall on, recent memories dropped by the quality filter
 are not recorded yet. It holds ids, hashes, counts and reasons only, never prompt or memory
 text; the prompt hash is unsalted, so a very short prompt can be guessed. A ledger failure prints one stderr line and never changes what the hook prints. Rows
 older than 90 days are pruned; at a heavy 300 prompts a day that is about 190 MB per store.
@@ -783,6 +784,8 @@ hippo watch "npm run build"
 | `hippo dashboard` | Open web dashboard at localhost:3333 (memory health by project, and the card board); open the printed URL, which carries a per-start access token |
 | `hippo dashboard --port <n>` | Use custom port |
 | `hippo mcp` | Start MCP server (stdio transport) |
+| `hippo serve` | Start the HTTP API server for this store on `127.0.0.1:6789` (`--port <n>` or `HIPPO_PORT`; `--host <host>`, which off loopback needs `HIPPO_REQUIRE_AUTH=1`). Every request needs an API key (`hippo auth create`, then `Authorization: Bearer <key>`; the hippo CLI reads `HIPPO_API_KEY`). `HIPPO_ALLOW_KEYLESS_LOCAL=1` lets requests from this machine in without one, as host admin; `HIPPO_REQUIRE_AUTH=1` wins over it |
+| `hippo serve --tls-cert <file> --tls-key <file>` | Serve HTTPS with that PEM certificate and key (or set `HIPPO_TLS_CERT` and `HIPPO_TLS_KEY`). Without them a network bind still starts, and warns once that API keys and memory text travel in cleartext unless a TLS-terminating proxy sits in front |
 
 On `heartbeat`, `block`, `review` and `complete`, a given `--run` is checked against the card's live run and the command is refused, unchanged, if the two do not match.
 

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

@@ -1,7 +1,7 @@
-import type { DatabaseSyncLike } from '../db.js';
-import { type MemoryEntry } from '../memory.js';
+import { type DatabaseSyncLike } from '../db/index.js';
+import { type MemoryEntry } from '../core/memory.js';
 import { type Tally } from './report.js';
-import type { AgentMemoryTool } from './tools.js';
+import type { AgentMemoryTool } from '../core/agent-memory-tools.js';
 import type { Container } from './types.js';
 export declare const SYNC_ACTOR = "agent-memories";
 export interface StoreSession {

package/dist/agent-memories/apply.js

@@ -1,14 +1,15 @@
 // 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 '../audit.js';
-import { deleteDormantRow, dormantSnapshotsBySourcePrefix, insertDormantRow, readDormantSnapshot, replaceDormantEntry } from '../dormant.js';
-import { gatedWrite } from '../gated-write.js';
-import { Layer, calculateStrength, createMemory } from '../memory.js';
-import { findRejectedValue, rejectionDigest } from '../rejection.js';
-import { redactSecretsStrict } from '../secret-detect.js';
+import { appendAuditEvent } from '../store/audit.js';
+import { withTrialScope, withWriteScope } from '../db/index.js';
+import { deleteDormantRow, dormantSnapshotsBySourcePrefix, insertDormantRow, readDormantSnapshot, replaceDormantEntry } from '../store/dormant.js';
+import { gatedWrite } from '../trust/gated-write.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 { deleteEntryRowInTx, setEntryTagsInTx } from '../store/entry-writes.js';
-import { selectLiveEntriesBySourcePrefix } from '../store/entry-reads.js';
-import { markSummaryDirtyInTx } from '../summary-dirty.js';
+import { deleteEntryRowInTx, renameEntrySourceAndOriginAt, renameEntrySourceAt, setEntryTagsInTx, supersedeEntryAt } from '../store/entry-writes.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';
@@ -16,20 +17,8 @@ import { MIN_ITEM_CHARS, itemSource, splitSource, storedText } from './source.js
 export const SYNC_ACTOR = 'agent-memories';
 /** Throws SQLITE_BUSY when another writer holds the store past its busy timeout; nothing is written then. */
 export function syncContainer(s, work) {
-    // A dry run takes no lock up front and rolls every write back.
-    s.db.exec(s.dryRun ? 'BEGIN' : 'BEGIN IMMEDIATE');
-    try {
-        const out = new ContainerRun(s, work).run();
-        s.db.exec(s.dryRun ? 'ROLLBACK' : 'COMMIT');
-        return out;
-    }
-    catch (err) {
-        try {
-            s.db.exec('ROLLBACK');
-        }
-        catch { /* already rolled back; keep the original error */ }
-        throw err;
-    }
+    const run = () => new ContainerRun(s, work).run();
+    return s.dryRun ? withTrialScope(s.db, 'sync_container', run) : withWriteScope(s.db, 'sync_container', run);
 }
 /** Design 6's set-aside on the caller's transaction: a pinned row only loses the tag, any other goes dormant, restorable. */
 export function setAsideRow(db, tag, row, why) {
@@ -110,8 +99,7 @@ class ContainerRun {
                 continue;
             const source = itemSource(this.w.prefix, key, item.text);
             for (const row of rows) {
-                const moved = this.s.db.prepare(`UPDATE memories SET source = ? WHERE id = ? AND tenant_id = ? AND source = ? AND superseded_by IS NULL`).run(source, row.id, row.tenantId, row.source);
-                if (Number(moved.changes ?? 0) === 0)
+                if (renameEntrySourceAt(this.s.db, row.tenantId, row.id, row.source, source) === 0)
                     continue;
                 this.tally.adopted++;
                 this.mirror.push({ ...row, source });
@@ -124,8 +112,7 @@ class ContainerRun {
         let moved = 0;
         for (const row of selectLiveEntriesBySourcePrefix(this.s.db, this.s.tenantId, old)) {
             const source = this.w.prefix + row.source.slice(old.length);
-            const done = this.s.db.prepare(`UPDATE memories SET source = ?, origin_project = COALESCE(?, origin_project) WHERE id = ? AND tenant_id = ? AND source = ?`).run(source, origin, row.id, row.tenantId, row.source);
-            if (Number(done.changes ?? 0) === 0)
+            if (renameEntrySourceAndOriginAt(this.s.db, row.tenantId, row.id, { from: row.source, to: source, origin }) === 0)
                 continue;
             moved++;
             this.mirror.push({ ...row, source, origin_project: origin ?? row.origin_project });
@@ -178,9 +165,7 @@ class ContainerRun {
     }
     /** api.supersede's steps on this transaction; false when another writer superseded the row first. */
     supersede(old, newId) {
-        const result = this.s.db.prepare(`UPDATE memories SET superseded_by = ? WHERE id = ? AND tenant_id = ? AND superseded_by IS NULL`)
-            .run(newId, old.id, old.tenantId);
-        if (Number(result.changes ?? 0) === 0)
+        if (!supersedeEntryAt(this.s.db, old.tenantId, old.id, newId))
             return false;
         if (old.dag_parent_id)
             markSummaryDirtyInTx(this.s.db, old.dag_parent_id, old.tenantId, SYNC_ACTOR);
@@ -225,7 +210,7 @@ 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 = this.s.db.prepare(`SELECT 1 FROM memories WHERE id = ?`).get(dormantId) !== undefined;
+        const taken = entryIdTakenAt(this.s.db, dormantId);
         if (snap === null || taken) {
             this.write({ key, hash: '', supersedes: [] });
             return;

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

@@ -1,14 +1,14 @@
-import { type ProjectIdentity } from '../project-identity.js';
+import { type ProjectIdentity } from '../core/project-identity.js';
 import type { Adapter, AdapterContext, Listing } from './types.js';
-/** Claude Code's auto memory folder names for a project: its checkout, which subfolders share, or the folder itself outside a repository. */
-export declare function claudeMemoryFolderNames(projectRoot: string, platform: NodeJS.Platform): Set<string>;
-/** 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. */
+/** 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. */
 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. */
 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. */
+/** 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. */
 export declare function transcriptNotesProject(transcriptPath: string, cwd: string | null, machine: Pick<AdapterContext, 'platform' | 'env'>): ProjectIdentity | null;
 //# sourceMappingURL=claude-code.d.ts.map

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

@@ -1,23 +1,28 @@
 // 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 { realpathOrResolve, resolveProjectIdentity } from '../project-identity.js';
-import { isStringValue } from '../capture-contract.js';
-import { claudeConfigDir, isJsonObject } from '../hooks/shared.js';
+import { resolveProjectIdentity } from '../core/project-identity.js';
+import { realpathOrResolve } from '../util/real-path.js';
+import { isStringValue } from '../core/capture-contract.js';
+import { claudeConfigDir } from '../hooks/shared.js';
 import { expandHome, frontmatterField, itemTime, readTextFile, splitFrontmatter } from './files.js';
 import { markdownNotes, readFolderStore, uniqueFolders } from './folder-store.js';
 import { gitLayout } from './git.js';
+import { isJsonObjectLiteral } from '../util/json.js';
+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. */
-export function claudeMemoryFolderNames(projectRoot, platform) {
+function claudeMemoryFolderNames(projectRoot, platform) {
     const roots = [projectRoot, realpathOrResolve(projectRoot)];
     const layout = gitLayout(projectRoot);
     if (layout)
         roots.push(claudeCheckoutRoot(layout.top, layout.gitDir, layout.common));
     return new Set(roots.map((root) => (platform === 'win32' ? claudeFolderName(root).toLowerCase() : claudeFolderName(root))));
 }
-/** 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. */
+/** 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 function claudeCheckoutRoot(top, gitDir, common) {
     if (gitDir === common)
         return top;
@@ -34,7 +39,7 @@ export function claudeFolderName(root) {
     let hash = 0;
     for (let i = 0; i < full.length; i++)
         hash = ((hash << 5) - hash + full.charCodeAt(i)) | 0;
-    return `${name.slice(0, 200)}-${Math.abs(hash).toString(36)}`;
+    return `${name.slice(0, NAME_SLUG_MAX_CHARS)}-${Math.abs(hash).toString(36)}`;
 }
 export const claudeCodeAdapter = {
     tool: 'claude-code',
@@ -51,7 +56,8 @@ export function claudeTranscriptListing(ctx, transcriptPath) {
     const folder = path.join(path.dirname(transcriptPath), 'memory');
     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. */
+/** 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. */
 export function transcriptNotesProject(transcriptPath, cwd, machine) {
     const fold = (name) => (machine.platform === 'win32' ? name.toLowerCase() : name);
     const folder = fold(path.basename(path.dirname(transcriptPath)));
@@ -75,9 +81,16 @@ export function transcriptNotesProject(transcriptPath, cwd, machine) {
 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. */
 function transcriptStartCwd(transcriptPath) {
-    if (!fs.existsSync(transcriptPath))
-        return null;
-    const fd = fs.openSync(transcriptPath, 'r');
+    let fd;
+    try {
+        fd = fs.openSync(transcriptPath, 'r');
+    }
+    catch (err) {
+        // A transcript that is not there names no start folder; any other failure is the caller's to see.
+        if (err instanceof Error && 'code' in err && (err.code === 'ENOENT' || err.code === 'ENOTDIR'))
+            return null;
+        throw err;
+    }
     try {
         const buf = Buffer.alloc(START_SCAN_BYTES);
         const lines = buf.subarray(0, fs.readSync(fd, buf, 0, buf.length, 0)).toString('utf8').split('\n');
@@ -126,10 +139,10 @@ function autoMemoryDirectory(settings, home, warnings) {
         json = JSON.parse(file.text);
     }
     catch (err) {
-        warnings.push(`${settings}: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`${settings}: ${errorMessage(err)}`);
         return null;
     }
-    const value = isJsonObject(json) ? json.autoMemoryDirectory : undefined;
+    const value = isJsonObjectLiteral(json) ? json.autoMemoryDirectory : undefined;
     if (!isStringValue(value) || value === '')
         return null;
     const dir = expandHome(value, home);

package/dist/agent-memories/copilot.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { readTextFile } from './files.js';
 import { readFolderStore } from './folder-store.js';
 import { gitLayout } from './git.js';
+import { errorMessage } from '../util/log.js';
 const PRODUCTS = ['Code', 'Code - Insiders'];
 const MEMORY_TOOL = ['github.copilot-chat', 'memory-tool', 'memories'];
 /** VS Code's user-data resolution: portable install first, then the app-data override, then the platform default. */
@@ -48,7 +49,7 @@ function workspaceFolder(file, platform, warnings) {
         return fileUriToPath(json.folder, platform);
     }
     catch (err) {
-        warnings.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`${file}: ${errorMessage(err)}`);
         return null;
     }
 }
@@ -85,7 +86,7 @@ function projectContainers(data, ctx, matches, warnings) {
         ids = fs.readdirSync(storage, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
     }
     catch (err) {
-        warnings.push(`${storage}: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`${storage}: ${errorMessage(err)}`);
         return [];
     }
     const found = [];

package/dist/agent-memories/files.js

@@ -1,28 +1,40 @@
 // Read-only file access shared by the adapters: size, binary and failure checks live in one place.
 import fs from 'node:fs';
 import path from 'node:path';
+import { errorMessage } from '../util/log.js';
 export const MAX_ITEM_BYTES = 256 * 1024;
 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 {
-        const stat = fs.statSync(file);
-        if (!stat.isFile())
-            return { ok: false, reason: `${file}: not a file` };
-        // A tool rewriting a file truncates it first; read as holding no notes, every row would be set aside.
-        if (stat.size === 0)
-            return { ok: false, reason: `${file}: empty` };
-        if (stat.size > MAX_ITEM_BYTES)
-            return { ok: false, reason: `${file}: over ${MAX_ITEM_BYTES} bytes` };
-        const buf = fs.readFileSync(file);
-        if (buf.includes(0))
-            return { ok: false, reason: `${file}: not text` };
-        return { ok: true, text: buf.toString('utf8'), mtimeMs: stat.mtimeMs };
+        // 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);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
     }
     catch (err) {
-        return { ok: false, reason: `${file}: ${err instanceof Error ? err.message : String(err)}` };
+        return { ok: false, reason: `${file}: ${errorMessage(err)}` };
     }
 }
+/** The checks and the read on one descriptor, so the file measured is the file read. */
+function readOpenTextFile(file, fd) {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile())
+        return { ok: false, reason: `${file}: not a file` };
+    // A tool rewriting a file truncates it first; read as holding no notes, every row would be set aside.
+    if (stat.size === 0)
+        return { ok: false, reason: `${file}: empty` };
+    if (stat.size > MAX_ITEM_BYTES)
+        return { ok: false, reason: `${file}: over ${MAX_ITEM_BYTES} bytes` };
+    const buf = fs.readFileSync(fd);
+    if (buf.includes(0))
+        return { ok: false, reason: `${file}: not text` };
+    return { ok: true, text: buf.toString('utf8'), mtimeMs: stat.mtimeMs };
+}
 /** Files in a folder as '/'-separated relative paths, sorted; dot entries skipped, symlinked folders not followed. */
 export function listFiles(dir, opts) {
     if (!fs.existsSync(dir))
@@ -35,7 +47,7 @@ export function listFiles(dir, opts) {
         return { status: 'ok', files: files.sort() };
     }
     catch (err) {
-        return { status: 'unreadable', reason: `${dir}: ${err instanceof Error ? err.message : String(err)}` };
+        return { status: 'unreadable', reason: `${dir}: ${errorMessage(err)}` };
     }
 }
 function walk(root, rel, depthLeft, out) {

package/dist/agent-memories/gemini.js

@@ -1,13 +1,14 @@
 // Gemini CLI: the "Gemini Added Memories" section of GEMINI.md, and the auto-memory folder that projects.json names.
 import fs from 'node:fs';
 import path from 'node:path';
-import { isStringValue } from '../capture-contract.js';
-import { isJsonObject } from '../hooks/shared.js';
+import { isStringValue } from '../core/capture-contract.js';
 import { readTextFile, splitFrontmatter } from './files.js';
 import { markdownNotes, readFolderStore } from './folder-store.js';
 import { gitLayout } from './git.js';
 import { textItemKeys } from './keys.js';
 import { splitMarkdownItems } from './markdown.js';
+import { isJsonObjectLiteral } from '../util/json.js';
+import { errorMessage } from '../util/log.js';
 const SECTION = 'gemini added memories';
 export const geminiAdapter = {
     tool: 'gemini',
@@ -58,7 +59,7 @@ function projectSlug(ctx, projectRoot, home, warnings) {
         projects = parseIndex(read.text);
     }
     catch (err) {
-        warnings.push(`${index}: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`${index}: ${errorMessage(err)}`);
         return null;
     }
     // The git top level is only asked for when the folder itself has no entry, since it spawns git.
@@ -74,8 +75,8 @@ function projectSlug(ctx, projectRoot, home, warnings) {
 function parseIndex(text) {
     // SAFETY: JSON.parse yields JSON; the object checks below decide what is used.
     const data = JSON.parse(text);
-    const projects = isJsonObject(data) ? data.projects : undefined;
-    if (!isJsonObject(projects))
+    const projects = isJsonObjectLiteral(data) ? data.projects : undefined;
+    if (!isJsonObjectLiteral(projects))
         throw new Error('expected { "projects": { "<absolute path>": "<slug>" } }');
     return projects;
 }

package/dist/agent-memories/keys.js

@@ -1,17 +1,18 @@
 // Hashes and keys for imported items, shared by the sync and the single-file adapters so they never drift apart.
 import { createHash } from 'node:crypto';
+import { FINGERPRINT_HEX_CHARS, ID_SUFFIX_CHARS } from '../util/token-text.js';
 export function sha256Hex(text) {
     return createHash('sha256').update(text.replace(/\r\n/g, '\n'), 'utf8').digest('hex');
 }
 /** The `#<hash>` part of a source: 16 hex of the full text, so an edit past the content cap is still seen. */
 export function itemHash(text) {
-    return sha256Hex(text).slice(0, 16);
+    return sha256Hex(text).slice(0, FINGERPRINT_HEX_CHARS);
 }
 /** Keys for a single-file store's items: `<heading slug>/<12 hex of the text>`, `~2`, `~3` on repeats. */
 export function textItemKeys(items) {
     const seen = new Map();
     return items.map(({ headingSlug, text }) => {
-        const base = `${headingSlug}/${sha256Hex(text).slice(0, 12)}`;
+        const base = `${headingSlug}/${sha256Hex(text).slice(0, ID_SUFFIX_CHARS)}`;
         const n = (seen.get(base) ?? 0) + 1;
         seen.set(base, n);
         return n === 1 ? base : `${base}~${n}`;

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

@@ -1,5 +1,5 @@
-import type { DatabaseSyncLike } from '../db.js';
-import type { MemoryEntry } from '../memory.js';
+import type { DatabaseSyncLike } from '../db/index.js';
+import type { MemoryEntry } from '../core/memory.js';
 import type { Listing } from './types.js';
 export declare const LEGACY_SOURCE_PREFIX = "claude-memory:";
 export interface ContainerLegacy {

package/dist/agent-memories/legacy.js

@@ -1,7 +1,7 @@
 // Rows the old Claude import wrote (`claude-memory:<file>`), taken over by the notes they came from (plan design 10).
 import path from 'node:path';
-import { duplicateKey } from '../same-text.js';
-import { maskEmails } from '../secret-detect.js';
+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';

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

@@ -1,6 +1,4 @@
-/**
- * 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,6 +1,4 @@
-/**
- * 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/report.d.ts

@@ -1,4 +1,4 @@
-import { type ToolId } from './tools.js';
+import { type ToolId } from '../core/agent-memory-tools.js';
 import type { Scope } from './types.js';
 export interface Tally {
     imported: number;

package/dist/agent-memories/report.js

@@ -1,5 +1,5 @@
 // What a sync did, per tool, and the one line a command prints about it (plan design 11).
-import { AGENT_MEMORY_TOOLS } from './tools.js';
+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,
@@ -47,7 +47,8 @@ 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', retagged: 'retagged',
+    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',
 };

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

@@ -1,4 +1,4 @@
-import { type ToolId } from './tools.js';
+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;

package/dist/agent-memories/source.js

@@ -1,16 +1,17 @@
 // An imported row's source, `agent-memory:<tool>:<container>/<item>#<hash>`, and the stored text: plan design 3 and 4.
-import { realpathOrResolve } from '../project-identity.js';
-import { truncateCodePointSafe } from '../transcript-tail.js';
-import { maskEmails } from '../secret-detect.js';
+import { realpathOrResolve } from '../util/real-path.js';
+import { truncateCodePointSafe } from '../util/transcript-tail.js';
+import { maskEmails } from '../util/secret-detect.js';
 import { itemHash, sha256Hex } from './keys.js';
-import { toolSourcePrefix } from './tools.js';
+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. */
 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, 12)}`;
+    return `${scope === 'project' ? 'p' : 'u'}-${sha256Hex(origin === '' ? folder : `${folder}\n${origin}`).slice(0, ID_SUFFIX_CHARS)}`;
 }
 export function containerPrefix(tool, container) {
     return `${toolSourcePrefix(tool)}${container}/`;

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

@@ -1,5 +1,5 @@
 import { type ImportReport } from './report.js';
-import { type ToolId } from './tools.js';
+import { type ToolId } from '../core/agent-memory-tools.js';
 import type { Adapter } from './types.js';
 export declare const ADAPTERS: readonly Adapter[];
 /** Overrides config because `hippo init` creates the store in the same command that imports (plan design 11). */
@@ -24,9 +24,11 @@ export declare function importForStore(hippoRoot: string, opts: SyncOptions): Im
 export declare function importProjectMemories(hippoRoot: string, opts: SyncOptions): ImportReport;
 /** Every tool's user-level memory into the global store, created on demand, with no origin. */
 export declare function importUserMemories(invokingRoot: string, opts: SyncOptions): ImportReport;
-/** Session end in a folder with no store of its own: the session's project into the global store with its origin, the session folder's notes, then the user pass. */
+/** Session end in a folder with no store of its own: the session's project into the
+ * global store with its origin, the session folder's notes, then the user pass. */
 export declare function importAtSessionEnd(cwd: string, transcriptPath: string | undefined, opts: SyncOptions): ImportReport;
-/** 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. */
+/** 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. */
 export declare function allowedTools(env: Machine['env'], invoking: string, target: string, warnings: string[]): Set<ToolId>;