@kisev/memomatic 1.0.0-dev.46.gfbe1e4c6992e

package/README.md

@@ -0,0 +1,36 @@
+# memomatic
+
+[Русская версия](README.ru.md)
+
+`@kisev/memomatic` is a personal learning memory for agents following the OpenClaw
+memory architecture: a tiered Markdown corpus you can read as plain files, a
+rebuildable SQLite index with FTS5 and optional local embeddings, and a nightly
+`dream` consolidation sweep.
+
+## Install
+
+```bash
+npm install @kisev/memomatic
+```
+
+The corpus lives under `$XDG_STATE_HOME/memomatic/` (`MEMORY.md`, `USER.md`,
+daily notes, `DREAMS.md`); rules live in `$XDG_CONFIG_HOME/memomatic/MEMORY_RULES.md`.
+The `@kisev/agentomatic` installer deploys the OpenCode plugin automatically;
+standalone use runs the CLI:
+
+```bash
+memomatic dream --dry-run
+```
+
+The nightly sweep is scheduled by the systemd user units in `assets/systemd/`
+(`memomatic-dream.service` and `memomatic-dream.timer`).
+
+## Surfaces
+
+- `memomatic` CLI: corpus inspection and the `dream` sweep.
+- MCP stdio server with `memory_search`, `memory_get`, `memory_write`, and
+  `memory_forget` tools.
+- The OpenCode plugin re-exported by `@kisev/agentomatic`.
+
+Nothing is deleted without the explicit directives documented in
+`MEMORY_RULES.md`.

package/README.ru.md

@@ -0,0 +1,35 @@
+# memomatic
+
+[English version](README.md)
+
+`@kisev/memomatic` — персональная обучающая память для агентов по архитектуре
+памяти OpenClaw: ярусный Markdown-корпус, который можно читать как обычные файлы,
+пересобираемый SQLite-индекс с FTS5 и опциональными локальными эмбеддингами и
+ночной проход консолидации `dream`.
+
+## Установка
+
+```bash
+npm install @kisev/memomatic
+```
+
+Корпус живёт в `$XDG_STATE_HOME/memomatic/` (`MEMORY.md`, `USER.md`, ежедневные
+записи, `DREAMS.md`); правила — в `$XDG_CONFIG_HOME/memomatic/MEMORY_RULES.md`.
+Установщик `@kisev/agentomatic` разворачивает плагин OpenCode автоматически;
+автономное использование — через CLI:
+
+```bash
+memomatic dream --dry-run
+```
+
+Ночной проход планируют user-юниты systemd из `assets/systemd/`
+(`memomatic-dream.service` и `memomatic-dream.timer`).
+
+## Поверхности
+
+- CLI `memomatic`: инспекция корпуса и проход `dream`.
+- MCP-сервер stdio с инструментами `memory_search`, `memory_get`,
+  `memory_write` и `memory_forget`.
+- Плагин OpenCode, реэкспортируемый пакетом `@kisev/agentomatic`.
+
+Без явных директив, описанных в `MEMORY_RULES.md`, ничего не удаляется.

package/assets/systemd/memomatic-dream.service

@@ -0,0 +1,9 @@
+[Unit]
+Description=Memomatic dream: background memory consolidation sweep
+Documentation=https://github.com/kisev/skills#memomatic
+After=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=/bin/sh -lc 'exec memomatic dream'
+Environment=MEMOMATIC_DREAM=1

