renor-engine 0.0.0-stage → 1.0.0

package/dist/memorymap/memoryMap.js

@@ -0,0 +1,1568 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOFOLLOW = exports.DEFAULT_MAP_LIMIT = exports.RETIRED_DIR = void 0;
+exports.resolveVaultFile = resolveVaultFile;
+exports.parseEntries = parseEntries;
+exports.appendedEntryId = appendedEntryId;
+exports.parseMemoryId = parseMemoryId;
+exports.openConfined = openConfined;
+exports.readPrefix = readPrefix;
+exports.readWhole = readWhole;
+exports.ensureRealDir = ensureRealDir;
+exports.readJournal = readJournal;
+exports.activeRetired = activeRetired;
+exports.buildMemoryMap = buildMemoryMap;
+exports.findMemories = findMemories;
+exports.readMemory = readMemory;
+exports.retireMemory = retireMemory;
+exports.restoreMemory = restoreMemory;
+exports.purgeRetired = purgeRetired;
+exports.dailyEntriesForExport = dailyEntriesForExport;
+exports.retiredForExport = retiredForExport;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const hasher_1 = require("../indexer/hasher");
+const parser_1 = require("../indexer/parser");
+const walker_1 = require("../indexer/walker");
+const pipeline_1 = require("../indexer/pipeline");
+const lifecycle_1 = require("../memory/lifecycle");
+const writerConflicts_1 = require("../memory/writerConflicts");
+const dailyNote_1 = require("../memory/dailyNote");
+const writer_1 = require("../memory/writer");
+const scope_1 = require("../mvp/scope");
+const secretGuard_1 = require("../extraction/secretGuard");
+const toolRefusal_1 = require("../toolRefusal");
+const evidenceCache_1 = require("../evidence/evidenceCache");
+const forgetImported_1 = require("../importing/forgetImported");
+const replacedJournal_1 = require("./replacedJournal");
+const orchestrator_1 = require("../retrieval/orchestrator");
+// ---------------------------------------------------------------------------
+// Memory map: a read model of everything one workspace holds, shaped for a
+// human to browse (the dashboard's graph + reader), plus reversible retirement.
+//
+// It is derived only from what the engine already stores — note files on disk,
+// the notes/facts/entities tables and write_events. Nothing is inferred by a
+// model: a link exists because a wikilink, a tag or a literal name mention says
+// so, and every link carries which of those it is.
+//
+// Units a person thinks of as "a memory":
+//   - note  : one Markdown file (imported notes, remember_note files, …);
+//   - entry : one entry of a daily log (Memory/**/Daily/YYYY-MM-DD.md), which is
+//             where the unstructured `remember` path appends. An entry is its
+//             timestamped line plus any continuation lines a multi-line
+//             statement wrote below it.
+// Lifecycle facts (the canonical ledger) are listed separately with their full
+// history. A fact is retired through the ledger (memory/lifecycle.ts, retireFact):
+// retire_memory and restore_memory take its id, `fact:` and its event id, and
+// hand it there.
+//
+// Retirement is a move, never a delete. Every retirement is journalled BEFORE
+// the move, so an interrupted one is either still in place (and the journal
+// record is void) or moved (and the record restores it):
+//   - a note file moves under `.trash/renor-retired/files/`;
+//   - an entry is cut out of its daily file by an atomic rewrite, under the
+//     same per-file lock every daily-file writer takes, and its exact bytes live
+//     in the journal.
+// `.trash/` is ignored by the indexer, so retired text leaves retrieval, and
+// restore puts the exact bytes back and re-indexes them.
+//
+// Why move bytes rather than mark them: retrieval does not only read the index —
+// the evidence pass hydrates whole note files from disk — so a "retired" line
+// left inside a daily log could still reach an agent's context. Moving it out of
+// the file is the only guarantee that holds for every reader.
+//
+// Identical entries in one daily log (the same statement saved twice) are one
+// memory: they share an id, and retiring it removes every copy.
+//
+// Confinement: ids address vault-relative Markdown paths only. No component may
+// be hidden ('.'-prefixed: .trash, .obsidian, the index), no component may be a
+// symlink, the real path must stay inside the vault's real path, and the fact
+// ledger is never addressable as a memory. Reads open with O_NOFOLLOW and check
+// the opened inode against the path. Threat model: the vault is written only by
+// this engine; these checks are defence in depth against a mis-provisioned vault
+// (a stray symlink), not a sandbox against a concurrent local attacker, who would
+// already own the files.
+// ---------------------------------------------------------------------------
+const LIFECYCLE_NOTE_PATH = '_mcp_';
+/** Frontmatter keys the indexer turns into note facts; they are note metadata, not knowledge. */
+const METADATA_PREDICATES = new Set(['owner', 'status', 'updated', 'tags']);
+/** The front-matter keys read_memory returns as `metadata` (MemoryDetail). Any other key is not copied. */
+const METADATA_KEYS = new Set(['title', 'status', 'owner', 'updated', 'tags']);
+exports.RETIRED_DIR = path_1.default.join('.trash', 'renor-retired');
+const RETIRED_FILES_DIR = path_1.default.join(exports.RETIRED_DIR, 'files');
+const RETIRED_INDEX = path_1.default.join(exports.RETIRED_DIR, 'retired.jsonl');
+const MAX_MEMORIES = 2000;
+/** Notes considered per map (newest first); bounds work before the memory cap applies. */
+const MAX_NOTES_SCANNED = 5000;
+/** Newest entries kept per daily log. */
+const MAX_ENTRIES_PER_DAY = 500;
+const MAX_THINGS = 2000;
+const MAX_FACTS = 5000;
+const MAX_LINKS = 20000;
+const MAX_EVENTS = 1000;
+const MAX_RETIRED_LISTED = 500;
+/**
+ * Items per list when a caller names no limit (memory_map's first call): small enough for one tool result on a large
+ * workspace, and the reply says how many more exist.
+ */
+exports.DEFAULT_MAP_LIMIT = 20;
+/** Bytes read per note for the map (excerpt + mention matching). */
+const MAP_READ_BYTES = 64 * 1024;
+/** Bytes read for one memory in full. */
+const READ_BYTES = 512 * 1024;
+/** A daily file larger than this is not rewritten (retire/restore refuse instead of truncating). */
+const MAX_REWRITE_BYTES = 8 * 1024 * 1024;
+const EXCERPT_CHARS = 280;
+const MAX_READ_CHARS = 40_000;
+const MIN_MENTION_CHARS = 3;
+// ------------------------------- paths --------------------------------------
+function toRel(memoryDir, stored) {
+    const root = path_1.default.resolve(memoryDir);
+    const resolved = path_1.default.resolve(root, stored);
+    const rel = path_1.default.relative(root, resolved);
+    if (!rel || rel === '..' || rel.startsWith('..' + path_1.default.sep) || path_1.default.isAbsolute(rel))
+        return null;
+    return rel.split(path_1.default.sep).join('/');
+}
+/**
+ * When a daily entry was saved, as retrieval dates it: the instant its header records, capped at its note's write time
+ * (createNoteTimeBound, the bound get_context and search_memory use), so a self-chosen file date cannot list an entry
+ * above what was written after it. Without a readable bound, the write time itself is the answer.
+ */
+function entryAt(bound, notePath, day, header, writtenAt) {
+    return bound(notePath, (0, dailyNote_1.entryInstant)(day, header)) ?? writtenAt;
+}
+function within(root, candidate) {
+    const rel = path_1.default.relative(root, candidate);
+    return rel !== '' && rel !== '..' && !rel.startsWith('..' + path_1.default.sep) && !path_1.default.isAbsolute(rel);
+}
+/** Lexical checks shared by every addressed path. */
+function lexicalRel(rel) {
+    if (typeof rel !== 'string' || rel.trim() === '' || path_1.default.isAbsolute(rel) || rel.includes('\0') || rel.includes('\\')) {
+        throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path must be a vault-relative path');
+    }
+    const parts = rel.split('/');
+    if (parts.some((p) => p === '..'))
+        throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path escapes the memory directory');
+    if (parts.some((p) => p === '' || p === '.'))
+        throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path must be a vault-relative path');
+    if (parts.some((p) => p.startsWith('.')))
+        throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path points into a hidden or system directory');
+    if (!rel.endsWith('.md'))
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'memory path must be a Markdown file');
+    return parts.join('/');
+}
+/**
+ * Resolve a vault-relative path and prove it is confined: every existing component below the vault
+ * root is a real directory (no symlink), the file itself is not a symlink, and the real path is
+ * inside the vault's real path. `mustExist: false` allows a missing file (restore) but still checks
+ * every directory that exists.
+ */
+async function resolveVaultFile(ctx, rel, mustExist) {
+    const clean = lexicalRel(rel);
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    const parts = clean.split('/');
+    let cursor = rootReal;
+    for (let i = 0; i < parts.length; i++) {
+        cursor = path_1.default.join(cursor, parts[i]);
+        let st;
+        try {
+            st = await promises_1.default.lstat(cursor);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                if (mustExist)
+                    throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found (it may have been retired)');
+                break; // nothing below exists; nothing below can be a symlink yet
+            }
+            throw err;
+        }
+        if (st.isSymbolicLink())
+            throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path goes through a symbolic link');
+        if (i < parts.length - 1 && !st.isDirectory())
+            throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found');
+        if (i === parts.length - 1 && !st.isFile())
+            throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path is not a file');
+    }
+    const real = path_1.default.join(rootReal, ...parts);
+    if (!within(rootReal, real))
+        throw (0, toolRefusal_1.refusal)('unsafe_path', 'memory path escapes the memory directory');
+    const file = { rel: clean, indexed: path_1.default.resolve(ctx.memoryDir, ...parts), real };
+    if (await isLedgerFile(ctx, file))
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'the fact ledger is not a memory; read facts through memory_map');
+    return file;
+}
+/**
+ * A file the owner left out of memory (.semanticignore, node_modules, ...) is not found by search, so it is not read or moved
+ * by its id either. Only read and retire ask: restore and reconcile must still reach a note that was retired before the
+ * owner added the rule.
+ */
+async function assertNotExcluded(ctx, file) {
+    if (await (0, walker_1.isIgnoredByVault)(ctx.memoryDir, file.rel))
+        throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found');
+}
+async function isLedgerFile(ctx, file) {
+    let ledger;
+    try {
+        ledger = (0, lifecycle_1.resolveLedgerPath)(ctx.memoryDir, ctx.ledgerRelPath);
+    }
+    catch {
+        return false;
+    }
+    if (path_1.default.resolve(ledger) === path_1.default.resolve(file.indexed))
+        return true;
+    try {
+        return (await promises_1.default.realpath(ledger)) === file.real;
+    }
+    catch {
+        return false;
+    }
+}
+function isLedgerIndexed(ctx, indexed) {
+    try {
+        return path_1.default.resolve(indexed) === (0, lifecycle_1.resolveLedgerPath)(ctx.memoryDir, ctx.ledgerRelPath);
+    }
+    catch {
+        return false;
+    }
+}
+function entryId(rel, raw) {
+    const digest = crypto_1.default.createHash('sha256').update(raw).digest('hex').slice(0, 16);
+    return `entry:${rel}#${digest}`;
+}
+/** A blank line is layout: spaces, tabs and carriage returns. Any other character on a line is the user's. */
+const BLANK_LINE_RE = /^[ \t\r]*$/;
+/**
+ * Split a daily file into entries: a timestamped line plus the continuation lines below it (a
+ * multi-line statement). Identical entries (same time, source and text) are one memory with every
+ * copy's line range, so an id never moves from one copy to another.
+ *
+ * `raw` is the entry as stored (it is the id, and the block retire and restore move); `text` is the
+ * statement as it was said: in an entry the writer marked, its escape on a continuation line is undone here
+ * (dailyNote.ts), and an entry without the mark reads back exactly as stored. A carriage return is content,
+ * not a line ending to drop.
+ */
+function parseEntries(rel, content) {
+    const lines = content.split('\n');
+    const starts = [];
+    // An entry starts at column 0. A look-alike behind a backslash (the writer's escape for the user's words)
+    // or behind an indent is a continuation.
+    lines.forEach((l, i) => {
+        if (dailyNote_1.ENTRY_LINE_RE.test(l))
+            starts.push(i);
+    });
+    const byRaw = new Map();
+    starts.forEach((start, k) => {
+        const end = k + 1 < starts.length ? starts[k + 1] : lines.length;
+        // Trailing blank lines are layout, not part of the entry.
+        let last = end;
+        while (last > start + 1 && BLANK_LINE_RE.test(lines[last - 1]))
+            last--;
+        const raw = lines.slice(start, last).join('\n');
+        const existing = byRaw.get(raw);
+        if (existing) {
+            existing.ranges.push([start, last]);
+            return;
+        }
+        const header = (0, dailyNote_1.parseEntryHeader)(lines[start]);
+        const rest = lines.slice(start + 1, last);
+        const continuation = (header.escaped ? rest.map(dailyNote_1.decodeEntryLine) : rest).join('\n');
+        byRaw.set(raw, {
+            ranges: [[start, last]], raw, time: header.time, ...(header.offset ? { offset: header.offset } : {}), source: header.source,
+            text: continuation ? `${header.text}\n${continuation}` : header.text,
+            id: entryId(rel, raw),
+        });
+    });
+    return { lines, blocks: [...byRaw.values()] };
+}
+/**
+ * The id the map gives an entry a writer has just appended (`entry`, as appendDailyEntry wrote it) to the daily log at
+ * vault-relative `rel`. The entry is read the way the map reads the file, so the two cannot differ: it runs to the next
+ * entry (the next append) less its trailing blank lines. Null when `rel` is no daily log or `entry` no entry.
+ */
+function appendedEntryId(rel, entry) {
+    if (!dailyNote_1.DAILY_FILE_RE.test(rel))
+        return null;
+    return parseEntries(rel, entry).blocks[0]?.id ?? null;
+}
+function withoutRanges(lines, ranges) {
+    const drop = new Set();
+    for (const [a, b] of ranges)
+        for (let i = a; i < b; i++)
+            drop.add(i);
+    return lines.filter((_, i) => !drop.has(i));
+}
+/** The entries just before and just after a block, which parseEntries returns in file order. */
+function entryNeighbours(blocks, block) {
+    const i = blocks.indexOf(block);
+    return {
+        ...(i > 0 ? { prevId: blocks[i - 1].id } : {}),
+        ...(i >= 0 && i + 1 < blocks.length ? { nextId: blocks[i + 1].id } : {}),
+    };
+}
+/**
+ * The line a restored entry goes back to, or null for the end of the file. It goes beside the neighbours it had when it
+ * was retired (the entry after it, else the one before it) while the log still agrees with time there: no entry in front
+ * of the place is later than it, and none at the place is earlier. Otherwise, before the first entry later than it.
+ */
+function restoreLine(blocks, record, time) {
+    const startOf = (b) => Math.min(...b.ranges.map(([a]) => a));
+    const endOf = (b) => Math.max(...b.ranges.map(([, b2]) => b2));
+    const next = blocks.find((b) => b.id === record.nextId);
+    const prev = blocks.find((b) => b.id === record.prevId);
+    const beside = next ? startOf(next) : prev ? endOf(prev) : null;
+    if (beside !== null) {
+        const before = blocks.filter((b) => startOf(b) < beside).pop();
+        const after = blocks.find((b) => startOf(b) >= beside);
+        if ((!before || before.time <= time) && (!after || after.time >= time))
+            return beside;
+    }
+    const later = blocks.find((b) => b.time > time);
+    return later ? startOf(later) : null;
+}
+function parseMemoryId(id) {
+    if (typeof id !== 'string')
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'memory id must be a string');
+    if (id.startsWith('note:'))
+        return { kind: 'note', rel: id.slice(5) };
+    if (id.startsWith('entry:')) {
+        const hashAt = id.lastIndexOf('#');
+        if (hashAt <= 6 || !/^[0-9a-f]{16}$/.test(id.slice(hashAt + 1)))
+            throw (0, toolRefusal_1.refusal)('invalid_argument', 'malformed entry id');
+        return { kind: 'entry', rel: id.slice(6, hashAt) };
+    }
+    throw (0, toolRefusal_1.refusal)('invalid_argument', 'unknown memory id kind');
+}
+// ------------------------------- helpers ------------------------------------
+function collapse(text, max) {
+    const t = text.replace(/\s+/g, ' ').trim();
+    return t.length <= max ? t : `${t.slice(0, max - 1)}…`;
+}
+function tagsOf(frontmatter) {
+    const raw = frontmatter.tags;
+    const list = Array.isArray(raw) ? raw.map(String) : typeof raw === 'string' ? raw.split(',') : [];
+    return [...new Set(list.map((t) => t.trim().replace(/^#/, '').toLowerCase()).filter(Boolean))];
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** Literal, case-insensitive, whole-word mention test. */
+function mentionMatcher(name) {
+    const n = name.trim();
+    if (n.length < MIN_MENTION_CHARS)
+        return null;
+    return new RegExp(`(^|[^\\p{L}\\p{N}_])${escapeRe(n)}($|[^\\p{L}\\p{N}_])`, 'iu');
+}
+exports.NOFOLLOW = promises_1.default.constants?.O_NOFOLLOW ?? 0;
+/** Open a confined file for reading: never through a final symlink, and only the inode at `real`. */
+async function openConfined(real) {
+    // O_NONBLOCK: opening a FIFO for reading waits for a writer; with it the open returns and the isFile check below refuses.
+    const handle = await promises_1.default.open(real, promises_1.default.constants.O_RDONLY | promises_1.default.constants.O_NONBLOCK | exports.NOFOLLOW);
+    try {
+        const [opened, there] = await Promise.all([handle.stat(), promises_1.default.lstat(real)]);
+        if (!opened.isFile() || opened.ino !== there.ino || opened.dev !== there.dev) {
+            throw new Error('memory path changed while it was being read');
+        }
+        return handle;
+    }
+    catch (err) {
+        await handle.close();
+        throw err;
+    }
+}
+async function readPrefix(real, bytes) {
+    let handle;
+    try {
+        handle = await openConfined(real);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const size = (await handle.stat()).size;
+        const buf = Buffer.alloc(Math.min(size, bytes));
+        const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+        return { text: buf.subarray(0, bytesRead).toString('utf8'), truncated: size > bytes };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Whole-file read for a rewrite; refuses rather than silently truncating. */
+async function readWhole(real) {
+    const handle = await openConfined(real);
+    try {
+        if ((await handle.stat()).size > MAX_REWRITE_BYTES) {
+            throw new Error('this daily log is too large to edit safely; nothing was changed');
+        }
+        return await handle.readFile('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * A note file read in full so the secret guard (RENOR_SECRET_GUARD) can screen it before it is moved. A file too
+ * large to hold is refused, as the guard does whenever it cannot check.
+ */
+async function readToScreen(real, action) {
+    const handle = await openConfined(real);
+    try {
+        if ((await handle.stat()).size > MAX_REWRITE_BYTES)
+            (0, secretGuard_1.refuseUnchecked)('memory', action);
+        return await handle.readFile('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Make sure a vault-relative directory exists as real directories all the way down (creating what
+ * is missing) and return its real path. Refuses a symlink at any level, so neither the journal nor
+ * a retired file can be written outside the vault through one.
+ */
+async function ensureRealDir(rootReal, relDir) {
+    let cursor = rootReal;
+    for (const part of relDir.split(/[\\/]/).filter((p) => p && p !== '.')) {
+        cursor = path_1.default.join(cursor, part);
+        try {
+            await promises_1.default.mkdir(cursor, { mode: 0o700 });
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+        const st = await promises_1.default.lstat(cursor);
+        if (st.isSymbolicLink() || !st.isDirectory())
+            throw new Error(`refusing to use ${relDir}: it is not a plain directory inside the vault`);
+    }
+    return cursor;
+}
+/** Replace a file's content atomically: a crash leaves either the old or the new bytes, never a mix. */
+async function atomicWrite(abs, content) {
+    const tmp = `${abs}.${process.pid}.${crypto_1.default.randomBytes(4).toString('hex')}.tmp`;
+    let mode;
+    try {
+        mode = (await promises_1.default.stat(abs)).mode & 0o777;
+    }
+    catch {
+        mode = undefined;
+    }
+    const handle = await promises_1.default.open(tmp, 'wx', mode ?? 0o600);
+    try {
+        await handle.writeFile(content, 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await promises_1.default.rename(tmp, abs);
+    }
+    catch (err) {
+        await promises_1.default.rm(tmp, { force: true });
+        throw err;
+    }
+}
+async function readJournal(ctx) {
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    let raw;
+    try {
+        // Confined like every other read: never through a symlinked .trash or journal.
+        for (const dir of [path_1.default.join(rootReal, '.trash'), path_1.default.join(rootReal, exports.RETIRED_DIR)]) {
+            const st = await promises_1.default.lstat(dir);
+            if (st.isSymbolicLink() || !st.isDirectory())
+                throw new Error('the retired-memory journal is not inside the vault');
+        }
+        const handle = await openConfined(path_1.default.join(rootReal, RETIRED_INDEX));
+        try {
+            raw = await handle.readFile('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // A torn final line (crash mid-append) is skipped, never fatal.
+        }
+    }
+    return out;
+}
+/** Retirements still in effect (the latest record per retirement wins; a restore or a void ends it). */
+function activeRetired(records) {
+    const latest = new Map();
+    for (const r of records)
+        if (typeof r.rid === 'string')
+            latest.set(r.rid, r);
+    return [...latest.values()].filter((r) => !r.restoredAt && !r.voided && !r.purgedAt);
+}
+async function appendJournal(ctx, record) {
+    const dir = await ensureRealDir(await promises_1.default.realpath(ctx.memoryDir), exports.RETIRED_DIR);
+    const file = path_1.default.join(dir, path_1.default.basename(RETIRED_INDEX));
+    // O_NONBLOCK: a FIFO planted under the journal's name is an error here, never a wait.
+    const handle = await promises_1.default.open(file, promises_1.default.constants.O_RDWR | promises_1.default.constants.O_APPEND | promises_1.default.constants.O_CREAT | promises_1.default.constants.O_NONBLOCK | exports.NOFOLLOW, 0o600);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.nlink !== 1)
+            throw new Error(`refusing to write ${JSON.stringify(RETIRED_INDEX)}: it is not a regular file with a single name`);
+        // A crash can leave a torn last line; start on a fresh line so this record is never glued to it.
+        const size = stat.size;
+        let prefix = '';
+        if (size > 0) {
+            const last = Buffer.alloc(1);
+            await handle.read(last, 0, 1, size - 1);
+            if (last[0] !== 0x0a)
+                prefix = '\n';
+        }
+        await handle.appendFile(prefix + JSON.stringify(record) + '\n', 'utf8');
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Retire/restore events carry the memory id and its title as JSON in `summary`. */
+function recordEvent(db, rel, action, id, title) {
+    db.prepare('INSERT INTO write_events (note_path, action, summary, created_at) VALUES (?, ?, ?, ?)')
+        .run(rel, action, JSON.stringify({ id, title }), new Date().toISOString());
+}
+function parseEventRef(summary) {
+    try {
+        const v = JSON.parse(summary ?? '');
+        return { id: typeof v.id === 'string' ? v.id : null, title: typeof v.title === 'string' ? v.title : null };
+    }
+    catch {
+        return { id: null, title: summary };
+    }
+}
+async function exists(abs) {
+    try {
+        await promises_1.default.lstat(abs);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a daily log is too large to be read whole, so a read of it would be cut and the map marked truncated. A note
+ * a lookup does not read is still counted by this, through the same confinement a read applies.
+ */
+async function readsWhole(ctx, stored) {
+    // Most daily logs are far below the size, so the confinement check runs only for the few that could be cut.
+    try {
+        if ((0, fs_1.statSync)(path_1.default.resolve(ctx.memoryDir, stored)).size <= MAX_REWRITE_BYTES)
+            return false;
+    }
+    catch {
+        return false;
+    }
+    try {
+        const file = await resolveVaultFile(ctx, stored, true);
+        return (await promises_1.default.stat(file.real)).size > MAX_REWRITE_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Whether a note's file has changed since it was indexed: its text may then hold words the index does not. A synchronous
+ * stat: one per note, and a queued async call per note cost about 2 s on a loaded host where the stats themselves take 50 ms.
+ */
+function changedSinceIndexed(memoryDir, n) {
+    try {
+        return (0, fs_1.statSync)(path_1.default.resolve(memoryDir, n.path)).mtime.toISOString() !== n.modified_at;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * The notes with a chunk the predicate accepts, read from the index's chunk text. A note's chunks are its body cut at line
+ * breaks (a word never spans one), so a word the note's body holds is in one chunk, at the same place in its line. It
+ * can therefore only be a candidate here, never a verdict: keep still decides on the file's own text.
+ */
+function notesWithIndexedText(db, hasWord) {
+    const out = new Set();
+    const rows = db.prepare('SELECT note_path, text FROM chunks').iterate();
+    for (const row of rows) {
+        if (!out.has(row.note_path) && hasWord(row.text))
+            out.add(row.note_path);
+    }
+    return out;
+}
+/**
+ * The daily logs that hold a retired entry. Their entries are read whole, because a retirement counts only once its entry
+ * is gone from its log.
+ */
+async function retiredEntryFiles(ctx) {
+    return new Set(activeRetired(await readJournal(ctx)).filter((r) => r.kind === 'entry').map((r) => r.path));
+}
+/**
+ * Every memory a person can open, newest first: each note file and each entry of a daily log. With `keep`, only the
+ * memories it keeps are collected, the cap counts those alone, and a daily log's every entry is considered rather than
+ * its newest ones, so a lookup reaches any memory the scan reads.
+ */
+async function collectMemories(ctx, keep, mayMatch) {
+    const { db, memoryDir } = ctx;
+    const notes = db.prepare(`SELECT path, title, modified_at, frontmatter_json FROM notes ORDER BY modified_at DESC LIMIT ?`).all(MAX_NOTES_SCANNED + 1);
+    const memories = [];
+    const text = new Map();
+    const wikilinks = new Map();
+    const seen = new Set();
+    const bound = (0, orchestrator_1.createNoteTimeBound)(db);
+    let truncated = notes.length > MAX_NOTES_SCANNED;
+    const add = (memory, said) => {
+        seen.add(memory.id);
+        if (keep && !keep(memory, said))
+            return false;
+        memories.push(memory);
+        text.set(memory.id, said);
+        return true;
+    };
+    for (const n of notes.slice(0, MAX_NOTES_SCANNED)) {
+        if (memories.length >= MAX_MEMORIES) {
+            truncated = true;
+            break;
+        }
+        if (n.path === LIFECYCLE_NOTE_PATH || isLedgerIndexed(ctx, n.path))
+            continue;
+        const stored = toRel(memoryDir, n.path);
+        if (!stored)
+            continue;
+        // A note that cannot match is not read at all: keep would refuse every memory in it.
+        if (mayMatch && !(await mayMatch(n))) {
+            if (dailyNote_1.DAILY_FILE_RE.test(stored) && (await readsWhole(ctx, stored)))
+                truncated = true;
+            continue;
+        }
+        // The same confinement as read/retire: a note reached through a symlink, a hidden directory or
+        // an alias of the ledger is not listed.
+        let file;
+        try {
+            file = await resolveVaultFile(ctx, stored, true);
+        }
+        catch {
+            continue;
+        }
+        const rel = file.rel;
+        const daily = dailyNote_1.DAILY_FILE_RE.exec(rel);
+        const read = await readPrefix(file.real, daily ? MAX_REWRITE_BYTES : MAP_READ_BYTES);
+        if (read === null)
+            continue; // indexed but gone from disk: not a memory a person can open
+        let fm = {};
+        try {
+            fm = JSON.parse(n.frontmatter_json);
+        }
+        catch { /* keep {} */ }
+        if (daily) {
+            const { blocks } = parseEntries(rel, read.text);
+            const dated = blocks.map((b) => ({ b, at: entryAt(bound, n.path, daily[2], b, n.modified_at) }));
+            const newest = keep ? dated : [...dated].sort((x, y) => y.at.localeCompare(x.at)).slice(0, MAX_ENTRIES_PER_DAY);
+            if (newest.length < blocks.length)
+                truncated = true;
+            for (const { b, at } of newest) {
+                add({
+                    id: b.id, kind: 'entry', path: rel,
+                    title: collapse(b.text, 90),
+                    at,
+                    source: b.source || null,
+                    tags: [], status: null,
+                    excerpt: collapse(b.text, EXCERPT_CHARS),
+                }, b.text);
+            }
+            if (read.truncated)
+                truncated = true;
+            continue;
+        }
+        const parsed = (0, parser_1.parseNote)(n.path, read.text);
+        const id = `note:${rel}`;
+        const kept = add({
+            id, kind: 'note', path: rel,
+            title: n.title,
+            at: n.modified_at,
+            source: typeof fm.source === 'string' ? fm.source : null,
+            tags: tagsOf(fm),
+            status: typeof fm.status === 'string' ? fm.status : null,
+            excerpt: collapse(parsed.body.replace(/^#\s+.*$/m, ''), EXCERPT_CHARS),
+        }, `${n.title}\n${parsed.body}`);
+        if (kept)
+            wikilinks.set(id, parsed.wikilinks);
+    }
+    memories.sort((a, b) => b.at.localeCompare(a.at));
+    return { memories, truncated, text, wikilinks, seen };
+}
+/**
+ * Retirements that completed, newest first (a note's file is in the retired area; an entry is no longer among `live`).
+ * An interrupted one is still a live memory and is not listed twice.
+ */
+async function completedRetirements(ctx, live) {
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    const out = [];
+    for (const r of activeRetired(await readJournal(ctx)).reverse()) {
+        const completed = r.kind === 'entry'
+            ? !live.has(r.id)
+            : Boolean(r.storedAt) && (await exists(path_1.default.join(rootReal, ...r.storedAt.split('/'))));
+        if (!completed)
+            continue;
+        const day = dailyNote_1.DAILY_FILE_RE.exec(r.path)?.[2];
+        const header = r.block ? (0, dailyNote_1.parseEntryHeader)(r.block.split('\n')[0]) : null;
+        out.push({
+            memory: {
+                id: r.rid, memoryId: r.id, kind: r.kind, path: r.path, title: r.title, retiredAt: r.retiredAt,
+                // A retired entry's file is gone, so no note row bounds it; it was saved before it was retired, so that time caps it.
+                ...(r.kind === 'entry' && day && header ? { savedAt: (0, orchestrator_1.clampSessionDate)((0, dailyNote_1.entryInstant)(day, header), r.retiredAt) ?? r.retiredAt } : {}),
+            },
+            text: r.block ?? '',
+            ...(r.kind === 'note' && r.storedAt ? { storedAt: r.storedAt } : {}),
+        });
+    }
+    const facts = (0, lifecycle_1.listRetiredFacts)(ctx.db).map((f) => ({
+        memory: { id: f.id, memoryId: f.id, kind: 'fact', path: ctx.ledgerRelPath, title: f.title, retiredAt: f.retiredAt },
+        text: f.title,
+        scope: f.scope,
+    }));
+    // Both lists are newest first; the sort is stable.
+    return [...out, ...facts].sort((a, b) => b.memory.retiredAt.localeCompare(a.memory.retiredAt));
+}
+/**
+ * The body of a retired note's stored copy, for a lookup to match. Only a copy inside the retired area, reached through
+ * real directories, is read (the checks restore makes before it moves the copy back), and as much of it as the map
+ * reads of a live note.
+ */
+async function retiredNoteBody(rootReal, storedAt) {
+    const stored = path_1.default.join(rootReal, ...storedAt.split('/'));
+    if (!within(path_1.default.join(rootReal, RETIRED_FILES_DIR), stored))
+        return '';
+    try {
+        if ((await promises_1.default.realpath(path_1.default.dirname(stored))) !== path_1.default.dirname(stored))
+            return '';
+    }
+    catch {
+        return '';
+    }
+    const read = await readPrefix(stored, MAP_READ_BYTES);
+    return read === null ? '' : (0, parser_1.parseNote)(stored, read.text).body;
+}
+async function buildMemoryMap(ctx, options = {}) {
+    const { db } = ctx;
+    const cap = options.limit ?? exports.DEFAULT_MAP_LIMIT;
+    const collected = await collectMemories(ctx);
+    const memories = collected.memories;
+    const mentionText = collected.text;
+    const wikilinksOf = collected.wikilinks;
+    const shown = memories.slice(0, cap);
+    const truncatedMemories = collected.truncated || memories.length > cap;
+    // Wikilink targets: an exact vault path wins; a bare name or title links only when unambiguous across the whole vault.
+    const byPath = new Map();
+    const byName = new Map();
+    for (const m of memories) {
+        if (m.kind !== 'note')
+            continue;
+        byPath.set(m.path.replace(/\.md$/i, '').toLowerCase(), m.id);
+        for (const key of new Set([path_1.default.posix.basename(m.path, '.md').toLowerCase(), m.title.toLowerCase()])) {
+            byName.set(key, [...(byName.get(key) ?? []), m.id]);
+        }
+    }
+    const resolveWikilink = (target) => {
+        const t = target.trim().replace(/\.md$/i, '').toLowerCase();
+        if (byPath.has(t))
+            return byPath.get(t);
+        if (t.includes('/'))
+            return null; // a path that names no note is not guessed from its basename
+        const candidates = byName.get(t) ?? [];
+        return candidates.length === 1 ? candidates[0] : null;
+    };
+    // Things: the subjects of lifecycle (ledger) facts, by their newest fact in the same order the facts list uses. So the
+    // newest `limit` facts always name things the reply lists: a thing with a newer fact ranks above it.
+    const thingRows = db.prepare(`SELECT e.id, e.canonical_name AS name,
+            SUM(CASE WHEN f.valid_to IS NULL THEN 1 ELSE 0 END) AS current,
+            (SELECT g.valid_from FROM facts g WHERE g.subject_entity_id = e.id AND g.source_path = ?
+              ORDER BY g.valid_from DESC, g.id DESC LIMIT 1) AS newest_from,
+            (SELECT g.id FROM facts g WHERE g.subject_entity_id = e.id AND g.source_path = ?
+              ORDER BY g.valid_from DESC, g.id DESC LIMIT 1) AS newest_id
+       FROM entities e JOIN facts f ON f.subject_entity_id = e.id AND f.source_path = ?
+      WHERE e.source_note = ?
+      GROUP BY e.id ORDER BY newest_from DESC, newest_id DESC, e.canonical_name LIMIT ?`).all(LIFECYCLE_NOTE_PATH, LIFECYCLE_NOTE_PATH, LIFECYCLE_NOTE_PATH, LIFECYCLE_NOTE_PATH, MAX_THINGS + 1);
+    const truncatedThings = thingRows.length > MAX_THINGS;
+    const allThings = thingRows.slice(0, MAX_THINGS).map((t) => ({ id: `thing:${t.id}`, name: t.name, currentFacts: t.current }));
+    const things = allThings.slice(0, cap);
+    // Facts: every lifecycle fact of a ledger thing, newest first. Not cut to the listed things: each fact names its subject.
+    const factRows = db.prepare(`SELECT f.id, f.subject_entity_id AS sid, e.canonical_name AS subject, f.predicate, f.object_text AS object,
+            f.valid_from, f.valid_to, f.scope, f.event_id
+       FROM facts f JOIN entities e ON e.id = f.subject_entity_id
+      WHERE f.source_path = ? AND e.source_note = ?
+      ORDER BY f.valid_from DESC, f.id DESC LIMIT ?`).all(LIFECYCLE_NOTE_PATH, LIFECYCLE_NOTE_PATH, MAX_FACTS + 1);
+    const allFacts = factRows.slice(0, MAX_FACTS).map((f) => ({
+        id: f.id, thingId: `thing:${f.sid}`, subject: f.subject, predicate: f.predicate,
+        object: f.object ?? '', validFrom: f.valid_from, validTo: f.valid_to, scope: f.scope, eventId: f.event_id,
+    }));
+    // A fact's object is shown as an excerpt (the link search below reads the whole object): a map is for browsing, and
+    // get_context returns the fact in full. A current fact that replaced another writer's value carries its conflict line.
+    const disputes = (0, writerConflicts_1.writerConflictLines)(db, allFacts.slice(0, cap).map((f) => (f.validTo === null ? f.eventId : null)));
+    const facts = allFacts.slice(0, cap).map((f) => {
+        const line = f.validTo === null && f.eventId !== null ? disputes.get(f.eventId) : undefined;
+        return { ...f, object: collapse(f.object, EXCERPT_CHARS), ...(line === undefined ? {} : { writerConflict: line }) };
+    });
+    const truncatedFacts = factRows.length > MAX_FACTS || allFacts.length > cap;
+    // Links over the whole map, then only those between what the reply lists (no link points at a missing node). Each kind
+    // has its own bucket and its own build cap, so a vault with many tags cannot starve the mention and fact links; the
+    // total counts every link the map holds, so `truncated` says more exist even when the listed nodes have few.
+    // `seq` is the order the links were found in: the reply lists the links it keeps in that order.
+    const linksByKind = { tag: [], wikilink: [], mention: [], fact: [] };
+    let linkSeq = 0;
+    let truncatedLinks = false;
+    const push = (l) => {
+        const bucket = linksByKind[l.kind];
+        if (bucket.length >= MAX_LINKS) {
+            truncatedLinks = true;
+            return false;
+        }
+        bucket.push({ seq: linkSeq++, link: l });
+        return true;
+    };
+    const topicCount = new Map();
+    for (const m of shown) {
+        for (const t of m.tags)
+            topicCount.set(t, (topicCount.get(t) ?? 0) + 1);
+    }
+    for (const m of memories) {
+        for (const t of m.tags)
+            push({ source: m.id, target: `topic:${t}`, kind: 'tag' });
+        for (const w of wikilinksOf.get(m.id) ?? []) {
+            const target = resolveWikilink(w);
+            if (target && target !== m.id)
+                push({ source: m.id, target, kind: 'wikilink' });
+        }
+    }
+    const matchers = allThings
+        .map((t) => ({
+        id: t.id, re: mentionMatcher(t.name),
+        // For ASCII names, absence of the folded literal proves absence of a /iu match.
+        // Non-ASCII names still use the regex alone (Unicode folding is not lowercasing).
+        literal: /^[\x00-\x7f]+$/.test(t.name.trim()) ? t.name.trim().toLowerCase() : null,
+    }))
+        .filter((t) => t.re !== null);
+    const hasLiteral = matchers.some((t) => t.literal !== null);
+    // Long s and Kelvin sign are the only non-ASCII letters /iu folds to ASCII. Lowercasing
+    // handles Kelvin; long s needs an explicit fold. The regex still decides boundaries.
+    const fold = (text) => hasLiteral ? text.toLowerCase().replace(/\u017f/g, 's') : '';
+    outer: for (const m of memories) {
+        const text = mentionText.get(m.id) ?? '';
+        const folded = fold(text);
+        for (const t of matchers) {
+            if (t.literal !== null && !folded.includes(t.literal))
+                continue;
+            if (t.re.test(text) && !push({ source: m.id, target: t.id, kind: 'mention' }))
+                break outer;
+        }
+    }
+    const seenFactLink = new Set();
+    outerFacts: for (const f of allFacts) {
+        if (f.validTo !== null)
+            continue;
+        const folded = fold(f.object);
+        for (const t of matchers) {
+            if (t.id === f.thingId || (t.literal !== null && !folded.includes(t.literal)) || !t.re.test(f.object))
+                continue;
+            const key = `${f.thingId}|${t.id}|${f.predicate}`;
+            if (seenFactLink.has(key))
+                continue;
+            seenFactLink.add(key);
+            if (!push({ source: f.thingId, target: t.id, kind: 'fact', label: f.predicate }))
+                break outerFacts;
+        }
+    }
+    const topics = [...topicCount.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([name, count]) => ({ id: `topic:${name}`, name, memories: count }));
+    // Events: what the engine itself recorded, newest first. The save of a fact that is retired now is left out, as the
+    // fact is: its summary names the value, at the fact's own time.
+    const eventRows = db.prepare(`SELECT note_path, action, summary, created_at, author FROM write_events w
+      WHERE NOT (w.note_path = '_memory_ledger_' AND w.action IN ('store', 'supersede') AND EXISTS (
+        SELECT 1 FROM retired_facts r WHERE r.valid_from = w.created_at AND instr(w.summary, ' ' || r.predicate || ' → ' || r.object_text) > 0))
+      ORDER BY created_at DESC, id DESC LIMIT ?`).all(MAX_EVENTS + 1);
+    const allEvents = eventRows.slice(0, MAX_EVENTS).map((e) => {
+        if (e.action === 'retire' || e.action === 'restore') {
+            const ref = parseEventRef(e.summary);
+            return { at: e.created_at, action: e.action, memoryId: ref.id, summary: ref.title, ...(e.author ? { source: e.author } : {}) };
+        }
+        return { at: e.created_at, action: e.action, memoryId: null, summary: e.summary, ...(e.author ? { source: e.author } : {}) };
+    });
+    const events = allEvents.slice(0, cap).map((e) => ({ ...e, summary: e.summary === null ? null : collapse(e.summary, EXCERPT_CHARS) }));
+    // Retired: only retirements that completed, newest first.
+    const retiredAll = (await completedRetirements(ctx, collected.seen)).map((r) => r.memory);
+    const retired = retiredAll.slice(0, Math.min(MAX_RETIRED_LISTED, cap));
+    // A link joins two nodes the reply lists: a memory or a topic of a listed memory, or a listed thing.
+    const listed = new Set([...shown.map((m) => m.id), ...things.map((t) => t.id), ...topics.map((t) => t.id)]);
+    // The reply's links are shared out across the kinds, one each in turn, so every kind that exists keeps its share of
+    // `limit` (a kind with fewer links gives its turns to the others). The reply never holds more than `limit` links.
+    const kindOrder = ['tag', 'wikilink', 'mention', 'fact'];
+    const shownByKind = kindOrder.map((k) => linksByKind[k].filter(({ link: l }) => listed.has(l.source) && listed.has(l.target)));
+    const kept = [];
+    for (let turn = 0; kept.length < cap; turn++) {
+        const picks = shownByKind.flatMap((bucket) => (turn < bucket.length ? [bucket[turn]] : []));
+        if (picks.length === 0)
+            break;
+        kept.push(...picks.slice(0, cap - kept.length));
+    }
+    const links = kept.sort((a, b) => a.seq - b.seq).map((k) => k.link);
+    const totalLinks = kindOrder.reduce((sum, k) => sum + linksByKind[k].length, 0);
+    return {
+        ok: true,
+        generatedAt: new Date().toISOString(),
+        limit: cap,
+        memories: shown,
+        things,
+        topics,
+        facts,
+        links,
+        events,
+        retired,
+        total: {
+            memories: memories.length,
+            things: allThings.length,
+            facts: allFacts.length,
+            links: totalLinks,
+            events: allEvents.length,
+            retired: retiredAll.length,
+        },
+        truncated: {
+            memories: truncatedMemories,
+            things: truncatedThings || allThings.length > cap,
+            facts: truncatedFacts,
+            links: truncatedLinks || totalLinks > links.length,
+            events: eventRows.length > MAX_EVENTS || allEvents.length > cap,
+            retired: retiredAll.length > retired.length,
+        },
+    };
+}
+/**
+ * The memories a few words find, so one can be read, retired or restored without loading the whole map: every memory
+ * whose path, title or text has a word starting with one of `terms` (lowercase words, as `atoms` gives them), and every
+ * retired memory whose path, title or stored text has one (an entry's text from the journal, a note's from its copy in
+ * the retired area). A term matches at the start of a word, so "rent" finds
+ * "rented" but not "current". A term counts for more the fewer memories have it, so the memory that has the rare word
+ * of "the note about my landlord" comes before the many that only say "note"; equal ones stay newest first. At most
+ * `limit` of each. With `scope`, only the memories in that scope (by path, the rule every note read follows) are looked
+ * at, before the cap: the lookup used to look everywhere, and finding one memory to forget cost a lookup of the whole
+ * workspace (live dogfood, 2026-10-03, D12).
+ */
+async function findMemories(ctx, args) {
+    const inScope = (rel) => args.scope === undefined || (0, scope_1.notePathMatchesScope)(rel, args.scope);
+    const patterns = [...new Set(args.terms)].map((t) => new RegExp(`(?<![\\p{L}\\p{N}\\p{M}])${escapeRe(t)}`, 'u'));
+    const termsIn = (...parts) => {
+        const text = parts.join('\n').toLowerCase();
+        return patterns.flatMap((re, i) => (re.test(text) ? [i] : []));
+    };
+    /** Each found item first by the summed rarity of the terms it has; the sort is stable, so the given order breaks ties. */
+    const best = (found) => {
+        const holders = patterns.map((_, i) => found.filter((f) => f.terms.includes(i)).length);
+        const weight = (terms) => terms.reduce((sum, i) => sum + 1 / holders[i], 0);
+        return found.map((f) => ({ item: f.item, w: weight(f.terms) })).sort((a, b) => b.w - a.w).map((f) => f.item);
+    };
+    const matched = new Map();
+    // Only the notes that can hold one of the words are read: the index names them, and a note whose file changed since
+    // it was indexed is read anyway. A retired entry's daily log is always read, as its liveness is decided by reading it.
+    const retiredDays = await retiredEntryFiles(ctx);
+    const indexed = notesWithIndexedText(ctx.db, (text) => termsIn(text).length > 0);
+    const collected = await collectMemories(ctx, (m, text) => {
+        if (!inScope(m.path))
+            return false;
+        const terms = termsIn(m.path, m.title, text);
+        if (terms.length > 0)
+            matched.set(m.id, terms);
+        return terms.length > 0;
+    }, async (n) => {
+        // The index keeps each note under its absolute path; the journal and the scope use the vault-relative one.
+        const rel = toRel(ctx.memoryDir, n.path) ?? '';
+        if (retiredDays.has(rel))
+            return true;
+        if (!inScope(rel))
+            return false;
+        return termsIn(rel, n.title).length > 0 || indexed.has(n.path) || changedSinceIndexed(ctx.memoryDir, n);
+    });
+    const memories = best(collected.memories.map((m) => ({ item: m, terms: matched.get(m.id) })));
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    const foundRetired = [];
+    for (const r of await completedRetirements(ctx, collected.seen)) {
+        if (r.scope !== undefined ? args.scope !== undefined && !(0, scope_1.savedScopeMatches)(r.scope, args.scope) : !inScope(r.memory.path))
+            continue;
+        const terms = termsIn(r.memory.path, r.memory.title, r.storedAt ? await retiredNoteBody(rootReal, r.storedAt) : r.text);
+        if (terms.length > 0)
+            foundRetired.push({ item: r.memory, terms });
+    }
+    const retired = best(foundRetired);
+    return {
+        ok: true,
+        generatedAt: new Date().toISOString(),
+        query: args.query,
+        ...(args.scope === undefined ? {} : { scope: args.scope }),
+        memories: memories.slice(0, args.limit),
+        retired: retired.slice(0, args.limit),
+        truncated: { memories: collected.truncated || memories.length > args.limit, retired: retired.length > args.limit },
+    };
+}
+async function readMemory(ctx, id) {
+    const ref = parseMemoryId(id);
+    const file = await resolveVaultFile(ctx, ref.rel, true);
+    await assertNotExcluded(ctx, file);
+    if (ref.kind === 'entry') {
+        const daily = dailyNote_1.DAILY_FILE_RE.exec(file.rel);
+        if (!daily)
+            throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found');
+        const block = parseEntries(file.rel, await readWhole(file.real)).blocks.find((b) => b.id === id);
+        if (!block)
+            throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found (it may have been retired)');
+        // The same bound the list shows the entry with: its note's indexed write time (main's createNoteTimeBound).
+        const written = ctx.db.prepare('SELECT modified_at FROM notes WHERE path = ?').get(file.indexed)?.modified_at
+            ?? (await promises_1.default.stat(file.real)).mtime.toISOString();
+        const dated = (0, orchestrator_1.createNoteTimeBound)(ctx.db)(file.indexed, (0, dailyNote_1.entryInstant)(daily[2], block));
+        return {
+            ok: true,
+            memory: {
+                id, kind: 'entry', path: file.rel, title: collapse(block.text, 90), at: dated ?? written,
+                ...(dated ? { session_date: dated } : {}),
+                source: block.source || null, tags: [], status: null, excerpt: collapse(block.text, EXCERPT_CHARS),
+            },
+            text: block.text.slice(0, MAX_READ_CHARS),
+            textTruncated: block.text.length > MAX_READ_CHARS,
+            metadata: {},
+            facts: [],
+        };
+    }
+    const read = await readPrefix(file.real, READ_BYTES);
+    if (read === null)
+        throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found (it may have been retired)');
+    const parsed = (0, parser_1.parseNote)(file.indexed, read.text);
+    const row = ctx.db.prepare('SELECT title, modified_at, frontmatter_json FROM notes WHERE path = ?').get(file.indexed);
+    const dated = row ? (0, orchestrator_1.resolveSessionDate)(row.frontmatter_json, row.modified_at) : undefined;
+    // Only the documented keys are copied. A front-matter key the type does not name stays in the note and the export.
+    const metadata = {};
+    for (const [k, v] of Object.entries(parsed.frontmatter)) {
+        if (!METADATA_KEYS.has(k) || v === null || v === undefined)
+            continue;
+        metadata[k] = Array.isArray(v) ? v.map(String).join(', ') : v instanceof Date ? v.toISOString().slice(0, 10) : String(v);
+    }
+    const factRows = ctx.db.prepare(`SELECT predicate, object_text AS object, valid_from, valid_to FROM facts WHERE source_path = ? ORDER BY id`).all(file.indexed);
+    const body = parsed.body;
+    return {
+        ok: true,
+        memory: {
+            id, kind: 'note', path: file.rel, title: row?.title ?? parsed.title, at: row?.modified_at ?? new Date(0).toISOString(),
+            ...(dated ? { session_date: dated } : {}),
+            source: typeof parsed.frontmatter.source === 'string' ? parsed.frontmatter.source : null,
+            tags: tagsOf(parsed.frontmatter),
+            status: typeof parsed.frontmatter.status === 'string' ? parsed.frontmatter.status : null,
+            excerpt: collapse(body, EXCERPT_CHARS),
+        },
+        text: body.slice(0, MAX_READ_CHARS),
+        textTruncated: body.length > MAX_READ_CHARS || read.truncated,
+        metadata,
+        facts: factRows
+            .filter((f) => !METADATA_PREDICATES.has(f.predicate))
+            .map((f) => ({ predicate: f.predicate, object: f.object ?? '', validFrom: f.valid_from, validTo: f.valid_to })),
+    };
+}
+// ------------------------------- retire / restore ---------------------------
+let chain = Promise.resolve();
+function serialize(fn) {
+    const result = chain.then(fn, fn);
+    chain = result.then(() => undefined, () => undefined);
+    return result;
+}
+/** Remove a note's derived rows (chunks, FTS, entities, structured rows cascade) and its vectors. */
+function dropNoteFromIndex(ctx, indexed) {
+    const chunkIds = ctx.db.prepare('SELECT id FROM chunks WHERE note_path = ?').all(indexed).map((r) => r.id);
+    ctx.db.transaction(() => {
+        ctx.db.prepare('DELETE FROM facts WHERE source_path = ?').run(indexed);
+        ctx.db.prepare('DELETE FROM relations WHERE source_note = ?').run(indexed);
+        ctx.db.prepare('DELETE FROM notes WHERE path = ?').run(indexed);
+    })();
+    for (const id of chunkIds)
+        ctx.indexOptions.vectorIndex?.delete(id);
+}
+/**
+ * Settle retirements and restores an earlier crash interrupted, so the journal, the files and the
+ * index agree again:
+ *  - note, file never moved (no stored copy, original present): void the record and re-index the
+ *    note (its index rows may already have been dropped);
+ *  - note, moved but index rows survived: drop them;
+ *  - note, restored on disk but the journal not yet told (original present, stored copy gone):
+ *    covered by the first case;
+ *  - entry still in its file: void the record (the retirement never happened, or it was restored);
+ *  - entry gone from its file: re-index the file, so a crash between the rewrite and the index
+ *    update never leaves retired text searchable.
+ */
+async function reconcile(ctx) {
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    const journal = await readJournal(ctx);
+    await removePurgedCopies(rootReal, journal);
+    for (const r of activeRetired(journal)) {
+        let file;
+        try {
+            file = await resolveVaultFile(ctx, r.path, false);
+        }
+        catch {
+            continue; // a record that no longer resolves safely is left alone, never acted on
+        }
+        if (r.kind === 'note') {
+            const stored = r.storedAt ? path_1.default.join(rootReal, ...r.storedAt.split('/')) : null;
+            const storedThere = stored ? await exists(stored) : false;
+            const originalThere = await exists(file.real);
+            if (!storedThere && originalThere) {
+                // Index first: if it fails, the record stays open and the next attempt repairs it again.
+                await (0, pipeline_1.indexFile)(ctx.db, file.indexed, ctx.indexOptions);
+                await appendJournal(ctx, voidRecord(r));
+            }
+            else if (storedThere && !originalThere) {
+                if (ctx.db.prepare('SELECT 1 FROM notes WHERE path = ?').get(file.indexed))
+                    dropNoteFromIndex(ctx, file.indexed);
+            }
+            continue;
+        }
+        if (!(await exists(file.real)))
+            continue;
+        const present = await (0, writer_1.withDailyFileLock)(file.indexed, async () => parseEntries(file.rel, await readWhole(file.real)).blocks.some((b) => b.id === r.id));
+        await (0, pipeline_1.indexFile)(ctx.db, file.indexed, ctx.indexOptions);
+        if (present)
+            await appendJournal(ctx, voidRecord(r));
+    }
+}
+/**
+ * The record that ends an interrupted retirement. It is never read for its text, so while the secret guard is on
+ * it does not carry a second copy of the block, which may be what the guard would have refused to retire.
+ */
+function voidRecord(r) {
+    const voided = { ...r, voided: true };
+    if ((0, secretGuard_1.secretGuardEnabled)())
+        delete voided.block;
+    return voided;
+}
+function newRid() {
+    return `retired:${crypto_1.default.randomBytes(8).toString('hex')}`;
+}
+function retireMemory(ctx, id, expectedHash) {
+    if ((0, lifecycle_1.factEventId)(id) !== null)
+        return (0, lifecycle_1.retireFact)(ctx.db, ctx.memoryDir, ctx.ledgerRelPath, id, ctx.source);
+    return serialize(async () => {
+        await reconcile(ctx);
+        const ref = parseMemoryId(id);
+        const file = await resolveVaultFile(ctx, ref.rel, true);
+        await assertNotExcluded(ctx, file);
+        const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+        const at = new Date().toISOString();
+        const rid = newRid();
+        if (ref.kind === 'entry') {
+            if (!dailyNote_1.DAILY_FILE_RE.test(file.rel))
+                throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found');
+            const { title, emptied } = await (0, writer_1.withDailyFileLock)(file.indexed, async () => {
+                const { lines, blocks } = parseEntries(file.rel, await readWhole(file.real));
+                const block = blocks.find((b) => b.id === id);
+                if (!block)
+                    throw (0, toolRefusal_1.refusal)('memory_not_found', 'memory not found (it may already be retired)');
+                const entryTitle = collapse(block.text, 90);
+                // RENOR_SECRET_GUARD (default ON): retiring copies the block into the journal, so a block the scanner flags
+                // is not retired, and nothing has been written yet.
+                if ((0, secretGuard_1.secretGuardEnabled)()) {
+                    await (0, secretGuard_1.assertStorable)([{ field: 'memory', text: block.raw }, { field: 'title', text: entryTitle }], 'retire');
+                }
+                const rest = withoutRanges(lines, block.ranges).join('\n');
+                // The log's last entry takes the log with it. What is left is the engine's own header: no memory, yet it stayed
+                // indexed as a note, an entity and a chunk, and with no entry in it no id could retire it (live dogfood,
+                // 2026-10-03, D11). Its bytes go into the record, which restore writes back.
+                const lastEntry = (0, dailyNote_1.isEmptyEngineDailyNote)(file.rel, rest);
+                // Journal first: a crash before the rewrite leaves the entry in place and the record void.
+                await appendJournal(ctx, {
+                    rid, id, kind: 'entry', path: file.rel, title: entryTitle, retiredAt: at, block: block.raw, copies: block.ranges.length,
+                    ...entryNeighbours(blocks, block),
+                    ...(lastEntry ? { remainder: rest } : {}),
+                });
+                if (lastEntry) {
+                    // Out of the index first, as a retired note is: a crash before the file goes leaves the entry in place, and
+                    // reconcile voids the record and indexes the file again.
+                    dropNoteFromIndex(ctx, file.indexed);
+                    await promises_1.default.unlink(file.real);
+                }
+                else {
+                    await atomicWrite(file.real, rest);
+                }
+                return { title: entryTitle, emptied: lastEntry };
+            });
+            if (!emptied)
+                await (0, pipeline_1.indexFile)(ctx.db, file.indexed, ctx.indexOptions);
+            recordEvent(ctx.db, file.rel, 'retire', id, title);
+            return { ok: true, id, action: 'retired', title, at };
+        }
+        const title = ctx.db.prepare('SELECT title FROM notes WHERE path = ?').get(file.indexed)?.title
+            ?? (0, parser_1.parseNote)(file.indexed, (await readPrefix(file.real, MAP_READ_BYTES))?.text ?? '').title;
+        // RENOR_SECRET_GUARD (default ON): the same rule for a whole note, before the retired directory exists.
+        if ((0, secretGuard_1.secretGuardEnabled)()) {
+            await (0, secretGuard_1.assertStorable)([{ field: 'memory', text: await readToScreen(file.real, 'retire') }, { field: 'title', text: title }], 'retire');
+        }
+        // Each retirement gets its own stored copy, so retiring a later note at the same path never
+        // hides an earlier one.
+        const storedRel = path_1.default.posix.join(RETIRED_FILES_DIR.split(path_1.default.sep).join('/'), `${rid.slice('retired:'.length)}`, file.rel);
+        const storedDir = await ensureRealDir(rootReal, path_1.default.posix.dirname(storedRel));
+        const storedReal = path_1.default.join(storedDir, path_1.default.posix.basename(storedRel));
+        // Journal first, then leave retrieval, then move: an interruption anywhere leaves a state
+        // reconcile() settles, never a memory nobody can restore.
+        await appendJournal(ctx, { rid, id, kind: 'note', path: file.rel, title, retiredAt: at, storedAt: storedRel });
+        // Under the file's lock, so an index pass already reading this note finishes before the drop,
+        // and one that starts after finds the file gone instead of re-adding it.
+        await (0, writer_1.withDailyFileLock)(file.indexed, async () => {
+            if (expectedHash !== undefined && (0, hasher_1.hashContent)(await readWhole(file.real)) !== expectedHash) {
+                // This retirement never took ownership: close its journal entry, preserving the edit.
+                await appendJournal(ctx, { rid, id, kind: 'note', path: file.rel, title, retiredAt: at, storedAt: storedRel, voided: true });
+                throw new Error('imported note changed; preserved');
+            }
+            dropNoteFromIndex(ctx, file.indexed);
+            await promises_1.default.rename(file.real, storedReal);
+        });
+        recordEvent(ctx.db, file.rel, 'retire', id, title);
+        return { ok: true, id, action: 'retired', title, at };
+    });
+}
+/**
+ * Restore by the retirement's id (from memory_map.retired) or by the memory id when exactly one
+ * retirement of it is in effect. Idempotent: a restore whose bytes are already back (a retry after
+ * an interruption) completes the journal and re-indexes instead of failing.
+ */
+function restoreMemory(ctx, id, options = {}) {
+    if ((0, lifecycle_1.factEventId)(id) !== null)
+        return (0, lifecycle_1.restoreFact)(ctx.db, ctx.memoryDir, ctx.ledgerRelPath, id, ctx.source, options.validateAfterWrite);
+    return serialize(async () => {
+        const before = await readJournal(ctx);
+        const pick = (records) => {
+            const active = activeRetired(records);
+            if (id.startsWith('retired:'))
+                return active.find((r) => r.rid === id) ?? null;
+            parseMemoryId(id);
+            const forMemory = active.filter((r) => r.id === id);
+            if (forMemory.length > 1)
+                throw (0, toolRefusal_1.refusal)('memory_already_retired', 'this memory was retired more than once; restore one retirement by its id from memory_map');
+            return forMemory[0] ?? null;
+        };
+        const wanted = pick(before);
+        await reconcile(ctx);
+        const record = pick(await readJournal(ctx));
+        if (!record) {
+            // Settled by reconcile because its bytes were already back: that is a completed restore.
+            if (wanted)
+                return { ok: true, id: wanted.id, action: 'restored', title: wanted.title, at: new Date().toISOString() };
+            throw (0, toolRefusal_1.refusal)('memory_not_found', 'no retired memory with that id');
+        }
+        const file = await resolveVaultFile(ctx, record.path, false);
+        const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+        const at = new Date().toISOString();
+        let rollback;
+        if (record.kind === 'entry') {
+            const day = dailyNote_1.DAILY_FILE_RE.exec(record.path)?.[2];
+            // The block is stored exactly as it was in the file. Not trimmed: a statement that opens with a line break
+            // has an entry line that ends in the separator space, and trimming it made the entry impossible to restore.
+            if (!record.block || !day || !dailyNote_1.ENTRY_LINE_RE.test(record.block.split('\n')[0]))
+                throw new Error('retired entry record is incomplete');
+            // RENOR_SECRET_GUARD (default ON): restoring puts the text back into live memory, so it is screened like a save.
+            if ((0, secretGuard_1.secretGuardEnabled)()) {
+                await (0, secretGuard_1.assertStorable)([{ field: 'memory', text: record.block }, { field: 'title', text: record.title }], 'restore');
+            }
+            await ensureRealDir(rootReal, path_1.default.posix.dirname(record.path));
+            await (0, writer_1.withDailyFileLock)(file.indexed, async () => {
+                let existing = null;
+                try {
+                    existing = await readWhole(file.real);
+                }
+                catch (err) {
+                    if (err.code !== 'ENOENT')
+                        throw err;
+                }
+                const copies = Array.from({ length: Math.max(1, record.copies ?? 1) }, () => record.block).join('\n');
+                rollback = existing === null
+                    ? async () => { await promises_1.default.rm(file.real, { force: true }); }
+                    : async () => { await atomicWrite(file.real, existing); };
+                if (existing !== null) {
+                    const { lines, blocks } = parseEntries(record.path, existing);
+                    if (blocks.some((b) => b.id === record.id))
+                        return; // already back
+                    // Back to its place in the day, not the end of the file: a restore at the end put an earlier entry after later ones.
+                    const line = restoreLine(blocks, record, (0, dailyNote_1.parseEntryHeader)(record.block.split('\n')[0])?.time ?? '');
+                    if (line !== null) {
+                        lines.splice(line, 0, ...copies.split('\n'));
+                        await atomicWrite(file.real, lines.join('\n'));
+                        return;
+                    }
+                }
+                const base = existing ?? record.remainder ?? (0, dailyNote_1.engineDailyHeader)(day);
+                await atomicWrite(file.real, `${base.replace(/\n*$/, '')}\n${copies}`);
+            });
+        }
+        else {
+            if (!record.storedAt)
+                throw new Error('retired note record is incomplete');
+            const storedDir = path_1.default.join(rootReal, ...path_1.default.posix.dirname(record.storedAt).split('/'));
+            if (!within(path_1.default.join(rootReal, RETIRED_FILES_DIR), path_1.default.join(storedDir, 'x')) || (await promises_1.default.realpath(storedDir)) !== storedDir) {
+                throw (0, toolRefusal_1.refusal)('unsafe_path', 'retired note record points outside the retired directory');
+            }
+            const storedReal = path_1.default.join(storedDir, path_1.default.posix.basename(record.storedAt));
+            if (await exists(file.real))
+                throw (0, toolRefusal_1.refusal)('restore_conflict', 'a memory already exists at that path; restore would overwrite it');
+            if ((0, secretGuard_1.secretGuardEnabled)()) {
+                await (0, secretGuard_1.assertStorable)([{ field: 'memory', text: await readToScreen(storedReal, 'restore') }, { field: 'title', text: record.title }], 'restore');
+            }
+            const targetDir = await ensureRealDir(rootReal, path_1.default.posix.dirname(record.path));
+            const targetReal = path_1.default.join(targetDir, path_1.default.posix.basename(record.path));
+            await promises_1.default.rename(storedReal, targetReal);
+            rollback = async () => { await promises_1.default.rename(targetReal, storedReal); };
+        }
+        try {
+            await options.validateAfterWrite?.();
+        }
+        catch (err) {
+            await rollback?.();
+            throw err;
+        }
+        // Index before the journal says "restored": if indexing fails, the record stays active and a
+        // retry completes the restore (see the idempotent path above).
+        await (0, pipeline_1.indexFile)(ctx.db, file.indexed, ctx.indexOptions);
+        await appendJournal(ctx, { ...record, restoredAt: at });
+        recordEvent(ctx.db, record.path, 'restore', record.id, record.title);
+        return { ok: true, id: record.id, action: 'restored', title: record.title, at };
+    });
+}
+/** The directory holding one retirement's stored copy: `.trash/renor-retired/files/<rid without its prefix>`. */
+function storedCopyDir(rootReal, rid) {
+    const hex = rid.startsWith('retired:') ? rid.slice('retired:'.length) : '';
+    if (!/^[0-9a-f]{16}$/.test(hex))
+        return null;
+    return path_1.default.join(rootReal, RETIRED_FILES_DIR, hex);
+}
+/**
+ * Remove the stored copy of every retirement the journal says was deleted. The journal is rewritten before any copy is
+ * removed (purgeRetired), so a crash between the two leaves a copy no record points to: this finds it by the rid the
+ * deletion's record keeps, and removes it. Only a plain directory inside the retired area is removed, never through a
+ * link.
+ */
+async function removePurgedCopies(rootReal, journal) {
+    for (const r of journal) {
+        if (!r.purgedAt || r.kind !== 'note')
+            continue;
+        const dir = storedCopyDir(rootReal, r.rid);
+        if (!dir)
+            continue;
+        let st;
+        try {
+            st = await promises_1.default.lstat(dir);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                continue;
+            throw err;
+        }
+        if (!st.isDirectory() || (await promises_1.default.realpath(path_1.default.dirname(dir))) !== path_1.default.dirname(dir))
+            continue;
+        // fs.rm removes a link inside the tree, never what it points to.
+        await promises_1.default.rm(dir, { recursive: true, force: true });
+    }
+}
+/** Bytes of regular files below `dir`, never through a link (what the storage gauge counts of a stored copy). */
+async function bytesBelow(dir) {
+    let total = 0;
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(dir, { withFileTypes: true });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return 0;
+        throw err;
+    }
+    for (const entry of entries) {
+        const abs = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory())
+            total += await bytesBelow(abs);
+        else if (entry.isFile() && entry.name.endsWith('.md'))
+            total += (await promises_1.default.lstat(abs)).size;
+    }
+    return total;
+}
+/**
+ * Permanently delete retired notes and daily-log entries: `target` is one retirement's id from memory_map.retired
+ * (`retired:<hex>`), or `all` for every retired note and entry. With `all`, `only` (retirement ids, as the owner saw them)
+ * limits the deletion to those, so a retirement made after the owner's list was read is not deleted unseen. A live memory
+ * has no retirement id, so it can never be deleted in one step: it is retired first. A retired fact is kept in the fact
+ * ledger, which is replayed to rebuild the index, and is refused here.
+ *
+ * What goes: a note's stored copy (so its bytes stop counting toward storage), an entry's text in the journal, every
+ * journal record of the memory's earlier retirements that carried its text, the retire, restore and note events that
+ * name it, cached evidence read from its file, a note's path in the import journal (.renor-imports), and every replacement
+ * record that names it (replaced.jsonl). The search index
+ * lost the memory when it was retired. What stays: one journal record per deletion (rid, kind, time) and one write event
+ * (how many, of which kind), neither with an id, a path, a title or any text.
+ *
+ * Crash safety: events, cached evidence, import-journal entries and replacement records are dropped first (a crash then leaves
+ * the memory retired and restorable, without its event titles, its undo entry or its replacement link); the journal rewrite is atomic and is the moment of
+ * deletion (from then on nothing lists or restores it); a stored copy left behind by a crash after it is removed by the
+ * next retire, restore or delete (removePurgedCopies), and until then it counts toward storage but nothing reads it.
+ */
+async function purgeRetired(ctx, target, only) {
+    if ((0, lifecycle_1.factEventId)(target) !== null) {
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'a retired fact stays in the fact ledger and cannot be deleted here; email privacy@renor.cloud to erase one');
+    }
+    if (target !== 'all' && !target.startsWith('retired:')) {
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'pass the id of a retired memory from memory_map.retired (retired:<id>) or "all"; a live memory is retired first');
+    }
+    if (only !== undefined && target !== 'all') {
+        throw (0, toolRefusal_1.refusal)('invalid_argument', 'a list of ids goes with "all" only: one id deletes one memory');
+    }
+    return serialize(async () => {
+        await reconcile(ctx);
+        const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+        const journal = await readJournal(ctx);
+        const live = (await collectMemories(ctx)).seen;
+        const completed = (await completedRetirements(ctx, live)).filter((r) => r.memory.kind !== 'fact');
+        const listed = only === undefined ? null : new Set(only);
+        const chosen = target === 'all'
+            ? completed.filter((r) => listed === null || listed.has(r.memory.id))
+            : completed.filter((r) => r.memory.id === target);
+        if (target !== 'all' && chosen.length === 0)
+            throw (0, toolRefusal_1.refusal)('memory_not_found', 'no retired note or entry with that id');
+        const at = new Date().toISOString();
+        if (chosen.length === 0)
+            return { ok: true, action: 'deleted', ids: [], freedBytes: 0, at };
+        const rids = new Set(chosen.map((r) => r.memory.id));
+        const memoryIds = new Set(chosen.map((r) => r.memory.memoryId));
+        const byRid = new Map(activeRetired(journal).map((r) => [r.rid, r]));
+        let freedBytes = 0;
+        for (const rid of rids) {
+            const dir = byRid.get(rid)?.kind === 'note' ? storedCopyDir(rootReal, rid) : null;
+            if (dir)
+                freedBytes += await bytesBelow(dir);
+        }
+        // 1. Events, cached evidence, import-journal entries and replacement records that carry its text or path. Idempotent, so a retry after a
+        // crash repeats them harmlessly.
+        const stems = new Set();
+        await (0, forgetImported_1.forgetImportedNotes)(ctx.memoryDir, new Set(chosen.filter((r) => r.memory.kind === 'note').map((r) => r.memory.path)));
+        await (0, replacedJournal_1.forgetReplacementsOf)(path_1.default.join(rootReal, exports.RETIRED_DIR), new Set(chosen.map((r) => r.memory.memoryId).filter((id) => typeof id === 'string')));
+        ctx.db.transaction(() => {
+            const named = ctx.db.prepare(`DELETE FROM write_events WHERE action IN ('retire', 'restore') AND json_valid(summary) AND json_extract(summary, '$.id') = ?`);
+            const noted = ctx.db.prepare(`DELETE FROM write_events WHERE action = 'note' AND note_path IN (?, ?) AND summary = ?`);
+            for (const memoryId of memoryIds)
+                named.run(memoryId);
+            for (const r of chosen) {
+                const rel = r.memory.path;
+                stems.add(rel);
+                stems.add(path_1.default.resolve(ctx.memoryDir, ...rel.split('/')));
+                if (r.memory.kind !== 'entry')
+                    continue;
+                const record = byRid.get(r.memory.id);
+                const text = record?.block ? parseEntries(rel, record.block).blocks[0]?.text : undefined;
+                if (text !== undefined)
+                    noted.run(rel, rel.split('/').join(path_1.default.sep), text.slice(0, 240));
+            }
+        })();
+        // A daily log is read whole by the evidence pass, so its live entries' extractions go too; the cache asks again.
+        if (ctx.evidenceCachePath)
+            (0, evidenceCache_1.dropEvidenceForStems)(ctx.evidenceCachePath, [...stems]);
+        // 2. The journal, rewritten atomically: the moment of deletion. Every record of a chosen retirement goes, and so does
+        // every ended retirement of the same memory (a restore or a void kept the entry's text); other retirements still in
+        // effect stay, so a memory retired twice keeps its other retirement.
+        const kept = journal.filter((r) => !rids.has(r.rid) && !(memoryIds.has(r.id) && !byRid.has(r.rid)));
+        const tombstones = [...rids].map((rid) => ({
+            rid, kind: byRid.get(rid).kind, purgedAt: at, voided: true,
+        }));
+        const dir = await ensureRealDir(rootReal, exports.RETIRED_DIR);
+        const file = path_1.default.join(dir, path_1.default.basename(RETIRED_INDEX));
+        const st = await promises_1.default.lstat(file);
+        if (!st.isFile() || st.nlink !== 1)
+            throw new Error(`refusing to rewrite ${JSON.stringify(RETIRED_INDEX)}: it is not a regular file with a single name`);
+        await atomicWrite(file, [...kept, ...tombstones].map((r) => JSON.stringify(r) + '\n').join(''));
+        // 3. The stored copies. A crash before this leaves them to removePurgedCopies.
+        await removePurgedCopies(rootReal, tombstones);
+        // 4. The visible audit line: what kind and how many, nothing else.
+        const notes = tombstones.filter((r) => r.kind === 'note').length;
+        const entries = tombstones.length - notes;
+        const counted = [notes ? `${notes} note${notes === 1 ? '' : 's'}` : '', entries ? `${entries} entr${entries === 1 ? 'y' : 'ies'}` : '']
+            .filter(Boolean).join(' and ');
+        ctx.db.prepare('INSERT INTO write_events (note_path, action, summary, created_at, author) VALUES (?, ?, ?, ?, ?)')
+            .run('_retired_', 'delete', `deleted permanently: ${counted}`, at, ctx.source ?? null);
+        return { ok: true, action: 'deleted', ids: [...rids], freedBytes, at };
+    });
+}
+/** Every entry of one daily log as stored (identical entries are one, as everywhere), in file order. */
+function dailyEntriesForExport(rel, content) {
+    const day = dailyNote_1.DAILY_FILE_RE.exec(rel)?.[2];
+    if (!day)
+        return [];
+    return parseEntries(rel, content).blocks.map((b) => ({ id: b.id, at: (0, dailyNote_1.entryInstant)(day, b), source: b.source, text: b.text }));
+}
+/**
+ * Every completed retirement of a note or an entry with its full retained text, newest first. A note's text is read from
+ * its stored copy (confined to the retired area); an entry's is the journal's block. Retired facts are not here: they
+ * come from listRetiredFacts. An interrupted retirement whose memory never left is not retired and is not listed.
+ */
+async function retiredForExport(ctx) {
+    const rootReal = await promises_1.default.realpath(ctx.memoryDir);
+    const out = [];
+    for (const r of activeRetired(await readJournal(ctx)).reverse()) {
+        const day = dailyNote_1.DAILY_FILE_RE.exec(r.path)?.[2];
+        if (r.kind === 'entry') {
+            if (!r.block)
+                continue;
+            let live = false;
+            try {
+                const file = await resolveVaultFile(ctx, r.path, true);
+                live = parseEntries(file.rel, await readWhole(file.real)).blocks.some((b) => b.id === r.id);
+            }
+            catch { /* the log is gone with its last entry: the entry is retired */ }
+            if (live)
+                continue;
+            const header = (0, dailyNote_1.parseEntryHeader)(r.block.split('\n')[0]);
+            out.push({
+                rid: r.rid, memoryId: r.id, kind: 'entry', path: r.path, title: r.title, retiredAt: r.retiredAt, content: r.block,
+                ...(day && header ? { savedAt: (0, dailyNote_1.entryInstant)(day, header) } : {}),
+            });
+            continue;
+        }
+        if (!r.storedAt)
+            continue;
+        const stored = path_1.default.join(rootReal, ...r.storedAt.split('/'));
+        if (!within(path_1.default.join(rootReal, RETIRED_FILES_DIR), stored))
+            continue;
+        try {
+            if ((await promises_1.default.realpath(path_1.default.dirname(stored))) !== path_1.default.dirname(stored))
+                continue;
+            const handle = await openConfined(stored);
+            let content;
+            try {
+                content = await handle.readFile('utf8');
+            }
+            finally {
+                await handle.close();
+            }
+            out.push({ rid: r.rid, memoryId: r.id, kind: 'note', path: r.path, title: r.title, retiredAt: r.retiredAt, storedAt: r.storedAt, content });
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                continue; // never moved: still live
+            throw err;
+        }
+    }
+    return out;
+}