@4fu/arbor-notes-sqlite 2026.1106.0 → 2026.1107.0

package/notes.js

@@ -15,7 +15,11 @@
  *   count and token budget, and frozen with the epoch's version, so every
  *   window opened in one epoch has the same prefix and later windows see the
  *   changes as a delta;
- * - every write recorded in the journal as a `note_revision` event.
+ * - every write recorded in the journal as a `note_revision` event;
+ * - lexical search: a word index with BM25, a trigram index for exact
+ *   substrings, and a `LIKE` scan for one- and two-character queries, merged
+ *   with exact substring hits first - and a semantic channel, note text embedded
+ *   and searched by meaning, when `@4fu/arbor-search-zvec` is installed.
  *
  * It is synchronous inside: one `DatabaseSync`, one transaction per write, so
  * the revision a write checks and the revision it writes are one atomic step.
@@ -24,13 +28,20 @@
  * may live behind a process boundary.
  */
 import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { arborError, isArborError } from "@4fu/arbor-errors";
 import { DEFAULT_PAGE_LIMIT, MAX_PAGE_LIMIT } from "@4fu/arbor-interfaces";
+import { indexText, resolveSegmenter } from "@4fu/arbor-lexical";
 import { bodyDiff } from "./diff.js";
 import { noteIdOf, noteRefOf, noteRefForms, parseNoteId, parseNoteRef, storedEventRef, storedWindowRef, } from "./refs.js";
-import { FTS_TABLE, createSchema } from "./schema.js";
+import { FTS_TABLE, WORD_TABLE, createSchema } from "./schema.js";
 import { USE_WEIGHTS, applyJudgeShare, pickByBudget, scoreNotes } from "./score.js";
-import { holdingIds, substringClause } from "./search.js";
+import { holdingIds, matchedIds } from "./search.js";
+import { resolveSemanticIndex } from "./semantic.js";
+import { textOf, zhTextTable } from "@4fu/arbor-prompt";
 /** A summary is at most this many characters (docs/memory.md). */
 export const SUMMARY_LIMIT = 200;
 /** How many characters of a body one read returns. */
@@ -46,6 +57,13 @@ export const DEFAULT_JUDGE_SHARE = 0.15;
 export const DEFAULT_HALF_LIFE_MS = 86_400_000;
 /** How many events one `about` lookup reads. */
 const ABOUT_EVENT_LIMIT = 200;
