@anchrd/intel-api 0.12.5 → 0.14.0

package/dist/adapters/semantic-index/semantic-index.js

@@ -1,15 +1,48 @@
 const defaultModel = "@cf/baai/bge-m3";
 const maxEmbeddingCharacters = 24_000;
-function embedding(result) {
+// How much of one embedding request this adapter is willing to be: at most this many texts, and at
+// most this many characters across them. Both bounds are ours rather than a number Cloudflare
+// publishes — what the model documents is the shape of `text`, not a batch size — so they are set
+// well inside anything plausible. The point is that a board with three hundred cards costs a
+// handful of requests on its first pass instead of three hundred round trips.
+const maxBatchTexts = 25;
+const maxBatchCharacters = 96_000;
+// Vectorize takes at most 1000 vectors in one call from a Worker (platform limits). A board may
+// hold 5000 tasks, so the write is cut rather than sent whole and refused.
+const maxVectorsPerCall = 1000;
+/**
+ * How a chunk is named in the vector index (anchrd/intel#301).
+ *
+ * ⚠️ `""` keeps the bare node id, which is what every vector written before this was called. That
+ * is the whole reason the separator sits on the SUFFIX side: nothing an installation already holds
+ * changes its name, so this ships without re-embedding a tree.
+ *
+ * ⚠️ Reading it back splits at the FIRST separator, and that direction matters. A node id is minted
+ * here (`ulid`) and cannot contain a `#`; a task id can, because a bundle import carries the task
+ * ids written in the file. Splitting at the first `#` therefore always recovers the node id exactly
+ * and leaves the rest to the key — and even a key that never matched a card costs a hit that
+ * hydrates to nothing, never a citation for a node the searcher did not match.
+ */
+const chunkSeparator = "#";
+function vectorId(nodeId, key) {
+    return key === "" ? nodeId : `${nodeId}${chunkSeparator}${key}`;
+}
+function embeddings(result, expected) {
     if (typeof result !== "object" ||
         result === null ||
         !("data" in result) ||
         !Array.isArray(result.data) ||
-        !Array.isArray(result.data[0]) ||
-        !result.data[0].every((value) => typeof value === "number")) {
+        // ⚠️ The count is part of the check. The rows come back in the order the texts went out and
+        // nothing else identifies them, so a short answer would silently pair every embedding after the
+        // gap with the wrong card — a search that answers confidently with the neighbouring task.
+        result.data.length !== expected ||
+        // ⚠️ And every row has to hold something. An empty one passes "is an array of numbers" and would
+        // be upserted under a real card's name as a vector that matches nothing — indexed, recorded as
+        // fingerprinted, and never looked at again until somebody edits that card.
+        !result.data.every((row) => Array.isArray(row) && row.length > 0 && row.every((value) => typeof value === "number"))) {
         throw new Error("The embedding provider returned an invalid response");
     }
-    return result.data[0];
+    return result.data;
 }
 function matches(result) {
     if (typeof result !== "object" ||
@@ -27,27 +60,74 @@ function matches(result) {
             typeof match.score !== "number") {
             return [];
         }
-        return [{ nodeId: match.id, score: Math.max(0, Math.min(1, match.score)) }];
+        const separator = match.id.indexOf(chunkSeparator);
+        return [
+            {
+                nodeId: separator < 0 ? match.id : match.id.slice(0, separator),
+                chunkKey: separator < 0 ? "" : match.id.slice(separator + 1),
+                score: Math.max(0, Math.min(1, match.score)),
+            },
+        ];
     });
 }
