hippo-memory 1.52.9 → 1.53.1

package/dist/agent-memories/markdown.js

@@ -0,0 +1,123 @@
+/**
+ * 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+[.)]) /;
+const RULE = /^\s*([-*_])(?:\s*\1){2,}\s*$/;
+// A backtick fence's info string holds no backtick, so inline code at line start is not a fence.
+const FENCE = /^\s*(?:(`{3,})[^`]*|(~{3,}).*)$/;
+const MAX_SLUG_LENGTH = 40;
+/** Lowercase, punctuation runs folded to '-', cut to 40 characters; 'top' when nothing is left. */
+export function slugHeading(heading) {
+    const slug = heading
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, MAX_SLUG_LENGTH)
+        .replace(/-+$/, '');
+    return slug === '' ? 'top' : slug;
+}
+/** Split markdown into memory items in file order; headings set context and are never items. */
+export function splitMarkdownItems(markdown) {
+    const lines = markdown.replace(/\r\n/g, '\n').split('\n');
+    const items = [];
+    let heading = '';
+    let headingSlug = slugHeading(heading);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (isBlank(line) || RULE.test(line)) {
+            i++;
+        }
+        else if (HEADING.test(line)) {
+            heading = headingText(line);
+            headingSlug = slugHeading(heading);
+            i++;
+        }
+        else {
+            const block = readBlock(lines, i);
+            if (block.text !== '')
+                items.push({ heading, headingSlug, text: block.text });
+            i = block.end;
+        }
+    }
+    return items;
+}
+function isBlank(line) {
+    return line.trim() === '';
+}
+function isIndented(line) {
+    return line.startsWith(' ') || line.startsWith('\t');
+}
+function headingText(line) {
+    // A closing run of '#' counts only after a space, so `## C#` keeps its name.
+    return line.replace(HEADING, '').trim().replace(/(?:^|\s+)#+$/, '').trim();
+}
+// Rules are tested first so `- - -` is a rule, not a bullet.
+function startsBlock(line) {
+    return RULE.test(line) || HEADING.test(line) || BULLET.test(line);
+}
+function fenceOf(line) {
+    const match = FENCE.exec(line);
+    return match === null ? null : (match[1] ?? match[2] ?? null);
+}
+function closesFence(line, fence) {
+    const trimmed = line.trim();
+    return trimmed.length >= fence.length && trimmed.replaceAll(fence[0], '') === '';
+}
+// An unclosed fence runs to the end of the file.
+function skipFence(lines, start, fence) {
+    for (let i = start + 1; i < lines.length; i++) {
+        if (closesFence(lines[i], fence))
+            return i + 1;
+    }
+    return lines.length;
+}
+// A line opening a fence carries its whole body with it, so body lines never start a heading or bullet.
+function afterLine(lines, i) {
+    const fence = fenceOf(lines[i]);
+    return fence === null ? i + 1 : skipFence(lines, i, fence);
+}
+// Where a bullet resumes after blank lines: the next line when it is indented, else -1.
+function resumeAfterBlank(lines, i) {
+    let next = i;
+    while (next < lines.length && isBlank(lines[next]))
+        next++;
+    return next < lines.length && isIndented(lines[next]) ? next : -1;
+}
+// A bullet spans blank lines between indented lines; a paragraph ends at the first blank line.
+function blockEnd(lines, start, isBullet) {
+    let i = start + 1;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (isBlank(line)) {
+            const resume = isBullet ? resumeAfterBlank(lines, i) : -1;
+            if (resume < 0)
+                return i;
+            i = resume;
+        }
+        else if (!isIndented(line) && startsBlock(line)) {
+            return i;
+        }
+        else {
+            i = afterLine(lines, i);
+        }
+    }
+    return lines.length;
+}
+function readBlock(lines, start) {
+    const fence = fenceOf(lines[start]);
+    if (fence !== null) {
+        const end = skipFence(lines, start, fence);
+        return { end, text: lines.slice(start, end).join('\n').trim() };
+    }
+    const isBullet = BULLET.test(lines[start]);
+    const end = blockEnd(lines, start, isBullet);
+    const body = lines.slice(start, end);
+    if (!isBullet)
+        return { end, text: body.join('\n').trim() };
+    body[0] = body[0].replace(BULLET, '');
+    return { end, text: body.map((l) => l.trimEnd()).join('\n').trim() };
+}
+//# sourceMappingURL=markdown.js.map

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