+/**
+ * The fewest candidates the semantic channel is asked for. A page of one still
+ * fuses the channels over a handful of candidates, so a hit the word index
+ * ranked first is not lost to a semantic hit the channel would have ranked
+ * second.
+ */
+const MIN_SEMANTIC_CANDIDATES = 10;
 function toNumber(value) {
     if (typeof value === "number")
         return value;
@@ -87,19 +105,19 @@ export function deriveSummary(body) {
     const characters = Array.from(flat);
     return characters.length <= SUMMARY_LIMIT ? flat : `${characters.slice(0, SUMMARY_LIMIT).join("")}…`;
 }
-function invalidNoteRef(call, ref) {
+function invalidNoteRef(text, call, ref) {
     return arborError({
         code: "invalid_input",
         rule: `note.${call}.ref`,
-        message: `note.${call}: ${ref} is not a note ref`,
-        nextAction: "pass a note ref such as n012, or one of its revisions such as n012@3",
+        message: text("refused.note.ref", { ref }),
+        nextAction: text("next.note.ref"),
         details: { ref },
     });
 }
-function parseOrThrow(ref, call) {
+function parseOrThrow(text, ref, call) {
     const parsed = parseNoteRef(ref);
     if (parsed === null)
-        throw invalidNoteRef(call, ref);
+        throw invalidNoteRef(text, call, ref);
     return parsed;
 }
 function toSummary(row) {
@@ -163,17 +181,38 @@ export class SqliteNoteStore {
     db;
     journal;
     clock;
+    segmenter;
     halfLifeMs;
+    semantic;
+    /** The temporary directory an in-memory store's vector collection lives in. */
+    ownedVectorDirectory;
+    /** The table every refusal this store raises is written from. */
+    text;
     /** One write at a time: a write spans the notes database and the journal. */
     writeQueue = Promise.resolve();
+    semanticReady = false;
+    semanticCaughtUp = false;
     closed = false;
     constructor(options) {
         this.path = options.path ?? ":memory:";
         this.db = new DatabaseSync(this.path);
-        createSchema(this.db);
+        this.segmenter = options.segmenter ?? resolveSegmenter();
+        // The segmenter is resolved first: a version-1 database migrates by
+        // segmenting the notes it already holds into the word index.
+        createSchema(this.db, this.segmenter);
         this.journal = options.journal;
         this.clock = options.now ?? (() => Date.now());
         this.halfLifeMs = options.usageHalfLifeMs ?? DEFAULT_HALF_LIFE_MS;
+        this.text = options.text ?? ((key, args) => textOf(zhTextTable, key, args));
+        // An in-memory store has no directory of its own; give it a temporary one
+        // and take it away on close. The semantic channel's store lives under it,
+        // beside where the notes database would be.
+        const root = this.path === ":memory:" ? join(tmpdir(), `arbor-notes-${randomUUID()}`) : null;
+        this.semantic =
+            options.semantic === undefined
+                ? resolveSemanticIndex(root === null ? `${this.path}.vectors` : join(root, "vectors"))
+                : options.semantic;
+        this.ownedVectorDirectory = root;
     }
     // --- writes -------------------------------------------------------------
     async write(input) {
@@ -217,8 +256,8 @@ export class SqliteNoteStore {
             throw arborError({
                 code: isArborError(error) ? error.code : "internal",
                 rule: "note.write.journal",
-                message: `note.write: ${noteRef} was not written because the journal refused the event (${detail})`,
-                nextAction: "fix what the journal refused, then write the note again",
+                message: this.text("refused.note.write.journal", { ref: noteRef, detail }),
+                nextAction: this.text("next.note.write.journal"),
                 details: { upstream: detail },
                 cause: error,
             });
@@ -229,40 +268,59 @@ export class SqliteNoteStore {
                 .run(event.ref, written.id, written.revision);
             this.db.prepare("UPDATE notes SET event = ? WHERE id = ?").run(event.ref, written.id);
         });
+        // The semantic channel is asynchronous, so the note is indexed once its
+        // revision is committed: a write never waits on a model, and a channel that
+        // is not ready yet holds the text until it is. With no channel there is
+        // nothing to wait for, and the write takes the path it always did. A delete
+        // takes the note's vector back out, as a redaction does in the journal.
+        if (this.semantic !== null) {
+            if (written.deleted)
+                await this.removeFromSemantic(written.id);
+            else
+                await this.addToSemantic(written.id, written.title, written.summary, written.body);
+        }
         return toNote(this.noteRow(written.id));
     }
     /** The rules a write has to meet before it touches the one copy. */
     checkWrite(input) {
+        if (input.id !== undefined && input.id.trim() === "") {
+            throw arborError({
+                code: "invalid_input",
+                rule: "note.write.id",
+                message: this.text("refused.note.write.id"),
+                nextAction: this.text("next.note.write.id"),
+            });
+        }
         if (input.title.trim() === "") {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.title",
-                message: "note.write: a note needs a title",
-                nextAction: "give the note a short title",
+                message: this.text("refused.note.write.title"),
+                nextAction: this.text("next.note.write.title"),
             });
         }
         if (input.delete !== true && input.body.trim() === "") {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.body",
-                message: "note.write: a note needs a body",
-                nextAction: "write what the note holds in body; a delete needs no body",
+                message: this.text("refused.note.write.body"),
+                nextAction: this.text("next.note.write.body"),
             });
         }
         if (input.summary !== undefined && Array.from(input.summary).length > SUMMARY_LIMIT) {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.summary",
-                message: `note.write: a summary is at most ${SUMMARY_LIMIT} characters`,
-                nextAction: `shorten the summary to at most ${SUMMARY_LIMIT} characters, or omit it`,
+                message: this.text("refused.note.write.summary", { limit: SUMMARY_LIMIT }),
+                nextAction: this.text("next.note.write.summary", { limit: SUMMARY_LIMIT }),
             });
         }
         if (input.id === undefined && input.expectedRevision !== undefined) {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.write.expected_revision",
-                message: "note.write: a new note has no revision to name",
-                nextAction: "omit expectedRevision to write a new note, or pass the note's id to replace it",
+                message: this.text("refused.note.write.expected_revision"),
+                nextAction: this.text("next.note.write.expected_revision"),
             });
         }
     }