package/assets/systemd/memomatic-dream.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=Run the Memomatic dream sweep nightly
+
+[Timer]
+OnCalendar=*-*-* 03:30:00
+RandomizedDelaySec=30m
+Persistent=true
+
+[Install]
+WantedBy=timers.target

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+import { openMemomatic, rebuildIndex, searchMemory } from "./service.js";
+import { runDream } from "./dream.js";
+import { OpenCodeExecutor } from "./executor.js";
+import { handleMcpRequest } from "./mcp.js";
+const USAGE = `usage: memomatic <command> [args]
+
+commands:
+  dream [--dry-run]        run the consolidation sweep (scheduled by memomatic-dream.timer)
+  search <query>           search memory from the command line
+  status                   report corpus and index status
+  index                    rebuild the search index
+  mcp-serve                run the MCP stdio server`;
+function parseArguments(argv) {
+    const [command, ...rest] = argv;
+    if (!command || command === "help" || command === "--help") {
+        process.stderr.write(USAGE);
+        process.exitCode = command ? 0 : 2;
+        return { command: "", rest };
+    }
+    return { command, rest };
+}
+async function main() {
+    const { command, rest } = parseArguments(process.argv.slice(2));
+    if (!command)
+        return;
+    if (command === "mcp-serve") {
+        const { runMcpServer } = await import("./mcp.js");
+        await runMcpServer();
+        return;
+    }
+    if (command === "mcp-selftest") {
+        process.stdout.write(await handleMcpRequest({ id: 1, method: "tools/list" }));
+        return;
+    }
+    const context = await openMemomatic();
+    try {
+        if (command === "dream") {
+            const dryRun = rest.includes("--dry-run");
+            const executor = context.settings.dream.model
+                ? new OpenCodeExecutor({
+                    model: context.settings.dream.model,
+                    variant: context.settings.dream.variant,
+                })
+                : null;
+            const report = await runDream(context, executor, { dryRun });
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+            return;
+        }
+        if (command === "search") {
+            const query = rest.join(" ").trim();
+            if (!query)
+                throw new Error("search requires a query");
+            for (const hit of await searchMemory(context, query))
+                process.stdout.write(`${hit.score.toFixed(3)}  ${hit.entry.file.replace(`${context.paths.stateRoot}/`, "")}:${hit.entry.line}  ${hit.snippet}\n`);
+            return;
+        }
+        if (command === "status") {
+            const count = await rebuildIndex(context);
+            const fts = context.store.hasFts();
+            process.stdout.write(`${JSON.stringify({ entries: count, fts5: fts, stateRoot: context.paths.stateRoot }, null, 2)}\n`);
+            return;
+        }
+        if (command === "index") {
+            process.stdout.write(`${await rebuildIndex(context)} entries indexed\n`);
+            return;
+        }
+        process.stderr.write(`unknown command: ${command}\n${USAGE}`);
+        process.exitCode = 2;
+    }
+    finally {
+        context.store.close();
+    }
+}
+await main();

package/dist/corpus.d.ts

@@ -0,0 +1,12 @@
+import { type CorpusEntry } from "./entries.js";
+import type { MemomaticPaths } from "./paths.js";
+export declare function readTextIfExists(path: string): Promise<string | undefined>;
+export declare function writeCorpusFile(paths: MemomaticPaths, file: string, next: string): Promise<void>;
+export declare function dailyNotePath(paths: MemomaticPaths, date?: Date): string;
+export declare function entryKind(file: string): "curated" | "user" | "episodic";
+export declare function parseCorpusEntries(markdown: string, file: string): CorpusEntry[];
+export declare function appendDailyEntry(paths: MemomaticPaths, line: string, date?: Date): Promise<string>;
+export declare function replaceEntryLine(paths: MemomaticPaths, file: string, line: number, replacement: string | null): Promise<void>;
+export declare function appendDreams(paths: MemomaticPaths, report: string): Promise<void>;
+export declare function archiveFile(paths: MemomaticPaths, file: string): Promise<string>;
+export declare function isCuratedFile(file: string): boolean;

package/dist/corpus.js