@@ -0,0 +1,3 @@
+import type { Adapter } from './types.js';
+export declare const openclawAdapter: Adapter;
+//# sourceMappingURL=openclaw.d.ts.map

package/dist/agent-memories/openclaw.js

@@ -0,0 +1,42 @@
+// OpenClaw keeps its durable memory in one MEMORY.md; the daily notes, USER.md and DREAMS.md are left out on purpose.
+import fs from 'node:fs';
+import path from 'node:path';
+import { readTextFile } from './files.js';
+import { textItemKeys } from './keys.js';
+import { splitMarkdownItems } from './markdown.js';
+export const openclawAdapter = {
+    tool: 'openclaw',
+    list(ctx, scope) {
+        const home = workspaceDir(ctx);
+        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.
+function workspaceDir(ctx) {
+    const { OPENCLAW_WORKSPACE_DIR: workspace } = ctx.env;
+    return path.resolve(workspace || path.join(stateDir(ctx), 'workspace'));
+}
+function stateDir(ctx) {
+    const { OPENCLAW_STATE_DIR: state, OPENCLAW_HOME: openclawHome, OPENCLAW_PROFILE: profile } = ctx.env;
+    if (state)
+        return state;
+    const suffix = profile && profile !== 'default' ? `-${profile}` : '';
+    return path.join(openclawHome || ctx.home, `.openclaw${suffix}`);
+}
+function userContainers(workspace) {
+    const file = path.join(workspace, 'MEMORY.md');
+    if (!fs.existsSync(file))
+        return [];
+    const read = readTextFile(file);
+    if (!read.ok) {
+        return [{ scope: 'user', path: file, readable: false, items: [], skipped: [], warnings: [read.reason], textKeyed: true }];
+    }
+    const stored = splitMarkdownItems(read.text).map(({ heading, headingSlug, text }) => ({
+        headingSlug,
+        text: heading === '' ? text : `${heading}: ${text}`,
+    }));
+    const keys = textItemKeys(stored);
+    const items = stored.map(({ text }, i) => ({ key: keys[i], text, updatedAt: read.mtimeMs }));
+    return [{ scope: 'user', path: file, readable: true, items, skipped: [], warnings: [], textKeyed: true }];
+}
+//# sourceMappingURL=openclaw.js.map

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

@@ -0,0 +1,78 @@
+export interface PlanItem {
+    readonly key: string;
+    readonly hash: string;
+    /** Read but not storable: under 10 characters, a secret, or a rejected value. */
+    readonly refused: boolean;
+}
+export interface LiveRow {
+    readonly id: string;
+    readonly key: string;
+    readonly hash: string;
+    /** Carries the tool's tag; an untagged row is one the user restored, or a pin whose note went. */
+    readonly tagged: boolean;
+    readonly created: string;
+}
+export interface DormantRow {
+    readonly id: string;
+    readonly key: string;
+    readonly hash: string;
+    readonly dormantAt: string;
+}
+export interface PlanInput {
+    readonly textKeyed: boolean;
+    readonly items: readonly PlanItem[];
+    readonly skipped: readonly string[];
+    readonly live: readonly LiveRow[];
+    /** Snapshots that are readable and not superseded. */
+    readonly dormant: readonly DormantRow[];
+    /** Legacy rows a new row of the key replaces (plan design 10, second round). */
+    readonly legacy?: ReadonlyMap<string, readonly string[]>;
+    /** Asked only when a row would be written: the text is already stored live by another path. */
+    readonly isDuplicate: (item: PlanItem) => boolean;
+}
+export interface PlannedWrite {
+    readonly key: string;
+    readonly hash: string;
+    readonly supersedes: readonly string[];
+}
+export interface ContainerPlan {
+    readonly unchanged: number;
+    /** Untagged rows whose tag goes back on. */
+    readonly retag: readonly string[];
+    /** Tagged rows superseded by the row kept for their key. */
+    readonly collapse: readonly {
+        readonly id: string;
+        readonly by: string;
+    }[];
+    readonly writes: readonly PlannedWrite[];
+    readonly restores: readonly {
+        readonly key: string;
+        readonly dormantId: string;
+    }[];
+    readonly setAside: readonly string[];
+    readonly duplicates: number;
+    readonly refused: number;
+}
+export declare function planContainer(input: PlanInput): ContainerPlan;
+export interface LegacyRow {
+    readonly id: string;
+    /** The file name its `claude-memory:<file>` source names. */
+    readonly file: string;
+    /** duplicateKey of its content. */
+    readonly textKey: string;
+}
+export interface LegacyTarget {
+    /** Opaque to this function: the sync's handle on one container's item. */
+    readonly ref: string;
+    readonly file: string;
+    readonly textKey: string;
+}
+export interface LegacyMatch {
+    /** Legacy row id to the target whose key it takes, keeping its id and history (same text: a renamed note too). */
+    readonly adopt: ReadonlyMap<string, string>;
+    /** Target ref to the legacy row a new row of that target replaces (different text, one legacy row of that file). */
+    readonly replace: ReadonlyMap<string, string>;
+}
+/** Plan design 10: same text first, then one legacy row per file name; anything else is left to decay. */
+export declare function matchLegacy(rows: readonly LegacyRow[], targets: readonly LegacyTarget[]): LegacyMatch;
+//# sourceMappingURL=plan.d.ts.map

package/dist/agent-memories/plan.js

@@ -0,0 +1,123 @@
+// What one sync does to one container's rows: a pure function of the items read and the rows found (plan design 6).
+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 };
+    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]);
+    const gone = new Map();
+    for (const [key, rows] of live) {
+        const tagged = rows.filter((r) => r.tagged).map((r) => r.id);
+        if (!read.has(key) && tagged.length > 0)
+            gone.set(key, tagged);
+    }
+    if (input.textKeyed)
+        pairEdits(gone, draft.fresh);
+    for (const ids of gone.values())
+        draft.setAside.push(...ids);
+    const { fresh, ...plan } = draft;
+    return { ...plan, writes: [...plan.writes, ...fresh] };
+}
+function planItem(input, item, rows, snaps, draft) {
+    const tagged = rows.filter((r) => r.tagged);
+    if (item.refused) {
+        draft.refused++;
+        draft.setAside.push(...tagged.map((r) => r.id));
+        return;
+    }
+    const same = rows.filter((r) => r.hash === item.hash);
+    if (same.length > 0) {
+        const kept = newestRow(same.filter((r) => r.tagged)) ?? newestRow(same);
+        if (kept === undefined)
+            return;
+        if (!kept.tagged)
+            draft.retag.push(kept.id);
+        const others = tagged.filter((r) => r.id !== kept.id);
+        draft.collapse.push(...others.map((r) => ({ id: r.id, by: kept.id })));
+        if (kept.tagged && others.length === 0)
+            draft.unchanged++;
+        return;
+    }
+    const legacy = input.legacy?.get(item.key) ?? [];
+    if (rows.length > 0) {
+        if (input.isDuplicate(item)) {
+            draft.duplicates++;
+            draft.setAside.push(...tagged.map((r) => r.id));
+        }
+        else {
+            draft.writes.push({ key: item.key, hash: item.hash, supersedes: [...rows.map((r) => r.id), ...legacy] });
+        }
+        return;
+    }
+    const snap = newestSnapshot(snaps.filter((s) => s.hash === item.hash));
+    if (snap !== undefined)
+        draft.restores.push({ key: item.key, dormantId: snap.id });
+    else if (input.isDuplicate(item))
+        draft.duplicates++;
+    else
+        draft.fresh.push({ key: item.key, hash: item.hash, supersedes: legacy });
+}
+/** A single-file store keys items by text, so an edit reads as one key gone and one new under the same heading. */
+function pairEdits(gone, fresh) {
+    const goneBy = groupBy([...gone.keys()], headingOf);
+    const freshBy = groupBy(fresh.map((w, i) => ({ w, i })), (f) => headingOf(f.w.key));
+    for (const [heading, keys] of goneBy) {
+        const news = freshBy.get(heading) ?? [];
+        if (keys.length !== 1 || news.length !== 1)
+            continue;
+        const { w, i } = news[0];
+        fresh[i] = { ...w, supersedes: [...w.supersedes, ...(gone.get(keys[0]) ?? [])] };
+        gone.delete(keys[0]);
+    }
+}
+function headingOf(key) {
+    return key.slice(0, Math.max(0, key.lastIndexOf('/')));
+}
+// Byte order, as memory.ts's timestamp note asks: localeCompare may skip the ISO punctuation.
+const byteOrder = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+function newestRow(rows) {
+    return [...rows].sort((a, b) => byteOrder(b.created, a.created) || byteOrder(b.id, a.id))[0];
+}
+function newestSnapshot(rows) {
+    return [...rows].sort((a, b) => byteOrder(b.dormantAt, a.dormantAt) || byteOrder(b.id, a.id))[0];
+}
+function groupByKey(rows) {
+    return groupBy(rows, (r) => r.key);
+}
+function groupBy(values, keyOf) {
+    const out = new Map();
+    for (const value of values) {
+        const key = keyOf(value);
+        const list = out.get(key);
+        if (list)
+            list.push(value);
+        else
+            out.set(key, [value]);
+    }
+    return out;
+}
+/** Plan design 10: same text first, then one legacy row per file name; anything else is left to decay. */
+export function matchLegacy(rows, targets) {
+    const byText = new Map();
+    for (const t of targets)
+        if (!byText.has(t.textKey))
+            byText.set(t.textKey, t.ref);
+    const adopt = new Map();
+    for (const row of rows) {
+        const ref = byText.get(row.textKey);
+        if (ref !== undefined)
+            adopt.set(row.id, ref);
+    }
+    const adoptedRefs = new Set(adopt.values());
+    const leftByFile = groupBy(rows.filter((r) => !adopt.has(r.id)), (r) => r.file);
+    const targetsByFile = groupBy(targets.filter((t) => !adoptedRefs.has(t.ref)), (t) => t.file);
+    const replace = new Map();
+    for (const [file, left] of leftByFile) {
+        const matches = targetsByFile.get(file) ?? [];
+        if (left.length === 1 && matches.length === 1)
+            replace.set(matches[0].ref, left[0].id);
+    }
+    return { adopt, replace };
+}
+//# sourceMappingURL=plan.js.map

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