@@ -280,22 +338,22 @@ export class SqliteNoteStore {
         else {
             const parsed = parseNoteId(input.id);
             if (parsed === null)
-                throw invalidNoteRef("write", input.id);
+                throw invalidNoteRef(this.text, "write", input.id);
             previous = this.noteRow(parsed);
             if (previous === null) {
                 throw arborError({
                     code: "not_found",
                     rule: "note.write.note",
-                    message: `note.write: ${input.id} is not in the notes`,
-                    nextAction: "omit id to write a new note, or look the note up with notes.search",
+                    message: this.text("refused.note.write.note", { id: input.id }),
+                    nextAction: this.text("next.note.write.note"),
                 });
             }
             if (previous.status === "deleted") {
                 throw arborError({
                     code: "not_found",
                     rule: "note.write.deleted",
-                    message: `note.write: ${input.id} is deleted`,
-                    nextAction: "its revisions still resolve by ref, but it cannot be written; write a new note instead",
+                    message: this.text("refused.note.write.deleted", { id: input.id }),
+                    nextAction: this.text("next.note.write.deleted"),
                 });
             }
             const expected = input.expectedRevision;
@@ -303,16 +361,20 @@ export class SqliteNoteStore {
                 throw arborError({
                     code: "invalid_input",
                     rule: "note.write.revision",
-                    message: `note.write: ${input.id} is at revision ${previous.revision}; a write names the revision it read`,
-                    nextAction: `read the note and write again against revision ${previous.revision}`,
+                    message: this.text("refused.note.write.revision", { id: input.id, revision: previous.revision }),
+                    nextAction: this.text("next.note.write.revision", { revision: previous.revision }),
                 });
             }
             if (expected > previous.revision) {
                 throw arborError({
                     code: "invalid_input",
-                    rule: "note.write.revision",
-                    message: `note.write: ${input.id}@${expected} does not exist; the note is at revision ${previous.revision}`,
-                    nextAction: `read the note and write again against revision ${previous.revision}`,
+                    rule: "note.write.revision.absent",
+                    message: this.text("refused.note.write.revision.absent", {
+                        id: input.id,
+                        expected,
+                        revision: previous.revision,
+                    }),
+                    nextAction: this.text("next.note.write.revision.absent", { revision: previous.revision }),
                 });
             }
             if (expected < previous.revision)
@@ -326,9 +388,9 @@ export class SqliteNoteStore {
                 input.body !== previous.body) {
                 throw arborError({
                     code: "invalid_input",
-                    rule: "note.write.summary",
-                    message: `note.write: a replace that changes the body of ${input.id} names a summary`,
-                    nextAction: `write a summary of at most ${SUMMARY_LIMIT} characters for the new body`,
+                    rule: "note.write.replace_summary",
+                    message: this.text("refused.note.write.replace_summary", { id: input.id }),
+                    nextAction: this.text("next.note.write.replace_summary", { limit: SUMMARY_LIMIT }),
                 });
             }
         }
@@ -359,12 +421,16 @@ export class SqliteNoteStore {
             .prepare(`INSERT INTO note_revisions (note, revision, title, summary, body, deleted, time, window, event, anchor, refs)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)`)
             .run(id, revision, input.title, summary, body, deleted ? 1 : 0, time, window, anchorJson, refs);
-        // The search index holds the current state; a deleted note is not found.
+        // The search indexes hold the current state; a deleted note is not found.
         this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE rowid = ?`).run(id);
+        this.db.prepare(`DELETE FROM ${WORD_TABLE} WHERE rowid = ?`).run(id);
         if (!deleted) {
             this.db
                 .prepare(`INSERT INTO ${FTS_TABLE} (rowid, title, summary, body) VALUES (?, ?, ?, ?)`)
                 .run(id, input.title, summary, body);
+            this.db
+                .prepare(`INSERT INTO ${WORD_TABLE} (rowid, title, summary, body) VALUES (?, ?, ?, ?)`)
+                .run(id, indexText(input.title, this.segmenter), indexText(summary, this.segmenter), indexText(body, this.segmenter));
         }
         // The refs the revision names: what it cites and what it holds as
         // evidence. The evidence ones between notes are what the credit walk
@@ -387,6 +453,8 @@ export class SqliteNoteStore {
             time,
             title: input.title,
             summary,
+            body,
+            deleted,
             window,
             anchor,
         };
@@ -401,6 +469,7 @@ export class SqliteNoteStore {
                 .prepare("DELETE FROM note_refs WHERE note = ? AND revision = ?")
                 .run(written.id, written.revision);
             this.db.prepare(`DELETE FROM ${FTS_TABLE} WHERE rowid = ?`).run(written.id);
+            this.db.prepare(`DELETE FROM ${WORD_TABLE} WHERE rowid = ?`).run(written.id);
             if (written.created) {
                 this.db.prepare("DELETE FROM notes WHERE id = ?").run(written.id);
                 return;
@@ -415,6 +484,9 @@ export class SqliteNoteStore {
                 this.db
                     .prepare(`INSERT INTO ${FTS_TABLE} (rowid, title, summary, body) VALUES (?, ?, ?, ?)`)
                     .run(written.id, previous.title, previous.summary, previous.body);
+                this.db
+                    .prepare(`INSERT INTO ${WORD_TABLE} (rowid, title, summary, body) VALUES (?, ?, ?, ?)`)
+                    .run(written.id, indexText(previous.title, this.segmenter), indexText(previous.summary, this.segmenter), indexText(previous.body, this.segmenter));
             }
         });
     }
@@ -435,8 +507,16 @@ export class SqliteNoteStore {
         return arborError({
             code: "conflict",
             rule: "note.write.stale_revision",
-            message: `note.write: ${noteIdOf(note.id)} is at revision ${current}, not the revision ${read} you read; merge what changed and write again`,
-            nextAction: `read ${noteIdOf(note.id)}@${current} and the revisions since ${read}, merge them with this write, then write again against revision ${current}`,
+            message: this.text("refused.note.write.stale_revision", {
+                ref: noteRefOf(note.id, current),
+                current,
+                read,
+            }),
+            nextAction: this.text("next.note.write.stale_revision", {
+                ref: noteRefOf(note.id, current),
+                current,
+                read,
+            }),
             refs: [noteRefOf(note.id, current), ...revisions.map((revision) => revision.ref)],
             details: {
                 conflict: { read, current, revisions },
@@ -447,7 +527,7 @@ export class SqliteNoteStore {
     // --- reads --------------------------------------------------------------
     async read(ref, options) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "read");
+        const parsed = parseOrThrow(this.text, ref, "read");
         const row = parsed.revision === null ? this.latestRevisionRow(parsed.id) : this.revisionRow(parsed.id, parsed.revision);
         if (row === null)
             return null;
@@ -469,7 +549,7 @@ export class SqliteNoteStore {
     }
     async revisions(ref) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "revisions");
+        const parsed = parseOrThrow(this.text, ref, "revisions");
         const limit = DEFAULT_PAGE_LIMIT;
         const nextCall = `notes.revisions(${noteIdOf(parsed.id)}, offset=${limit})`;
         const note = this.noteRow(parsed.id);
@@ -487,16 +567,25 @@ export class SqliteNoteStore {
         const offset = Math.max(0, Math.floor(query.offset ?? 0));
         const text = (query.query ?? "").trim();
         // `about` and `linked` bound the result to the notes the journal resolved,
-        // in weight order; a text match narrows that set.
+        // in weight order; a text match narrows that set. The semantic channel does
+        // not widen a bound the journal resolved, so it is not asked at all here.
         if (query.about !== undefined || query.linked !== undefined) {
             const ordered = await this.linkedNoteIds(query.about, query.linked);
-            const holding = text === "" ? null : new Set(holdingIds(this.db, text, ordered));
+            const holding = text === "" ? null : new Set(holdingIds(this.db, text, ordered, this.segmenter));
             const chosen = holding === null ? ordered : ordered.filter((id) => holding.has(id));
             const page = this.summaryPageByIds(chosen, query, limit, offset);
             return { ...page, nextCall: searchCall(query, offset, limit) };
         }
-        const match = text === "" ? null : substringClause(text);
-        const page = this.summaryPageBySql(query, limit, offset, match);
+        // No query lists every note by id; a query is answered by the lexical
+        // channels and the semantic one, merged: exact substring hits first, then
+        // word hits, then the hits only the semantic channel found.
+        const semantic = text === "" ? [] : await this.semanticRanks(text, limit, query.status);
+        const matched = text === ""
+            ? null
+            : matchedIds(this.db, text, this.segmenter, query.status, semantic);
+        const page = matched === null
+            ? this.summaryPageBySql(query, limit, offset)
+            : this.summaryPage(matched, limit, offset);
         return { ...page, nextCall: searchCall(query, offset, limit) };
     }
     async active() {
@@ -510,7 +599,7 @@ export class SqliteNoteStore {
     }
     async context(ref) {
         this.ensureOpen();
-        const parsed = parseOrThrow(ref, "context");
+        const parsed = parseOrThrow(this.text, ref, "context");
         const note = this.noteRow(parsed.id);
         if (note === null)
             return null;
@@ -552,6 +641,7 @@ export class SqliteNoteStore {
                 limit: items.length,
                 nextCall: `notes.delta(${epoch.epoch})`,
                 budget,
+                tokens: this.epochTokens(epoch.epoch),
             };
         });
     }
@@ -564,8 +654,8 @@ export class SqliteNoteStore {
             throw arborError({
                 code: "invalid_input",
                 rule: "note.delta.epoch",
-                message: `note.delta: epoch ${since} is not in the notes`,
-                nextAction: "pass the epoch the window froze, or 0 for every note",
+                message: this.text("refused.note.delta.epoch", { since }),
+                nextAction: this.text("next.note.delta.epoch"),
                 details: { since },
             });
         }
@@ -631,7 +721,7 @@ export class SqliteNoteStore {
     }
     async recordUse(input) {
         this.ensureOpen();
-        const parsed = parseOrThrow(input.ref, "recordUse");
+        const parsed = parseOrThrow(this.text, input.ref, "recordUse");
         // A use of a note that is not there names a ref that does not resolve; the
         // host's own append must not fail for it.
         if (this.noteRow(parsed.id) === null)
@@ -661,6 +751,39 @@ export class SqliteNoteStore {
         this.closed = true;
         await this.writeQueue;
         this.db.close();
+        // The channel's own store is closed with the notes database, and the
+        // temporary directory an in-memory store gave it goes with it.
+        if (this.semantic !== null)
+            await this.semantic.close();
+        if (this.ownedVectorDirectory !== null) {
+            await rm(this.ownedVectorDirectory, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Index the notes the semantic channel does not hold yet, and say how many.
+     *
+     * A restart over an existing database, a channel that was not ready when the
+     * notes were written, and a write whose indexing failed all leave notes to
+     * catch up on. A channel that is not ready yet holds what it was given and
+     * indexes that itself, so this answers 0 until it is.
+     */
+    async catchUpSemantic() {
+        this.ensureOpen();
+        if (this.semantic === null || !(await this.semantic.ready()))
+            return 0;
+        const held = await this.semantic.held();
+        const rows = this.db
+            .prepare(`SELECT id, title, summary, body FROM notes WHERE status <> 'deleted' ORDER BY id`)
+            .all();
+        let indexed = 0;
+        for (const row of rows) {
+            const id = toNumber(row.id);
+            if (held.has(noteIdOf(id)))
+                continue;
+            await this.addToSemantic(id, row.title, row.summary, row.body);
+            indexed += 1;
+        }
+        return indexed;
     }
     // --- internals ---------------------------------------------------------
     ensureOpen() {
@@ -668,11 +791,109 @@ export class SqliteNoteStore {
             throw arborError({
                 code: "unavailable",
                 rule: "note.closed",
-                message: "notes: the note store is closed",
-                nextAction: "open a note store before reading or writing",
+                message: this.text("refused.note.closed"),
+                nextAction: this.text("next.note.closed"),
             });
         }
     }
+    /**
+     * Hand one note's text to the semantic channel, when there is one.
+     *
+     * The note is embedded as one text: its title, its summary and its body, in
+     * the order the lexical index weights them. The vector channel holds one
+     * vector per note and cannot weight a note's parts against each other the way
+     * BM25 weights the three columns, so the title - the note's name - leads the
+     * text and the body follows it, and a query that means either reaches the
+     * note (docs/memory.md#search).
+     */
+    async addToSemantic(id, title, summary, body) {
+        if (this.semantic === null)
+            return;
+        try {
+            await this.semantic.add(noteIdOf(id), [title, summary, body].join("\n"));
+        }
+        catch {
+            // An optional channel that refuses leaves the note searchable lexically;
+            // a catch-up indexes it once the channel answers again.
+        }
+    }
+    /** Take one note's text back out of the semantic channel, as a delete does. */
+    async removeFromSemantic(id) {
+        if (this.semantic === null)
+            return;
+        try {
+            await this.semantic.remove(noteIdOf(id));
+        }
+        catch {
+            // As with a write: the channel is optional, and the note is gone from
+            // every index the store owns.
+        }
+    }
+    /**
+     * The semantic channel's candidates, as ranks in the order it gave them.
+     *
+     * An absent channel, one that is not ready yet, and one that refuses all
+     * answer with nothing, and the search is exactly the lexical one. The note
+     * read's own filters decide which candidates count, so a channel that filters
+     * less than the store does still answers the read it was asked for.
+     */
+    async semanticRanks(query, limit, status) {
+        if (this.semantic === null)
+            return [];
+        const ready = await this.semantic.ready();
+        if (ready !== this.semanticReady) {
+            // The channel just became usable, or stopped being: index what it missed
+            // while it was not.
+            this.semanticReady = ready;
+            this.semanticCaughtUp = false;
+        }
+        if (!this.semanticCaughtUp) {
+            this.semanticCaughtUp = true;
+            await this.catchUpSemantic();
+        }
+        if (!ready)
+            return [];
+        // The filters a note read applies are the store's own, and none of them is
+        // a field of the channel: a note's status changes at every snapshot epoch
+        // without a revision, and `about` and `linked` are bounds the journal
+        // resolved. So the channel is asked for the notes nearest the query and
+        // nothing else, and the store applies its own filters to what comes back -
+        // exactly as the journal does with the targets it filters on itself
+        // (docs/memory.md#search).
+        const asked = {};
+        const refs = await this.semantic.search(query, Math.max(limit, MIN_SEMANTIC_CANDIDATES), asked);
+        const ids = [];
+        for (const ref of refs) {
+            const id = parseNoteId(ref);
+            if (id !== null)
+                ids.push(id);
+        }
+        const allowed = this.allowedNoteIds(ids, status);
+        // The channel's order, as ranks the shared merge reads: the nearest hit
+        // carries the most negative rank, so it normalizes to the best score.
+        return allowed.map((id, index) => ({ rowid: id, rank: index - allowed.length }));
+    }
+    /**
+     * The notes among `ids` the read's own filters allow, in the order given. A
+     * deleted note is not among them, so a vector that outlived its note never
+     * reaches a page.
+     */
+    allowedNoteIds(ids, status) {
+        if (ids.length === 0)
+            return [];
+        const clauses = ["status <> 'deleted'"];
+        const params = [...ids];
+        if (status !== undefined) {
+            clauses.push("status = ?");
+            params.push(status);
+        }
+        const rows = this.db
+            .prepare(`SELECT id FROM notes
+         WHERE id IN (${ids.map(() => "?").join(", ")}) AND ${clauses.join(" AND ")}`)
+            .all(...params);
+        const allowed = new Set(rows.map((row) => toNumber(row.id)));
+        return ids.filter((id) => allowed.has(id));
+    }
     noteRow(id) {
         const row = this.db
             .prepare(`SELECT id, created, updated, revision, title, summary, body, status, window, anchor, event
@@ -712,13 +933,11 @@ export class SqliteNoteStore {
         }
         return states;
     }
-    summaryPageBySql(query, limit, offset, match) {
-        const clauses = [];
+    summaryPageBySql(query, limit, offset) {
+        // A delete leaves the row and marks it, and this reads the notes table
+        // itself, so it leaves the deleted ones out on its own (docs/memory.md).
+        const clauses = ["n.status <> 'deleted'"];
         const params = [];
-        if (match !== null) {
-            clauses.push(match.sql);
-            params.push(...match.params);
-        }
         if (query.status !== undefined) {
             clauses.push("n.status = ?");
             params.push(query.status);
@@ -734,10 +953,28 @@ export class SqliteNoteStore {
             .get(...params).n);
         return { items: rows.map(toSummary), total, limit };
     }
+    /** One page of an ordered id list, in the order the list gives. */
+    summaryPage(ordered, limit, offset) {
+        const page = ordered.slice(offset, offset + limit);
+        if (page.length === 0)
+            return { items: [], total: ordered.length, limit };
+        const rows = this.db
+            .prepare(`SELECT id, revision, title, summary, status, updated FROM notes
+         WHERE id IN (${page.map(() => "?").join(", ")})`)
+            .all(...page);
+        const byId = new Map(rows.map((row) => [toNumber(row.id), row]));
+        const items = page
+            .map((id) => byId.get(id))
+            .filter((row) => row !== undefined)
+            .map(toSummary);
+        return { items, total: ordered.length, limit };
+    }
     summaryPageByIds(ordered, query, limit, offset) {
         if (ordered.length === 0)
             return { items: [], total: 0, limit };
-        const clauses = [`id IN (${ordered.map(() => "?").join(", ")})`];
+        // A delete leaves the row and marks it, and no search returns the note
+        // again, whichever lookup ordered it (docs/memory.md).
+        const clauses = [`status <> 'deleted'`, `id IN (${ordered.map(() => "?").join(", ")})`];
         const params = [...ordered];
         if (query.status !== undefined) {
             clauses.push("status = ?");
@@ -841,6 +1078,13 @@ export class SqliteNoteStore {
             activate.run(item.note);
         return this.epochRow(epoch);
     }
+    /** What the active notes of one epoch cost, as the epoch froze them. */
+    epochTokens(epoch) {
+        const row = this.db
+            .prepare("SELECT COALESCE(SUM(tokens), 0) AS total FROM note_epoch_items WHERE epoch = ?")
+            .get(epoch);
+        return row === undefined ? 0 : toNumber(row.total);
+    }
     /** The active notes one epoch froze, by summary, sorted by id. */
     epochSummaries(epoch) {
         const rows = this.db

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@4fu/arbor-notes-sqlite",
-  "version": "2026.1106.0",
+  "version": "2026.1107.0",
   "type": "module",
-  "description": "The default NoteStore: one copy of every note, checked writes, revisions, anchors and the active set on SQLite beside the journal.",
+  "description": "The default NoteStore: one copy of every note, checked writes, revisions, anchors, the active set and search on SQLite beside the journal: lexical, and semantic when the optional channel is installed.",
   "exports": {
     ".": {
       "types": "./index.d.ts",
@@ -25,7 +25,9 @@
     "score.d.ts",
     "score.js",
     "search.d.ts",
-    "search.js"
+    "search.js",
+    "semantic.d.ts",
+    "semantic.js"
   ],
   "engines": {
     "node": ">=24"
@@ -40,7 +42,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@4fu/arbor-errors": "2026.1106.0",
-    "@4fu/arbor-interfaces": "2026.1106.0"
+    "@4fu/arbor-errors": "2026.1107.0",
+    "@4fu/arbor-interfaces": "2026.1107.0",
+    "@4fu/arbor-lexical": "2026.1107.0",
+    "@4fu/arbor-prompt": "2026.1107.0"
+  },
+  "peerDependencies": {
+    "@4fu/arbor-search-zvec": "2026.1107.0"
+  },
+  "peerDependenciesMeta": {
+    "@4fu/arbor-search-zvec": {
+      "optional": true
+    }
   }
 }