+function batched(chunks) {
+    const batches = [];
+    let current = [];
+    let characters = 0;
+    for (const chunk of chunks) {
+        if (current.length > 0 &&
+            (current.length >= maxBatchTexts || characters >= maxBatchCharacters)) {
+            batches.push(current);
+            current = [];
+            characters = 0;
+        }
+        current.push(chunk);
+        characters += chunk.text.length;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
 export function createSemanticIndex(deps) {
     const model = deps.model ?? defaultModel;
-    async function embed(text) {
-        return embedding(await deps.ai.run(model, { text: [text] }));
+    async function embed(texts) {
+        return embeddings(await deps.ai.run(model, { text: texts }), texts.length);
     }
     return {
-        async replace(target, content) {
-            const text = `${target.title}\n\n${content}`.slice(0, maxEmbeddingCharacters);
-            await deps.index.upsert([
-                {
-                    id: target.nodeId,
-                    values: await embed(text),
-                    metadata: { versionId: target.versionId },
-                },
-            ]);
+        async upsert(target, chunks) {
+            const vectors = [];
+            for (const batch of batched(chunks)) {
+                const values = await embed(batch.map((chunk) => chunk.text.slice(0, maxEmbeddingCharacters)));
+                batch.forEach((chunk, index) => {
+                    const embedded = values[index];
+                    // The index is what makes this reachable at all — `embeddings` has already refused a short
+                    // answer and an empty row, so this is the type system's question rather than the
+                    // provider's. It throws anyway rather than skipping: the alternative to a missing card is
+                    // never a shorter list, it is a card recorded as fingerprinted with no vector behind it.
+                    if (!embedded)
+                        throw new Error("The embedding provider returned an invalid response");
+                    vectors.push({
+                        id: vectorId(target.nodeId, chunk.key),
+                        values: embedded,
+                        metadata: { versionId: target.versionId },
+                    });
+                });
+            }
+            for (let offset = 0; offset < vectors.length; offset += maxVectorsPerCall) {
+                await deps.index.upsert(vectors.slice(offset, offset + maxVectorsPerCall));
+            }
+        },
+        async remove(nodeId, keys) {
+            const ids = keys.map((key) => vectorId(nodeId, key));
+            for (let offset = 0; offset < ids.length; offset += maxVectorsPerCall) {
+                await deps.index.deleteByIds(ids.slice(offset, offset + maxVectorsPerCall));
+            }
         },
         async search(query, limit) {
-            const result = await deps.index.query(await embed(query), {
+            const [vector] = await embed([query]);
+            if (!vector)
+                throw new Error("The embedding provider returned an invalid response");
+            const result = await deps.index.query(vector, {
                 topK: Math.max(1, Math.min(100, limit)),
                 returnMetadata: "none",
             });

package/dist/adapters/semantic-index/semantic-index.types.d.ts

@@ -12,17 +12,36 @@ export interface VectorizeBinding {
             versionId: string;
         };
     }>): Promise<unknown>;
+    deleteByIds(ids: string[]): Promise<unknown>;
     query(vector: number[], options: {
         topK: number;
         returnMetadata: "none";
     }): Promise<unknown>;
 }
+/**
+ * One vector's worth of a node (anchrd/intel#301).
+ *
+ * ⚠️ `key` is `""` for a node that carries exactly one vector — every kind but `board` — and the
+ * vector is then named by the bare node id it has always been named by. A board card carries its
+ * task id, and its vector is `<node id>#<task id>`.
+ *
+ * `text` is embedded verbatim. Composing it — the node's title in front of a document's body, the
+ * card's own title in front of a card — belongs to the indexing pass rather than here, because the
+ * same string has to be fingerprinted there to decide whether this vector needs making at all. A
+ * title prefixed on this side would sit outside that fingerprint and change nothing when it changed.
+ */
+export interface SemanticChunk {
+    key: string;
+    text: string;
+}
 export interface SemanticHit {
     nodeId: string;
+    chunkKey: string;
     score: number;
 }
 export interface SemanticIndex {
-    replace(target: NodeIndexTarget, content: string): Promise<void>;
+    upsert(target: NodeIndexTarget, chunks: SemanticChunk[]): Promise<void>;
+    remove(nodeId: string, keys: string[]): Promise<void>;
     search(query: string, limit: number): Promise<SemanticHit[]>;
 }
 export interface SemanticIndexDeps {

package/dist/bundle/bundle.js

@@ -1,5 +1,6 @@
 import { AgentDefinition, AgentMediaType, BlockNoteMediaType, BoardDocument, BoardMediaType, BundleImportResult, BundleManifest, BundleManifestFilename, DocumentLinkInlineType, FlowGraph, TableMediaType, } from "@anchrd/intel-contract";
 import { Unzip, UnzipInflate, Zip, ZipDeflate, ZipPassThrough } from "fflate";
+import { repeatedBoardId, upgradeStoredBoard } from "../nodes/board/board.js";
 import { documentLinkTargets } from "../nodes/document-links/document-links.js";
 import { parseCsv } from "../shared/csv/csv.js";
 import { IntelError } from "../shared/intel-error/intel-error.js";
@@ -925,6 +926,20 @@ export function createBundle(deps) {
                         if (header.length === 0 || header.every((column) => column.trim().length === 0)) {
                             throw new IntelError(400, "import_invalid_table", `Bundle entry is not a table with a header row: ${entry.path}`);
                         }
+                        // ⚠️ Distinct column names, read the same way `DefineTableInput` and
+                        // `RedefineTableInput` read them — case-insensitively (#322). Both refuse a duplicate,
+                        // and the import used to walk past both: a table could only enter the tree this way
+                        // with two columns of one name.
+                        //
+                        // The consumer assumes the opposite and says so. `packages/ui/src/node-table` keys its
+                        // header cells and every row cell with the column name and carries the comment
+                        // "Column names are distinct by contract (`DefineTableInput`)" — true for the two write
+                        // paths, and false for this one. Two equal names are two React keys with one value, in
+                        // the header AND in every row.
+                        const seen = new Set(header.map((column) => column.trim().toLowerCase()));
+                        if (seen.size !== header.length) {
+                            throw new IntelError(400, "import_invalid_table", `Bundle entry has two columns of the same name: ${entry.path}`);
+                        }
                         // The whole file as one snapshot: the same shape a definition or a redefine writes
                         // (#135), so reading starts here and nothing older is expected to exist.
                         version = versionRowFor(entry, text, TableMediaType, await deps.hash(text), "snapshot");
@@ -935,11 +950,41 @@ export function createBundle(deps) {
                     if (text.trim().length > 0) {
                         let document;
                         try {
-                            document = BoardDocument.parse(JSON.parse(text));
+                            // Same upgrade the stored read does (anchrd/intel#311): a bundle exported before
+                            // `terminal` existed is exactly an old board in a file, and importing it must not be
+                            // the one way to lose a board.
+                            document = BoardDocument.parse(upgradeStoredBoard(JSON.parse(text)));
                         }
                         catch {
                             throw new IntelError(400, "import_invalid_board", `Bundle entry is not a board: ${entry.path}`);
                         }
+                        /**
+                         * ⚠️ Refused by name, and refused rather than folded (anchrd/intel#321).
+                         *
+                         * A board arriving in a file is the ONE place a document somebody else wrote becomes
+                         * truth here — everywhere else a task id is minted by `deps.id()` and a status list
+                         * goes through `ConfigureBoardInput`, which has demanded distinct ids since #285. Two
+                         * tasks under one id threw `graph.addNode` out of the board's graph view, and two
+                         * statuses under one id drew the same cards in two lanes with a drop that had two
+                         * targets meaning one.
+                         *
+                         * Outside the catch above on purpose: swallowed into `import_invalid_board` this would
+                         * read as "that file is not a board", and whoever is holding the file would look for
+                         * the wrong thing. `repeatedBoardId` names the id, which is the line they have to fix.
+                         *
+                         * ⚠️ And it names the way out, not only the fault (anchrd/intel#341). The usual holder
+                         * of such a file is not its author but somebody moving a tree between installations,
+                         * and the pair is in the BOARD the export came from — where `board_repair_task_ids`
+                         * and `board_configure` each remove one kind of it. Told only what is wrong, they were
+                         * left editing JSON by hand or leaving the board behind, and an import is all or
+                         * nothing: one such board stops the whole move.
+                         */
+                        const repeated = repeatedBoardId(document);
+                        if (repeated !== null) {
+                            throw new IntelError(400, "import_duplicate_board_id", repeated.list === "tasks"
+                                ? `Bundle entry names the task “${repeated.id}” twice: ${entry.path}. Repair that board with board_repair_task_ids where it came from, then export it again.`
+                                : `Bundle entry names the status “${repeated.id}” twice: ${entry.path}. Repair that board with board_configure — the status list written whole, with distinct ids — where it came from, then export it again.`);
+                        }
                         // ⚠️ `references` are remapped the way a document's inline links are, and `dependsOn`
                         // and `parentId` are NOT (#285). A task's references point at NODES, which the import
                         // renumbers; its dependencies and its parent point at tasks inside this very file,

package/dist/http/http.js

@@ -486,6 +486,10 @@ export function createHttp(deps) {
         }
         return context.json(await deps.nodes.deleteBoardTask(asActor(auth), input), 201);
     });
+    // ⚠️ There is deliberately no route for the sixth board operation. `board_repair_task_ids`
+    // (anchrd/intel#341) is MCP-only until a screen calls it: the routes here are what the browser
+    // reaches, nothing in `intel-data-provider` asks for it, and a route with no caller is the thing
+    // YAGNI is about. The screen is anchrd/intel#358, and it brings this route with it.
     app.get("/nodes/:nodeId/links", async (context) => {
         const auth = requireCapability(context, "knowledge", "read");
         return context.json(await deps.nodes.listLinks(asActor(auth), context.req.param("nodeId")));

package/dist/indexing/indexing.js

@@ -1,6 +1,14 @@
-import { BlockNoteDocument, BlockNoteMediaType, BoardDocument } from "@anchrd/intel-contract";
+import { ArchivedBoardStatusId, BlockNoteDocument, BlockNoteMediaType, BoardDocument, } from "@anchrd/intel-contract";
+import { upgradeStoredBoard } from "../nodes/board/board.js";
 export class PermanentIndexingError extends Error {
 }
+// The key under which a node that has exactly one vector is filed — every kind but `board`. It is
+// the bare node id in the index itself, which is why nothing written before anchrd/intel#301 has to
+// be renamed or embedded again.
+const wholeNodeChunkKey = "";
+// What the pass hands to `purgeVectors` at its end: the names it has just written, in case the node
+// was archived while it worked and the record of them was refused (anchrd/intel#348).
+const writtenKeys = (chunks) => chunks.map((chunk) => chunk.key);
 function indexText(mediaType, content) {
     if (mediaType !== BlockNoteMediaType)
         return content;
@@ -14,7 +22,8 @@ function indexText(mediaType, content) {
     }
 }
 /**
- * One passage per task, never one per board (#285).
+ * One passage per task, never one per board (#285) — and since anchrd/intel#301 one VECTOR per task
+ * too, which is what `key` carries.
  *
  * ⚠️ This is the whole reason a board is chunked at all. "Where do I stand with X" has to land on a
  * CARD: indexed as one blob, a board of three hundred tasks matches on any of them and answers with
@@ -22,8 +31,17 @@ function indexText(mediaType, content) {
  * have nothing to do with the question. Each chunk carries the task's own title, which is the
  * column the FTS table weights highest.
  *
- * ⚠️ The status list is not indexed. "Backlog" and "Done" appear on every board in the
- * installation, so they are the words most likely to match and the least likely to mean anything.
+ * ⚠️ The status list is not indexed, and neither is a task's own status. "Backlog" and "Done" appear
+ * on every board in the installation, so they are the words most likely to match and the least
+ * likely to mean anything — and in the semantic half they would drag every card of every board
+ * towards every question phrased as a state.
+ *
+ * ⚠️ A task on the `archived` shelf is left out of BOTH halves (anchrd/intel#301). That shelf is
+ * what a board has instead of deleting a card (`ArchivedBoardStatusId`), so it is the same statement
+ * `archived_at` makes about a node one level up — and an archived node has never been searchable.
+ * Answering "where do I stand with X" out of a card somebody swept away is the failure the ticket
+ * names. A card in a `terminal` status is NOT swept: "we finished it" is an answer to where the work
+ * stands, and the only thing that says a card no longer counts is the shelf.
  */
 function boardChunks(content) {
     let parsed;
@@ -33,15 +51,139 @@ function boardChunks(content) {
     catch (error) {
         throw new PermanentIndexingError(`Node version content is not valid JSON: ${error instanceof Error ? error.message : "unknown parse failure"}`);
     }
-    const board = BoardDocument.safeParse(parsed);
+    /**
+     * ⚠️ Upgraded first, exactly like `parseStoredBoard` — this is the SECOND place a stored board
+     * body is parsed, and it reads bodies nobody has rewritten since (anchrd/intel#318).
+     *
+     * `reindex` walks every current version in the installation, so an old board arrives here as it
+     * was written: without `terminal` (#311) or with a repeated `dependsOn`. Without the upgrade the
+     * refusal below is PERMANENT — the version is marked failed and never retried — so that board
+     * would simply stop being findable, quietly, while its screen still worked. A rule added at one
+     * parse site and not the other is how a fix looks complete and is not.
+     */
+    const board = BoardDocument.safeParse(upgradeStoredBoard(parsed));
     if (!board.success) {
         throw new PermanentIndexingError("Node version content is not a valid board document");
     }
-    return board.data.tasks.map((task) => ({
+    return board.data.tasks
+        .filter((task) => task.status !== ArchivedBoardStatusId)
+        .map((task) => ({
+        key: task.id,
         title: task.title,
         text: [task.title, ...task.labels, task.description].filter(Boolean).join("\n\n"),
     }));
 }
+/**
+ * What one chunk is embedded as (anchrd/intel#301).
+ *
+ * The node's title in front of a whole-node chunk, which is the exact string the semantic adapter
+ * used to compose on its own side. It moved here because the fingerprint has to cover what is
+ * embedded and nothing else: a prefix added downstream would sit outside the comparison and change
+ * nothing when it changed. The vector it produces therefore keeps the same name AND the same
+ * content it had before this — an upgrading installation loses no answer, though its first pass
+ * over any node does embed once more, because `node_vectors` starts empty and has no fingerprint to
+ * compare against. That cost is one embedding per node, paid when that node is next saved or when
+ * an administrator runs `reindex`, and never per card.
+ *
+ * ⚠️ A card is NOT prefixed with the board's title. It brings its own title as the first line of its
+ * text already, and the board's would put a value into all three hundred fingerprints that moves
+ * when somebody renames the board — one rename, three hundred embeddings.
+ */
+function embeddedText(target, chunk) {
+    return chunk.key === wholeNodeChunkKey ? `${target.title}\n\n${chunk.text}` : chunk.text;
+}
+/**
+ * The vectors this node needs, minus the ones it already has (anchrd/intel#301).
+ *
+ * ⚠️ This is the answer to "a changed card must not reindex the board". A save writes the whole
+ * document — that is what a board version IS — so without this every keystroke-save of a board with
+ * three hundred cards would cost three hundred embeddings. The fingerprint of the exact text that
+ * was embedded is what tells an untouched card from a changed one.
+ *
+ * ⚠️ The comparison is against D1 and deliberately not against Vectorize. Vectorize writes are
+ * asynchronous — a vector upserted a moment ago is not readable yet — so a check made there would
+ * answer about the save before last and re-embed a board that had just been saved twice.
+ *
+ * ⚠️ The record is written only after the upsert returned, in the caller. A pass that dies in
+ * between leaves the record short, so the next one embeds again; the opposite order would leave a
+ * record claiming a vector nobody ever wrote, and nothing would ever notice.
+ */
+async function replaceVectors(deps, target, chunks) {
+    const semantic = deps.semantic;
+    if (!semantic)
+        return;
+    const stored = await deps.repository.listVectors(target.nodeId);
+    const known = new Map(stored.map((record) => [record.chunkKey, record.fingerprint]));
+    const records = [];
+    const changed = [];
+    for (const chunk of chunks) {
+        const text = embeddedText(target, chunk);
+        const fingerprint = await deps.hash(text);
+        if (known.get(chunk.key) !== fingerprint)
+            changed.push({ key: chunk.key, text });
+        records.push({ chunkKey: chunk.key, fingerprint, passage: chunk.text });
+    }
+    const wanted = new Set(chunks.map((chunk) => chunk.key));
+    const stale = stored.map((record) => record.chunkKey).filter((key) => !wanted.has(key));
+    // ⚠️ The one-time sweep of the vector this node had BEFORE it was chunked. An empty record with a
+    // chunked node means this is the first pass since anchrd/intel#301 (or since `reindex` emptied
+    // the record), and the whole-board vector written under the bare node id is still sitting there —
+    // matching questions and answering with the wrong card's passage. Once a record exists this
+    // branch is never taken again, so it costs one call per board rather than one per save.
+    if (stored.length === 0 && !wanted.has(wholeNodeChunkKey))
+        stale.push(wholeNodeChunkKey);
+    await semantic.upsert(target, changed);
+    if (stale.length > 0)
+        await semantic.remove(target.nodeId, stale);
+    await deps.repository.replaceVectors(target, records);
+}
+/**
+ * Everything an archived node had in the vector index, taken out of it (anchrd/intel#348).
+ *
+ * ⚠️ The ORDER is the whole safety argument, and it is the exact mirror of the one above. There the
+ * record is written last, because a row claiming a vector nobody wrote would make the next pass skip
+ * that card forever. Here the record is DELETED last, because the row is the only thing that knows
+ * what a vector is called: drop it first and the vectors stay in the index under names nothing left
+ * anywhere can produce. A pass that dies in between leaves vectors already gone and a record that
+ * still names them — which costs the next pass one embedding per card and nothing else, because the
+ * queue redelivers this message and the second run asks Vectorize to forget names it has already
+ * forgotten. Both failures are repaired by repeating; neither ends in a wrong answer.
+ *
+ * ⚠️ The bare node id goes with them whether or not it is in the record. That name is the ONE vector
+ * a node can hold without any record of it — everything written before anchrd/intel#301 is filed
+ * under it — and an archived node has no later pass in which the one-time sweep in `replaceVectors`
+ * could find it. The standing cost of that is one `deleteByIds` of a single name on a redelivered
+ * message, which Vectorize answers without complaint for an id it no longer holds.
+ *
+ * ⚠️ `alsoNamed` is what makes this run after a NORMAL pass too, and it closes the one hole a purge
+ * driven from `archive` alone cannot. A pass that has already upserted its vectors when somebody
+ * archives the node writes no record at all — `replaceVectors` refuses on `archived_at IS NULL` —
+ * so those vectors would sit in the index with nothing anywhere able to name them, and no message
+ * left to repair it. The pass knows the names it just wrote, so it hands them over.
+ *
+ * ⚠️ Without a semantic index configured nothing happens at all, `node_vectors` included. The rows
+ * can only have been written while one WAS configured, so a deployment that has temporarily lost the
+ * binding must not take the record away — that would leave the vectors behind it unnameable, which
+ * is the failure this whole function exists to avoid.
+ *
+ * ⚠️ One race is left and it is the harmless direction: a restore that lands between the read below
+ * and the deletion loses the vectors that restore's own pass had just written. The node keeps
+ * answering out of the lexical half — `hydrateVisibleCitations` falls back on the full-text passage
+ * when there is no `node_vectors` row — and the next save or `reindex` puts the vectors back. The
+ * record is gone with them, so nothing claims otherwise in the meantime.
+ */
+async function purgeVectors(deps, versionId, alsoNamed = []) {
+    const semantic = deps.semantic;
+    if (!semantic)
+        return;
+    const nodeId = await deps.repository.archivedNodeId(versionId);
+    if (nodeId === null)
+        return;
+    const recorded = (await deps.repository.listVectors(nodeId)).map((record) => record.chunkKey);
+    const keys = [...new Set([wholeNodeChunkKey, ...recorded, ...alsoNamed])];
+    await semantic.remove(nodeId, keys);
+    await deps.repository.deleteVectors(nodeId);
+}
 async function readCanonical(deps, target) {
     if (target.kind === "attachment") {
         const key = target.contentKeys[0];
@@ -56,8 +198,15 @@ export function createIndexing(deps) {
     return {
         async index(versionId) {
             const target = await deps.repository.getTarget(versionId);
-            if (!target)
+            // ⚠️ No target has meant "nothing to do" since the pass existed, and for a superseded version
+            // it still does. For an ARCHIVED node it never did: its vectors stayed in the index, invisible
+            // because every citation is hydrated through a join on `nodes` — and costing places in a
+            // candidate list that Vectorize caps at 100 for everybody (anchrd/intel#348). `purgeVectors`
+            // is the one that tells the two apart; this call cannot.
+            if (!target) {
+                await purgeVectors(deps, versionId);
                 return;
+            }
             // ⚠️ An agent's body is a definition, not something to read: node IDs, a cron line and a model
             // name (ADR-0005 §4). Indexing it verbatim would fill the index with identifiers and, worse,
             // put them into the passage a searcher is shown — the definition names nodes the searcher may
@@ -65,10 +214,12 @@ export function createIndexing(deps) {
             // the tree being asked. What makes an agent findable is what a person wrote about it, so the
             // text is its description, and the FTS table indexes the title on its own (#139).
             if (target.kind === "agent") {
-                await deps.repository.replace(target, [
-                    { title: target.title, text: target.description ?? "" },
-                ]);
-                await deps.semantic?.replace(target, target.description ?? "");
+                const chunks = [
+                    { key: wholeNodeChunkKey, title: target.title, text: target.description ?? "" },
+                ];
+                await deps.repository.replace(target, chunks);
+                await replaceVectors(deps, target, chunks);
+                await purgeVectors(deps, versionId, writtenKeys(chunks));
                 await deps.repository.markIndexed(versionId, deps.now().toISOString());
                 return;
             }
@@ -89,12 +240,21 @@ export function createIndexing(deps) {
                 if (text === undefined) {
                     throw new PermanentIndexingError(`No document converter is configured for ${target.mediaType}`);
                 }
-                // ⚠️ The semantic index stays per NODE while the lexical one gains a row per task. Vectorize
-                // is keyed by node id (`semantic-index.ts`), so a board would need its own key space there
-                // before it could carry one vector per card — a bigger change than #285, and one nothing
-                // asks for yet: the lexical half is what "find the card" needs today.
-                await deps.repository.replace(target, target.kind === "board" ? boardChunks(text) : [{ title: target.title, text }]);
-                await deps.semantic?.replace(target, text);
+                // Both halves are chunked the same way now (anchrd/intel#301): a board is one passage and
+                // one vector per card, everything else is one of each for the node. The two indexes read the
+                // same list, so they cannot come to disagree about what a board is made of.
+                const chunks = target.kind === "board"
+                    ? boardChunks(text)
+                    : [{ key: wholeNodeChunkKey, title: target.title, text }];
+                await deps.repository.replace(target, chunks);
+                await replaceVectors(deps, target, chunks);
+                // ⚠️ Asked again, at the END of a pass that started on a live node (anchrd/intel#348). The
+                // node may have been archived while this pass was embedding, and then `replaceVectors` above
+                // wrote no record at all — its statements refuse on `archived_at IS NULL`. The vectors are in
+                // the index either way, so without this they would stay there with nothing anywhere able to
+                // name them and no message left to try again: the archive's own pass has an empty record to
+                // read from. One extra `SELECT` per pass buys that, and on a live node it answers null.
+                await purgeVectors(deps, versionId, writtenKeys(chunks));
                 await deps.repository.markIndexed(versionId, deps.now().toISOString());
             }
             catch (error) {

package/dist/indexing/indexing.types.d.ts

@@ -6,5 +6,6 @@ export interface IndexingDeps {
     content: ContentStore;
     semantic?: SemanticIndex | undefined;
     converter?: DocumentConverter | undefined;
+    hash(content: string): Promise<string>;
     now(): Date;
 }