@@ -0,0 +1,5 @@
+import type { Adapter } from './types.js';
+/** Qwen's own folder-name rule, so a project's container is the folder Qwen made for it. */
+export declare function sanitizeCwd(p: string, platform: NodeJS.Platform): string;
+export declare const qwenCodeAdapter: Adapter;
+//# sourceMappingURL=qwen-code.d.ts.map

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

@@ -0,0 +1,50 @@
+// Qwen Code's auto memory: markdown notes under its base folder, or inside the project when it keeps them local.
+import fs from 'node:fs';
+import path from 'node:path';
+import { splitFrontmatter } from './files.js';
+import { markdownNotes, readFolderStore } from './folder-store.js';
+/** Qwen's own folder-name rule, so a project's container is the folder Qwen made for it. */
+export function sanitizeCwd(p, platform) {
+    return (platform === 'win32' ? p.toLowerCase() : p).replace(/[^a-zA-Z0-9]/g, '-');
+}
+function baseDir(ctx) {
+    const { env } = ctx;
+    return env.QWEN_CODE_MEMORY_BASE_DIR || env.QWEN_RUNTIME_DIR || env.QWEN_HOME || path.join(ctx.home, '.qwen');
+}
+/** The nearest folder at or above `start` holding a `.git` entry; a file counts, so a linked worktree keeps its own. */
+function gitRoot(start) {
+    for (let dir = start;;) {
+        if (fs.existsSync(path.join(dir, '.git')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function projectDir(ctx, base, projectRoot) {
+    const root = path.resolve(projectRoot);
+    if (ctx.env.QWEN_CODE_MEMORY_LOCAL === '1')
+        return path.join(root, '.qwen', 'memory');
+    const key = ctx.env.QWEN_CODE_MEMORY_PROJECT_SCOPE === 'workspace' ? root : (gitRoot(root) ?? root);
+    return path.join(base, 'projects', sanitizeCwd(key, ctx.platform), 'memory');
+}
+const NOTES = {
+    recursive: true,
+    include: markdownNotes,
+    item: (text, mtimeMs) => ({ text: splitFrontmatter(text).body.trim(), updatedAt: mtimeMs }),
+};
+export const qwenCodeAdapter = {
+    tool: 'qwen-code',
+    list(ctx, scope) {
+        const base = baseDir(ctx);
+        let dir = null;
+        if (scope === 'user')
+            dir = path.join(base, 'memories');
+        else if (ctx.projectRoot !== undefined)
+            dir = projectDir(ctx, base, ctx.projectRoot);
+        const container = dir === null ? null : readFolderStore(dir, scope, NOTES);
+        return { tool: 'qwen-code', home: base, containers: container ? [container] : [], warnings: [] };
+    },
+};
+//# sourceMappingURL=qwen-code.js.map

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

@@ -0,0 +1,52 @@
+import { type ToolId } from './tools.js';
+import type { Scope } from './types.js';
+export interface Tally {
+    imported: number;
+    replaced: number;
+    restored: number;
+    setAside: number;
+    untagged: number;
+    unchanged: number;
+    adopted: number;
+    collapsed: number;
+    retagged: number;
+    handedOver: number;
+    duplicate: number;
+    secret: number;
+    short: number;
+    rejected: number;
+    unread: number;
+    unreadable: number;
+    busy: number;
+}
+export declare function emptyTally(): Tally;
+export declare function addTally(into: Tally, from: Tally): void;
+export interface ContainerSeen {
+    readonly scope: Scope;
+    readonly path: string;
+    readonly store: string;
+    readonly items: number;
+    readonly readable: boolean;
+}
+export interface ToolReport {
+    readonly tool: ToolId;
+    readonly label: string;
+    readonly homes: string[];
+    readonly containers: ContainerSeen[];
+    readonly tally: Tally;
+    /** Dry run only: kept rows in containers this run did not list, such as a moved project's old folder. */
+    unlisted: number;
+}
+export interface ImportReport {
+    readonly tools: ToolReport[];
+    readonly warnings: string[];
+}
+export declare function emptyReport(): ImportReport;
+export declare function toolReport(report: ImportReport, tool: ToolId): ToolReport;
+export declare function mergeReports(into: ImportReport, from: ImportReport): void;
+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. */
+export declare function summaryLine(report: ImportReport): string | null;
+//# sourceMappingURL=report.d.ts.map

package/dist/agent-memories/report.js

@@ -0,0 +1,88 @@
+// 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';
+export function emptyTally() {
+    return {
+        imported: 0, replaced: 0, restored: 0, setAside: 0, untagged: 0, unchanged: 0, adopted: 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);
+function isTallyField(key) {
+    return key in emptyTally();
+}
+export function addTally(into, from) {
+    for (const field of TALLY_FIELDS)
+        into[field] += from[field];
+}
+export function emptyReport() {
+    return { tools: [], warnings: [] };
+}
+export function toolReport(report, tool) {
+    const found = report.tools.find((t) => t.tool === tool);
+    if (found)
+        return found;
+    const label = AGENT_MEMORY_TOOLS.find((t) => t.id === tool)?.label ?? tool;
+    const created = { tool, label, homes: [], containers: [], tally: emptyTally(), unlisted: 0 };
+    report.tools.push(created);
+    return created;
+}
+export function mergeReports(into, from) {
+    for (const t of from.tools) {
+        const target = toolReport(into, t.tool);
+        for (const home of t.homes)
+            if (!target.homes.includes(home))
+                target.homes.push(home);
+        target.containers.push(...t.containers);
+        addTally(target.tally, t.tally);
+        target.unlisted += t.unlisted;
+    }
+    into.warnings.push(...from.warnings);
+}
+export function totalTally(report) {
+    const total = emptyTally();
+    for (const t of report.tools)
+        addTally(total, t.tally);
+    return total;
+}
+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', 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',
+};
+/** `hippo import --agents`: each tool's home, its folders and what moved; in a dry run, what would have. */
+export function detailLines(report, dryRun) {
+    const lines = [dryRun ? 'Agent memories (dry run, nothing written):' : 'Agent memories:'];
+    for (const t of report.tools) {
+        const found = t.containers.length === 0 ? ' (no memory folders found)' : '';
+        lines.push(`  ${t.label}: ${t.homes.length === 0 ? 'not found' : t.homes.join(', ')}${found}`);
+        for (const c of t.containers) {
+            lines.push(`    ${c.scope} ${c.path}: ${c.readable ? plural(c.items, 'note', 'notes') : 'unreadable'}, into ${c.store}`);
+        }
+        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)`);
+    }
+    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. */
+export function summaryLine(report) {
+    const total = totalTally(report);
+    const parts = [
+        total.replaced > 0 ? `${total.replaced} replaced` : '',
+        total.restored > 0 ? `${total.restored} brought back` : '',
+        total.setAside > 0 ? `${total.setAside} set aside` : '',
+        total.untagged > 0 ? `${plural(total.untagged, 'pinned memory', 'pinned memories')} kept with the note gone` : '',
+        total.secret > 0 ? `${total.secret} skipped for a secret` : '',
+        total.rejected > 0 ? `${total.rejected} skipped as rejected` : '',
+    ].filter((p) => p !== '');
+    if (total.imported === 0)
+        return parts.length === 0 ? null : `Agent memories: ${parts.join(', ')}.`;
+    const byTool = report.tools.filter((t) => t.tally.imported > 0).map((t) => `${t.label} ${t.tally.imported}`);
+    const head = `Imported ${plural(total.imported, 'agent memory', 'agent memories')} (${byTool.join(', ')})`;
+    return parts.length === 0 ? `${head}.` : `${head}; ${parts.join(', ')}.`;
+}
+//# sourceMappingURL=report.js.map

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

@@ -0,0 +1,16 @@
+import { type ToolId } from './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. */
+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;
+/** The key and hash of a source under `prefix`; the hash follows the last `#`, since a file name may hold one too. */
+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. */
+export declare function storedText(text: string): string;
+//# sourceMappingURL=source.d.ts.map

package/dist/agent-memories/source.js

@@ -0,0 +1,32 @@
+// 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 '../capture.js';
+import { maskEmails } from '../secret-detect.js';
+import { itemHash, sha256Hex } from './keys.js';
+import { toolSourcePrefix } from './tools.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)}`;
+}
+export function containerPrefix(tool, container) {
+    return `${toolSourcePrefix(tool)}${container}/`;
+}
+export function itemSource(prefix, key, text) {
+    return `${prefix}${key}#${itemHash(text)}`;
+}
+/** The key and hash of a source under `prefix`; the hash follows the last `#`, since a file name may hold one too. */
+export function splitSource(source, prefix) {
+    const rest = source.slice(prefix.length);
+    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. */
+export function storedText(text) {
+    const masked = maskEmails(text);
+    return masked.length > CONTENT_CAP ? `${truncateCodePointSafe(masked, CONTENT_CAP)} [truncated]` : masked;
+}
+//# sourceMappingURL=source.js.map

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

@@ -0,0 +1,33 @@
+import { type ImportReport } from './report.js';
+import { type ToolId } from './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). */
+export declare const TOOLS_ENV = "HIPPO_AGENT_MEMORY_TOOLS";
+/** Everything the adapters may know about the machine; tests hand in a scratch one. */
+export interface Machine {
+    readonly home: string;
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform: NodeJS.Platform;
+}
+export declare function currentMachine(): Machine;
+export interface SyncOptions {
+    readonly machine: Machine;
+    /** Writes nothing: each container's transaction rolls back, and a missing store is stood in for by an empty one. */
+    readonly dryRun?: boolean;
+    /** 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. */
+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;
+/** 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, then the user pass. */
+export declare function importAtSessionEnd(cwd: string, transcriptPath: string | undefined, opts: SyncOptions): ImportReport;
+/** Post-compact: the transcript folder's notes only, with no git call, no legacy adoption and no user pass, as the hook has 10 seconds. */
+export declare function importAtCompaction(hippoRoot: string, transcriptPath: string, originProject: string | undefined, 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>;
+//# sourceMappingURL=sync.d.ts.map