hippo-memory 1.52.8 → 1.53.0

package/dist/agent-memories/files.js

@@ -0,0 +1,77 @@
+// 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';
+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 };
+    }
+    catch (err) {
+        return { ok: false, reason: `${file}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/** 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))
+        return { status: 'missing' };
+    try {
+        if (!fs.statSync(dir).isDirectory())
+            return { status: 'unreadable', reason: `${dir}: not a folder` };
+        const files = [];
+        walk(dir, '', opts.recursive ? MAX_DEPTH : 0, files);
+        return { status: 'ok', files: files.sort() };
+    }
+    catch (err) {
+        return { status: 'unreadable', reason: `${dir}: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+function walk(root, rel, depthLeft, out) {
+    for (const entry of fs.readdirSync(path.join(root, rel), { withFileTypes: true })) {
+        if (entry.name.startsWith('.'))
+            continue;
+        const child = rel === '' ? entry.name : `${rel}/${entry.name}`;
+        if (entry.isFile() || (entry.isSymbolicLink() && isFile(path.join(root, child))))
+            out.push(child);
+        else if (entry.isDirectory() && depthLeft > 0)
+            walk(root, child, depthLeft - 1, out);
+    }
+}
+function isFile(p) {
+    return fs.statSync(p, { throwIfNoEntry: false })?.isFile() === true;
+}
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+export function splitFrontmatter(raw) {
+    const m = raw.match(FRONTMATTER);
+    return m ? { yaml: m[1], body: m[2] } : { yaml: null, body: raw };
+}
+/** One top-level scalar from frontmatter YAML, quotes removed; enough for `modified`, no YAML parser needed. */
+export function frontmatterField(yaml, field) {
+    const m = yaml.match(new RegExp(`^${field}:[ \\t]*(.+?)[ \\t]*$`, 'm'));
+    if (!m)
+        return null;
+    return m[1].replace(/^(['"])(.*)\1$/, '$2');
+}
+/** An item's time: the date string when it parses and is not in the future, else the fallback. */
+export function itemTime(dateText, fallbackMs, nowMs = Date.now()) {
+    const parsed = dateText === null ? NaN : Date.parse(dateText);
+    const t = Number.isFinite(parsed) ? parsed : fallbackMs;
+    return Math.min(t, nowMs);
+}
+/** `~/x` against the given home; anything else unchanged. */
+export function expandHome(p, home) {
+    return p === '~' ? home : p.startsWith('~/') || p.startsWith('~\\') ? path.join(home, p.slice(2)) : p;
+}
+//# sourceMappingURL=files.js.map

package/dist/agent-memories/folder-store.d.ts

@@ -0,0 +1,17 @@
+import type { Container, Scope } from './types.js';
+export interface FolderRules {
+    readonly recursive: boolean;
+    readonly include: (rel: string) => boolean;
+    /** The stored text and time of a file read in full, or null when the tool would not count it as a note. */
+    readonly item: (text: string, mtimeMs: number) => {
+        readonly text: string;
+        readonly updatedAt: number;
+    } | null;
+}
+/** Null when the folder is missing; a file that could not be read is `skipped`, so its row is left alone. */
+export declare function readFolderStore(dir: string, scope: Scope, rules: FolderRules): Container | null;
+/** Markdown notes directly in, or anywhere under, the folder, with the tool's index file left out. */
+export declare function markdownNotes(rel: string): boolean;
+/** Each folder once, compared case-insensitively on win32 as the file system does. */
+export declare function uniqueFolders(folders: readonly string[], platform: NodeJS.Platform): string[];
+//# sourceMappingURL=folder-store.d.ts.map

package/dist/agent-memories/folder-store.js

@@ -0,0 +1,44 @@
+// A folder whose files are the items, as Claude Code, Gemini, Qwen and Copilot keep them: one reader for all four.
+import path from 'node:path';
+import { listFiles, readTextFile } from './files.js';
+/** Null when the folder is missing; a file that could not be read is `skipped`, so its row is left alone. */
+export function readFolderStore(dir, scope, rules) {
+    const listing = listFiles(dir, { recursive: rules.recursive });
+    if (listing.status === 'missing')
+        return null;
+    if (listing.status === 'unreadable') {
+        return { scope, path: dir, readable: false, items: [], skipped: [], warnings: [listing.reason], textKeyed: false };
+    }
+    const items = [];
+    const skipped = [];
+    const warnings = [];
+    for (const key of listing.files.filter(rules.include)) {
+        const file = readTextFile(path.join(dir, key));
+        if (!file.ok) {
+            skipped.push(key);
+            warnings.push(file.reason);
+            continue;
+        }
+        const item = rules.item(file.text, file.mtimeMs);
+        if (item !== null)
+            items.push({ key, ...item });
+    }
+    return { scope, path: dir, readable: true, items, skipped, warnings, textKeyed: false };
+}
+/** Markdown notes directly in, or anywhere under, the folder, with the tool's index file left out. */
+export function markdownNotes(rel) {
+    return rel.endsWith('.md') && rel !== 'MEMORY.md';
+}
+/** Each folder once, compared case-insensitively on win32 as the file system does. */
+export function uniqueFolders(folders, platform) {
+    const seen = new Set();
+    return folders.filter((folder) => {
+        const resolved = path.resolve(folder);
+        const key = platform === 'win32' ? resolved.toLowerCase() : resolved;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+//# sourceMappingURL=folder-store.js.map

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

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

package/dist/agent-memories/gemini.js

@@ -0,0 +1,103 @@
+// 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.js';
+import { isJsonObject } from '../hooks.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';
+const SECTION = 'gemini added memories';
+export const geminiAdapter = {
+    tool: 'gemini',
+    list(ctx, scope) {
+        const home = path.join(ctx.env.GEMINI_CLI_HOME || ctx.home, '.gemini');
+        if (scope === 'user')
+            return { tool: 'gemini', home, containers: userContainers(home), warnings: [] };
+        return projectListing(ctx, home);
+    },
+};
+function refused(scope, file, reason, textKeyed) {
+    return { scope, path: file, readable: false, items: [], skipped: [], warnings: [reason], textKeyed };
+}
+function userContainers(home) {
+    const file = path.join(home, 'GEMINI.md');
+    if (!fs.existsSync(file))
+        return [];
+    const read = readTextFile(file);
+    if (!read.ok)
+        return [refused('user', file, read.reason, true)];
+    const kept = splitMarkdownItems(read.text).filter((item) => item.heading.toLowerCase() === SECTION);
+    const keys = textItemKeys(kept);
+    const items = kept.map((item, i) => ({ key: keys[i], text: item.text, updatedAt: read.mtimeMs }));
+    return [{ scope: 'user', path: file, readable: true, items, skipped: [], warnings: [], textKeyed: true }];
+}
+function projectListing(ctx, home) {
+    const warnings = [];
+    const containers = [];
+    if (ctx.projectRoot !== undefined) {
+        const slug = projectSlug(ctx, ctx.projectRoot, home, warnings);
+        const container = slug === null ? null : readFolderStore(path.join(home, 'tmp', slug, 'memory'), 'project', NOTES);
+        if (container !== null)
+            containers.push(container);
+    }
+    return { tool: 'gemini', home, containers, warnings };
+}
+function projectSlug(ctx, projectRoot, home, warnings) {
+    const index = path.join(home, 'projects.json');
+    if (!fs.existsSync(index))
+        return null;
+    const read = readTextFile(index);
+    if (!read.ok) {
+        warnings.push(read.reason);
+        return null;
+    }
+    let projects;
+    try {
+        projects = parseIndex(read.text);
+    }
+    catch (err) {
+        warnings.push(`${index}: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    // The git top level is only asked for when the folder itself has no entry, since it spawns git.
+    const entry = findEntry(projects, projectRoot, ctx.platform) ?? topEntry(projects, projectRoot, ctx.platform);
+    if (entry === undefined)
+        return null;
+    const [key, slug] = entry;
+    if (isStringValue(slug) && isPlainName(slug))
+        return slug;
+    warnings.push(`${index}: the slug for ${key} is not a plain folder name`);
+    return null;
+}
+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))
+        throw new Error('expected { "projects": { "<absolute path>": "<slug>" } }');
+    return projects;
+}
+function isPlainName(slug) {
+    return slug !== '' && slug !== '.' && slug !== '..' && !/[\\/]/.test(slug);
+}
+function fold(p, platform) {
+    const resolved = path.resolve(p);
+    return platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+// A relative key would resolve against the working folder, which no adapter may read.
+function findEntry(projects, target, platform) {
+    const want = fold(target, platform);
+    return Object.entries(projects).find(([key]) => path.isAbsolute(key) && fold(key, platform) === want);
+}
+function topEntry(projects, projectRoot, platform) {
+    const top = gitLayout(projectRoot)?.top;
+    return top === undefined ? undefined : findEntry(projects, top, platform);
+}
+const NOTES = {
+    recursive: false,
+    include: markdownNotes,
+    item: (text, mtimeMs) => ({ text: splitFrontmatter(text).body.trim(), updatedAt: mtimeMs }),
+};
+//# sourceMappingURL=gemini.js.map

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

@@ -0,0 +1,8 @@
+export interface GitLayout {
+    readonly top: string;
+    readonly gitDir: string;
+    readonly common: string;
+}
+/** Null outside a repository or when git fails; a missing folder name then only means fewer containers listed. */
+export declare function gitLayout(projectRoot: string): GitLayout | null;
+//# sourceMappingURL=git.d.ts.map

package/dist/agent-memories/git.js

@@ -0,0 +1,11 @@
+// The git layout of a project root, which Claude Code, Gemini and Copilot use to name a project's memory folder.
+import { spawnSync } from 'node:child_process';
+/** Null outside a repository or when git fails; a missing folder name then only means fewer containers listed. */
+export function gitLayout(projectRoot) {
+    const git = spawnSync('git', ['rev-parse', '--path-format=absolute', '--show-toplevel', '--absolute-git-dir', '--git-common-dir'], { cwd: projectRoot, encoding: 'utf8', timeout: 10000, windowsHide: true });
+    if (git.status !== 0)
+        return null;
+    const [top, gitDir, common] = git.stdout.trim().split(/\r?\n/);
+    return top && gitDir && common ? { top, gitDir, common } : null;
+}
+//# sourceMappingURL=git.js.map

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

@@ -0,0 +1,9 @@
+export declare function sha256Hex(text: string): string;
+/** The `#<hash>` part of a source: 16 hex of the full text, so an edit past the content cap is still seen. */
+export declare function itemHash(text: string): string;
+/** Keys for a single-file store's items: `<heading slug>/<12 hex of the text>`, `~2`, `~3` on repeats. */
+export declare function textItemKeys(items: readonly {
+    readonly headingSlug: string;
+    readonly text: string;
+}[]): string[];
+//# sourceMappingURL=keys.d.ts.map

package/dist/agent-memories/keys.js

@@ -0,0 +1,20 @@
+// 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';
+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);
+}
+/** 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 n = (seen.get(base) ?? 0) + 1;
+        seen.set(base, n);
+        return n === 1 ? base : `${base}~${n}`;
+    });
+}
+//# sourceMappingURL=keys.js.map

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

@@ -0,0 +1,17 @@
+import type { DatabaseSyncLike } from '../db.js';
+import type { MemoryEntry } from '../memory.js';
+import type { Listing } from './types.js';
+export declare const LEGACY_SOURCE_PREFIX = "claude-memory:";
+export interface ContainerLegacy {
+    readonly adopt: Map<string, MemoryEntry[]>;
+    readonly replace: Map<string, MemoryEntry[]>;
+}
+export interface LegacyWork {
+    /** By container path. */
+    readonly byContainer: ReadonlyMap<string, ContainerLegacy>;
+    /** 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;
+//# sourceMappingURL=legacy.d.ts.map

package/dist/agent-memories/legacy.js

@@ -0,0 +1,45 @@
+// 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 { selectLiveEntriesBySourcePrefix } from '../store.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() };
+    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)) });
+            refs.push({ dir: container.path, key: item.key });
+        }
+    }
+    const match = matchLegacy(rows.map((r) => ({ id: r.id, file: r.source.slice(LEGACY_SOURCE_PREFIX.length), textKey: duplicateKey(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() };
+        byContainer.set(dir, found);
+        found[pick].set(key, [...(found[pick].get(key) ?? []), row]);
+    };
+    for (const [id, ref] of match.adopt)
+        add('adopt', ref, id);
+    for (const [ref, id] of match.replace)
+        add('replace', ref, id);
+    return { byContainer, adopted: new Set(match.adopt.keys()) };
+}
+//# sourceMappingURL=legacy.js.map

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

@@ -0,0 +1,13 @@
+/**
+ * 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;
+    readonly text: string;
+}
+/** Lowercase, punctuation runs folded to '-', cut to 40 characters; 'top' when nothing is left. */
+export declare function slugHeading(heading: string): string;
+/** Split markdown into memory items in file order; headings set context and are never items. */
+export declare function splitMarkdownItems(markdown: string): MarkdownItem[];
+//# sourceMappingURL=markdown.d.ts.map

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