@@ -0,0 +1,138 @@
+import { createHash } from "node:crypto";
+import { lstat, mkdir, open, readFile, rm } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { writeAtomic } from "@kisev/safe-fs";
+import { parseEntryLine } from "./entries.js";
+const CURATED_FILES = ["MEMORY.md", "USER.md"];
+function inside(root, target) {
+    const value = relative(root, target);
+    return value === "" || (!value.startsWith("..") && value !== "..");
+}
+async function safeDirectory(path, boundary, create) {
+    if (!inside(boundary, path))
+        throw new Error("memomatic path escapes its root");
+    if (create)
+        await mkdir(path, { mode: 0o700, recursive: true });
+    let current = boundary;
+    for (const piece of relative(current, path).split("/").filter(Boolean)) {
+        current = join(current, piece);
+        const info = await lstat(current);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new Error(`memomatic directory is unsafe: ${current}`);
+    }
+}
+async function writePreImage(paths, source, previous) {
+    await safeDirectory(paths.historyDir, paths.stateRoot, true);
+    const name = `${createHash("sha256").update(previous).digest("hex")}.md`;
+    const target = join(paths.historyDir, name);
+    try {
+        const file = await open(target, "wx", 0o600);
+        try {
+            await file.writeFile(previous);
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+        const info = await lstat(target);
+        if (!info.isFile() || info.isSymbolicLink() || !(await readFile(target)).equals(previous))
+            throw new Error("memomatic history was changed");
+    }
+}
+export async function readTextIfExists(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+export async function writeCorpusFile(paths, file, next) {
+    if (!inside(paths.stateRoot, file))
+        throw new Error("memomatic path escapes its root");
+    const previous = await readFile(file).catch(() => undefined);
+    if (previous !== undefined && previous.toString("utf8") === next)
+        return;
+    await safeDirectory(dirname(file), paths.stateRoot, true);
+    if (previous !== undefined)
+        await writePreImage(paths, file, previous);
+    await writeAtomic(file, Buffer.from(next), 0o600);
+}
+export function dailyNotePath(paths, date = new Date()) {
+    const iso = date.toISOString().slice(0, 10);
+    return join(paths.dailyDir, `${iso}.md`);
+}
+export function entryKind(file) {
+    const name = file.slice(file.lastIndexOf("/") + 1);
+    if (name === "MEMORY.md")
+        return "curated";
+    if (name === "USER.md")
+        return "user";
+    return "episodic";
+}
+export function parseCorpusEntries(markdown, file) {
+    const entries = [];
+    const lines = markdown.split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const parsed = parseEntryLine(lines[index]);
+        if (!parsed)
+            continue;
+        entries.push({ file, line: index + 1, text: parsed.text, annotations: parsed.annotations });
+    }
+    return entries;
+}
+export async function appendDailyEntry(paths, line, date = new Date()) {
+    const file = dailyNotePath(paths, date);
+    const current = (await readTextIfExists(file)) ?? "";
+    const next = current.length ? `${current.trimEnd()}\n${line}\n` : `${line}\n`;
+    await writeCorpusFile(paths, file, next);
+    return file;
+}
+export async function replaceEntryLine(paths, file, line, replacement) {
+    const content = await readFile(file, "utf8");
+    const lines = content.split("\n");
+    if (line < 1 || line > lines.length)
+        throw new Error("entry line is out of range");
+    if (replacement === null) {
+        lines.splice(line - 1, 1);
+        const rest = lines.join("\n");
+        await writeCorpusFile(paths, file, rest.length ? `${rest}` : "");
+        return;
+    }
+    lines[line - 1] = replacement;
+    await writeCorpusFile(paths, file, lines.join("\n"));
+}
+export async function appendDreams(paths, report) {
+    const stamp = new Date().toISOString().replace("T", " ").slice(0, 16);
+    const current = (await readTextIfExists(paths.dreamsFile)) ?? "";
+    const block = `## ${stamp}\n\n${report.trim()}\n\n`;
+    const next = `${current}${current.length ? "\n" : ""}${block}`;
+    await writeCorpusFile(paths, paths.dreamsFile, next);
+}
+export async function archiveFile(paths, file) {
+    if (!inside(paths.stateRoot, file))
+        throw new Error("memomatic path escapes its root");
+    const name = file.slice(file.lastIndexOf("/") + 1);
+    const target = join(paths.archiveDir, `${name}`);
+    await safeDirectory(paths.archiveDir, paths.stateRoot, true);
+    const content = await readFile(file);
+    const existing = await readFile(target).catch(() => undefined);
+    if (existing !== undefined) {
+        const merged = `${existing.toString("utf8").trimEnd()}\n${content.toString("utf8").trimEnd()}\n`;
+        await writeAtomic(target, Buffer.from(merged), 0o600);
+    }
+    else {
+        await writeAtomic(target, content, 0o600);
+    }
+    await rm(file);
+    return target;
+}
+export function isCuratedFile(file) {
+    return CURATED_FILES.some((name) => file.endsWith(name));
+}

package/dist/dream.d.ts

@@ -0,0 +1,37 @@
+import { type ModelExecutor } from "./executor.js";
+import type { MemomaticContext } from "./service.js";
+export type DreamReport = {
+    sessionsIngested: number;
+    candidatesExtracted: number;
+    promoted: string[];
+    superseded: string[];
+    dropped: string[];
+    rejected: Array<{
+        text: string;
+        reason: string;
+    }>;
+    archived: string[];
+    appendOnlyFallback: boolean;
+    dryRun: boolean;
+};
+export type ExtractedCandidate = {
+    text: string;
+    key: string | null;
+    reason: string;
+};
+export declare function parseExtraction(response: string): ExtractedCandidate[];
+export type ConsolidationOperation = {
+    op: "add";
+    line: string;
+} | {
+    op: "supersede";
+    key: string;
+    line: string;
+} | {
+    op: "drop";
+    key: string;
+};
+export declare function parseConsolidation(response: string): ConsolidationOperation[];
+export declare function runDream(context: MemomaticContext, executor: ModelExecutor | null, options?: {
+    dryRun?: boolean;
+}): Promise<DreamReport>;

package/dist/dream.js

@@ -0,0 +1,249 @@
+import { entryLine, parseEntryLine } from "./entries.js";
+import { appendDailyEntry, appendDreams, readTextIfExists, writeCorpusFile } from "./corpus.js";
+import { promotionCandidates } from "./gates.js";
+import { extractJson } from "./executor.js";
+import { loadRecentSessions, opencodeDatabasePath } from "./ingest.js";
+import { isForbidden } from "./rules.js";
+import { reindex } from "./search.js";
+import { archiveOldEpisodic } from "./service.js";
+const WATERMARK_KEY = "ingest-watermark";
+const EXTRACT_SYSTEM = `You distill durable engineering memory from a coding session.
+Reply with exactly one JSON object of the form
+{"candidates":[{"text":string,"key":string|null,"reason":string}]}.
+Include only standing decisions with rationale, discoveries, failed attempts with
+the reason they were rejected, session outcomes, and action-sensitive boundaries
+(approval requirements, temporary constraints, handoffs, expiry conditions).
+Each "text" is imperative, self-contained, at most two sentences, without secrets,
+credentials, or machine-local paths. "key" is a stable kebab-case identifier when
+the item clearly has a durable identity, otherwise null. Return {"candidates":[]}
+when nothing qualifies.`;
+const CONSOLIDATE_SYSTEM = `You consolidate a long-term memory file.
+Reply with exactly one JSON object of the form
+{"operations":[{"op":"add","line":string},{"op":"supersede","key":string,"line":string},{"op":"drop","key":string}]}.
+Merge duplicates, supersede outdated entries sharing a key instead of appending,
+keep every line compact (at most two sentences), keep or assign "key" annotations
+in the form <!-- key: ... -->, and add <!-- trigger: ... --> phrases only when a
+clear activation context exists. Never invent keys for "supersede" or "drop" that
+are not present in the current file.`;
+export function parseExtraction(response) {
+    const parsed = extractJson(response);
+    if (!Array.isArray(parsed.candidates))
+        throw new Error("extraction response has no candidates");
+    const result = [];
+    for (const raw of parsed.candidates) {
+        const value = raw;
+        if (typeof value.text !== "string" || !value.text.trim())
+            continue;
+        result.push({
+            text: value.text.trim(),
+            key: typeof value.key === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value.key)
+                ? value.key
+                : null,
+            reason: typeof value.reason === "string" ? value.reason : "",
+        });
+    }
+    return result.slice(0, 24);
+}
+export function parseConsolidation(response) {
+    const parsed = extractJson(response);
+    if (!Array.isArray(parsed.operations))
+        throw new Error("consolidation response has no operations");
+    const result = [];
+    for (const raw of parsed.operations) {
+        const value = raw;
+        if (value.op === "add" && typeof value.line === "string") {
+            const line = value.line.trim();
+            if (parseEntryLine(line))
+                result.push({ op: "add", line });
+        }
+        else if (value.op === "supersede" &&
+            typeof value.key === "string" &&
+            typeof value.line === "string") {
+            const line = value.line.trim();
+            if (parseEntryLine(line))
+                result.push({ op: "supersede", key: value.key, line });
+        }
+        else if (value.op === "drop" && typeof value.key === "string") {
+            result.push({ op: "drop", key: value.key });
+        }
+    }
+    return result.slice(0, 32);
+}
+async function ingestSessions(context, executor) {
+    const watermark = Number.parseInt(context.store.getMeta(WATERMARK_KEY) ?? "0", 10) || 0;
+    const sessions = loadRecentSessions(opencodeDatabasePath(), watermark, {
+        before: Date.now() - 10 * 60_000,
+        maxSessions: 20,
+        maxCharsPerSession: 24_000,
+    });
+    const extracted = [];
+    const rejected = [];
+    let latest = watermark;
+    for (const session of sessions) {
+        latest = Math.max(latest, session.timeCreated);
+        if (!executor)
+            continue;
+        const transcript = session.messages
+            .map((message) => `${message.role}: ${message.text}`)
+            .join("\n\n")
+            .slice(0, 24_000);
+        const response = await executor.complete({
+            system: EXTRACT_SYSTEM,
+            prompt: `Session title: ${session.title}\nWorking directory: ${session.directory}\n\n${transcript}`,
+        });
+        for (const candidate of parseExtraction(response)) {
+            if (isForbidden(candidate.text, context.rules)) {
+                rejected.push({ text: candidate.text, reason: "never-save rule" });
+                continue;
+            }
+            extracted.push(candidate);
+        }
+    }
+    return {
+        sessions: sessions.length,
+        extracted,
+        watermark: sessions.length ? latest : null,
+        rejected,
+    };
+}
+export async function runDream(context, executor, options = {}) {
+    const dryRun = options.dryRun === true;
+    const report = {
+        sessionsIngested: 0,
+        candidatesExtracted: 0,
+        promoted: [],
+        superseded: [],
+        dropped: [],
+        rejected: [],
+        archived: [],
+        appendOnlyFallback: false,
+        dryRun,
+    };
+    await reindex(context.paths, context.settings, context.store);
+    const ingestion = await ingestSessions(context, executor);
+    report.sessionsIngested = ingestion.sessions;
+    report.candidatesExtracted = ingestion.extracted.length;
+    report.rejected = ingestion.rejected;
+    if (!dryRun) {
+        for (const candidate of ingestion.extracted) {
+            await appendDailyEntry(context.paths, entryLine(candidate.text, {
+                key: candidate.key ?? undefined,
+                origin: "agent",
+                observed: new Date().toISOString().slice(0, 10),
+            }));
+        }
+        if (ingestion.watermark !== null)
+            context.store.setMeta(WATERMARK_KEY, String(ingestion.watermark));
+    }
+    await reindex(context.paths, context.settings, context.store);
+    const relevance = new Map();
+    for (const entry of context.store.allEntries()) {
+        if (entry.kind !== "episodic")
+            continue;
+        const usage = context.store.usageFor(entry.stableId);
+        if (usage.useful < context.settings.dream.minUseful)
+            continue;
+        const match = context.store.ftsSearch(entry.text, 10).get(entry.stableId);
+        if (match)
+            relevance.set(entry.stableId, match);
+    }
+    const finalCandidates = promotionCandidates(context.store, context.settings, relevance);
+    if (executor && finalCandidates.length) {
+        const current = (await readTextIfExists(context.paths.memoryFile)) ?? "";
+        const response = await executor.complete({
+            system: CONSOLIDATE_SYSTEM,
+            prompt: `Current MEMORY.md:\n${current || "(empty)"}\n\nCandidates:\n${finalCandidates
+                .map((candidate) => `- ${candidate.entry.text} <!-- key: ${candidate.entry.key ?? candidate.entry.stableId} -->`)
+                .join("\n")}`,
+        });
+        const operations = parseConsolidation(response);
+        const outcome = await applyConsolidation(context, operations, current, dryRun);
+        report.promoted = outcome.promoted;
+        report.superseded = outcome.superseded;
+        report.dropped = outcome.dropped;
+        report.appendOnlyFallback = outcome.appendOnlyFallback;
+    }
+    if (!dryRun)
+        report.archived = await archiveOldEpisodic(context);
+    await reindex(context.paths, context.settings, context.store);
+    const summary = [
+        `- sessions ingested: ${report.sessionsIngested}`,
+        `- candidates extracted: ${report.candidatesExtracted}`,
+        `- promoted: ${report.promoted.length}${report.promoted.length ? ` (${report.promoted.join(", ")})` : ""}`,
+        `- superseded: ${report.superseded.length ? report.superseded.join(", ") : "none"}`,
+        `- dropped: ${report.dropped.length ? report.dropped.join(", ") : "none"}`,
+        `- rejected by rules: ${report.rejected.length}`,
+        `- archived files: ${report.archived.length ? report.archived.join(", ") : "none"}`,
+        `- append-only fallback: ${report.appendOnlyFallback}`,
+        `- dry run: ${report.dryRun}`,
+    ].join("\n");
+    if (!dryRun)
+        await appendDreams(context.paths, summary);
+    return report;
+}
+async function applyConsolidation(context, operations, currentMemory, dryRun) {
+    const result = {
+        promoted: [],
+        superseded: [],
+        dropped: [],
+        appendOnlyFallback: false,
+    };
+    if (!operations.length)
+        return result;
+    const lines = currentMemory.split("\n").filter((line) => line.trim().length > 0);
+    const existingKeys = new Set(lines
+        .map((line) => parseEntryLine(line)?.annotations.key)
+        .filter((key) => Boolean(key)));
+    const removals = operations.filter((operation) => operation.op !== "add");
+    const lossRatio = lines.length ? removals.length / lines.length : 0;
+    const adds = operations.filter((operation) => operation.op === "add");
+    const supersessions = operations.filter((operation) => operation.op === "supersede" && existingKeys.has(operation.key));
+    const drops = operations.filter((operation) => operation.op === "drop" && existingKeys.has(operation.key));
+    if (removals.length !== supersessions.length + drops.length)
+        result.appendOnlyFallback = true;
+    if (!result.appendOnlyFallback && lossRatio > context.settings.dream.maxPriorEntryLoss)
+        result.appendOnlyFallback = true;
+    if (result.appendOnlyFallback) {
+        const budget = context.settings.dream.memoryBudgetLines;
+        if (lines.length + adds.length > budget)
+            return result;
+        const next = `${lines.join("\n")}\n${adds.map((operation) => operation.line).join("\n")}\n`;
+        if (!dryRun)
+            await writeCorpusFile(context.paths, context.paths.memoryFile, next);
+        result.promoted = adds.map((operation) => operation.line);
+        return result;
+    }
+    const nextLines = [...lines];
+    for (const operation of supersessions) {
+        const index = nextLines.findIndex((line) => parseEntryLine(line)?.annotations.key === operation.key);
+        if (index === -1)
+            continue;
+        nextLines[index] = operation.line;
+        result.superseded.push(operation.key);
+    }
+    for (const operation of drops) {
+        const index = nextLines.findIndex((line) => parseEntryLine(line)?.annotations.key === operation.key);
+        if (index === -1)
+            continue;
+        nextLines.splice(index, 1);
+        result.dropped.push(operation.key);
+    }
+    for (const operation of adds) {
+        const key = parseEntryLine(operation.line)?.annotations.key;
+        if (key && nextLines.some((line) => parseEntryLine(line)?.annotations.key === key))
+            continue;
+        nextLines.push(operation.line);
+        result.promoted.push(operation.line);
+    }
+    if (nextLines.length > context.settings.dream.memoryBudgetLines) {
+        result.appendOnlyFallback = true;
+        result.promoted = [];
+        result.superseded = [];
+        result.dropped = [];
+        return result;
+    }
+    const next = `${nextLines.join("\n")}\n`;
+    if (!dryRun)
+        await writeCorpusFile(context.paths, context.paths.memoryFile, next);
+    return result;
+}

package/dist/entries.d.ts

@@ -0,0 +1,25 @@
+export type EntryAnnotations = {
+    key?: string;
+    status?: "active" | "superseded";
+    origin?: "user" | "agent";
+    observed?: string;
+    project?: string;
+    importance?: number;
+    trigger?: string[];
+    pinned?: boolean;
+};
+export type CorpusEntry = {
+    file: string;
+    line: number;
+    text: string;
+    annotations: EntryAnnotations;
+};
+export declare function parseEntryLine(line: string): {
+    text: string;
+    annotations: EntryAnnotations;
+} | null;
+export declare function serializeAnnotations(annotations: EntryAnnotations): string;
+export declare function entryLine(text: string, annotations: EntryAnnotations): string;
+export declare function entryKey(entry: CorpusEntry): string | null;
+export declare function entryImportance(entry: CorpusEntry): number;
+export declare function entryObservedAt(entry: CorpusEntry): number;