@anchrd/intel-api 0.13.0 → 0.15.0

package/dist/nodes/nodes.js

@@ -1,8 +1,7 @@
-import { AgentDefinition, AgentMediaType, agentReferenceAccepts, BoardDocument, BoardMediaType, TableMediaType, } from "@anchrd/intel-contract";
+import { TableMediaType, } from "@anchrd/intel-contract";
 import { encodeCsv, parseCsv } from "../shared/csv/csv.js";
 import { IntelError } from "../shared/intel-error/intel-error.js";
 import { plainTitle } from "../shared/plain-title/plain-title.js";
-import { createBoard, upgradeStoredBoard } from "./board/board.js";
 import { documentLinkTargets } from "./document-links/document-links.js";
 // ⚠️ The R2 key of a version written before #125 begins `knowledge/`, and it stays that way. A key
 // is stored in `node_versions.content_key` and read back from there; nothing derives one from ids,
@@ -14,16 +13,12 @@ function contentKeyFor(nodeId, versionId) {
 // A verb that cannot apply to a node is neither offered on it nor accepted for it (ADR-0004 §2).
 // The answer lives here rather than in the screen so HTTP, MCP and the UI cannot disagree about it.
 //
-// `execute` is meaningful where something can be run: a folder, because only a folder can hold a
-// flow, and an agent, where it means being allowed to USE it (#139). Reading an agent's definition
-// and being permitted to put it to work are separate questions — the whole reason the verbs are
-// granted independently rather than as a ladder — and an agent is the case that makes the
-// difference obvious: its definition is inspectable by design (ADR-0005 §2), so `read` on it must
-// not imply the right to set it going.
+// `execute` is meaningful where something can be run, and since #390 that is the folder alone —
+// because only a folder can hold a flow. Reading something and being permitted to put it to work
+// stay separate questions, which is the whole reason the verbs are granted independently rather
+// than as a ladder (ADR-0004 §2).
 function applicableVerbs(kind) {
-    return kind === "folder" || kind === "agent"
-        ? ["read", "write", "execute", "share"]
-        : ["read", "write", "share"];
+    return kind === "folder" ? ["read", "write", "execute", "share"] : ["read", "write", "share"];
 }
 // ⚠️ The refusal has to be actionable without becoming a directory of the tree. Whoever holds
 // `share` on one folder must not learn the titles of flows they may not see, so the ones they may
@@ -47,29 +42,6 @@ function asPrincipalActor(principal) {
         return { id: "", email: principal.email };
     return { id: "", email: "" };
 }
-/**
- * A stored definition, parsed rather than trusted — the version boundary the repository rule names
- * (`CLAUDE.md`, "stored Flow graphs read across a version boundary").
- *
- * ⚠️ It fails loudly on purpose. Intel is the only writer of this body, so a definition that does
- * not parse is corruption, not an older shape to be coerced into the current one. Reading it
- * leniently would hand the runtime an agent that has quietly forgotten its references, and the
- * first sign of it would be an agent answering without the knowledge it was given.
- */
-function parseStoredDefinition(body) {
-    let json;
-    try {
-        json = JSON.parse(body);
-    }
-    catch {
-        throw new IntelError(500, "agent_definition_invalid", "Agent definition is not valid JSON");
-    }
-    const parsed = AgentDefinition.safeParse(json);
-    if (!parsed.success) {
-        throw new IntelError(500, "agent_definition_invalid", "Agent definition does not match the contract");
-    }
-    return parsed.data;
-}
 function decodeBase64(value) {
     if (value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
         throw new IntelError(400, "attachment_invalid", "Attachment content is not valid base64");
@@ -82,9 +54,6 @@ function decodeBase64(value) {
     }
 }
 export function createNodes(deps) {
-    // Made here rather than passed in: the board's rules need nothing this service does not already
-    // have, and a caller who could substitute them could substitute the cycle checks with them.
-    const board = createBoard({ id: () => deps.id() });
     function mergeSearchResults(lexical, semantic, semanticScores, limit) {
         const merged = new Map();
         for (const citation of lexical) {
@@ -128,7 +97,7 @@ export function createNodes(deps) {
      * ⚠️ This is the price of appending without reading. Each `append` writes one immutable object
      * holding only the rows it added, so the write is O(new rows) and two concurrent appends cannot
      * overwrite one another — but a read of a table with k appends costs k R2 gets. That is the
-     * trade the ticket asks for by name: the write side is the hot path an agent uses on a schedule,
+     * trade the ticket asks for by name: the write side is the hot path a flow uses on a schedule,
      * the read side is a person opening a grid or one indexing pass. The gets are issued together
      * rather than in a chain so the cost is k requests, not k round trips; compacting old segments
      * into one object is a later ticket, and it can happen without changing anything a caller sees
@@ -313,140 +282,6 @@ export function createNodes(deps) {
             throw new IntelError(400, "table_row_position", `Row position ${outside} is out of range: the table has ${rowCount} row${rowCount === 1 ? "" : "s"}`);
         }
     }
-    async function agentOf(node) {
-        if (node.kind !== "agent") {
-            throw new IntelError(409, "not_an_agent", "This node is not an agent");
-        }
-        // The Application ID rides on every agent read (#182). It is a name and not a credential, so
-        // there is nothing to withhold — and the surface that draws an agent has to be able to say
-        // whether it has a principal at all, because an agent without one runs nothing.
-        const applicationId = await deps.repository.agentApplicationId(node.id);
-        if (node.currentVersionId === null) {
-            return { node, version: null, definition: null, applicationId };
-        }
-        const version = await deps.repository.getVersion(node.currentVersionId);
-        if (!version)
-            throw new IntelError(500, "version_missing", "Current version is missing");
-        const body = await deps.content.get(version.contentKey);
-        if (body === null)
-            throw new IntelError(500, "content_missing", "Version content is missing");
-        return { node, version, definition: parseStoredDefinition(body), applicationId };
-    }
-    /**
-     * Whether every reference names a node its role can actually use (#255).
-     *
-     * ⚠️ Here and not in the screen. The screen offers only what a role accepts, but a definition can
-     * be written straight over the Intel MCP surface — and a `memory` reference pointing at a
-     * document is not a cosmetic mistake: `agent_remember` writes into what it is given, so the agent
-     * would overwrite the document somebody handed it.
-     *
-     * ⚠️ A reference to a node this actor cannot see is left alone, deliberately. Refusing it would
-     * answer "there is a node with that id and it is the wrong kind" to somebody who may not know the
-     * node exists (#41), and accepting it changes nothing: the runtime reads with the AGENT's grants,
-     * and what it may not read it reports as an unavailable reference. What is checked is what the
-     * writer can see, which is exactly what they chose.
-     *
-     * ⚠️ Ids are deduplicated before the reads. The contract allows two hundred references and the
-     * same folder twice; one lookup per row would make a large definition pay for the repetition.
-     */
-    async function checkReferences(actor, definition) {
-        const kinds = new Map();
-        for (const reference of definition.references) {
-            let kind = kinds.get(reference.nodeId);
-            if (kind === undefined) {
-                kind = (await deps.repository.getVisible(actor, reference.nodeId))?.kind ?? null;
-                kinds.set(reference.nodeId, kind);
-            }
-            if (kind !== null && !agentReferenceAccepts(reference.role, kind)) {
-                throw new IntelError(422, "agent_reference_kind_not_allowed", `A ${kind} cannot be used as ${reference.role}`);
-            }
-        }
-    }
-    /**
-     * The one place a caller's asked-for definition becomes the definition Intel stores (D30).
-     *
-     * ⚠️ `delegatedBy` is ADDED here, from the session, and could not have arrived any other way:
-     * `AgentDefinitionInput` has no field for it, so a body naming somebody else is a parse error at
-     * the boundary rather than a value this function has to remember to ignore. Adding it here is
-     * safe in exactly one direction — the writer must prove below that they reach every named server
-     * themselves, so the delegation can only ever move to somebody who already had it.
-     *
-     * ⚠️ The check is a live `tools/list` through the portal, before anything is written. A server the
-     * saver cannot reach is refused BY NAME — a silent drop would leave a person looking at a saved
-     * agent that quietly has one tool fewer than they picked.
-     */
-    async function delegationOf(actor, definition) {
-        const tools = definition.tools;
-        if (!tools)
-            return { ...definition, tools: null };
-        const servers = [...new Set(tools.servers)];
-        if (servers.length === 0) {
-            return { ...definition, tools: { delegatedBy: actor.id, servers: [] } };
-        }
-        const reachable = new Set(await deps.toolServers(actor));
-        const missing = servers.filter((server) => !reachable.has(server));
-        if (missing.length > 0) {
-            throw new IntelError(403, "tool_server_not_delegatable", `You do not reach these MCP servers, so you cannot delegate them: ${missing.join(", ")}`);
-        }
-        return { ...definition, tools: { delegatedBy: actor.id, servers } };
-    }
-    /**
-     * One immutable definition version, written exactly the way a document's content is (ADR-0005 §1).
-     *
-     * ⚠️ R2 object first, version row second, R2 object deleted again if the row does not land — the
-     * same order `save` keeps and for the same reason: an orphaned object is invisible, while a
-     * version row pointing at nothing is an agent that cannot be read at all.
-     *
-     * ⚠️ The body is serialized from the PARSED definition, never from the caller's JSON text. What
-     * is stored is therefore always what the contract accepted, and a field the strict schema refused
-     * cannot reach R2 by riding along in the original string.
-     *
-     * ⚠️ `segment` is `null`, like a document's and unlike a table's (#135): every version here holds
-     * the whole definition, so there is nothing for a snapshot to mark off from what came before it.
-     */
-    async function writeAgentVersion(actor, node, definition, baseVersionId, idempotencyKey) {
-        const body = JSON.stringify(definition);
-        const versionId = deps.id();
-        const contentKey = contentKeyFor(node.id, versionId);
-        const version = {
-            id: versionId,
-            nodeId: node.id,
-            sequence: await nextSequence(node),
-            contentKey,
-            mediaType: AgentMediaType,
-            contentHash: await deps.hash(body),
-            size: new TextEncoder().encode(body).byteLength,
-            segment: null,
-            createdBy: actor.id,
-            createdAt: deps.now().toISOString(),
-        };
-        await deps.content.put(contentKey, body, AgentMediaType);
-        let saved;
-        try {
-            saved = await deps.repository.appendVersion({
-                version,
-                actorId: actor.id,
-                baseVersionId,
-                idempotencyKey,
-                auditId: deps.id(),
-            });
-        }
-        catch (error) {
-            await deps.content.delete(contentKey).catch(() => undefined);
-            throw error;
-        }
-        if (saved === "conflict") {
-            await deps.content.delete(contentKey);
-            throw new IntelError(409, "version_conflict", "A newer version already exists");
-        }
-        await deps.indexing.enqueue(version.id);
-        return {
-            node: await requireVisible(actor, node.id),
-            version,
-            definition,
-            applicationId: await deps.repository.agentApplicationId(node.id),
-        };
-    }
     async function requireTable(actor, nodeId) {
         const node = await requireVisible(actor, nodeId);
         if (node.kind !== "table") {
@@ -457,310 +292,13 @@ export function createNodes(deps) {
         }
         return node;
     }
-    // ── Boards (#285) ──────────────────────────────────────────────────────────────────────────────
-    // How often one task operation may meet a board that moved under it before it gives up. Every
-    // round is a fresh read and the SAME operation applied again — see `applyToBoard` for why that is
-    // the point rather than a retry loop hiding a race.
-    const boardWriteAttempts = 5;
-    function parseStoredBoard(body) {
-        let parsed;
-        try {
-            parsed = JSON.parse(body);
-        }
-        catch {
-            throw new IntelError(500, "board_unreadable", "The stored board cannot be read");
-        }
-        // ⚠️ Upgraded BEFORE validation, not after. `terminal` is required now (anchrd/intel#311), and
-        // this parse is deliberately loud — so a board written before the flag existed would answer
-        // `board_unreadable` rather than "old", and every board in every installation would break on
-        // deploy. `upgradeStoredBoard` fills only what is missing; the next write persists it.
-        const document = BoardDocument.safeParse(upgradeStoredBoard(parsed));
-        // ⚠️ Loud, unlike the tolerant read the share warning makes of an agent definition. A board IS
-        // its document: answering with an empty one would show somebody a board with no tasks on it,
-        // and the next write would store that as the truth.
-        if (!document.success) {
-            throw new IntelError(500, "board_unreadable", "The stored board cannot be read");
-        }
-        return document.data;
-    }
-    /**
-     * The board a node currently holds.
-     *
-     * ⚠️ A board with no version yet answers with the DEFAULTS rather than with nothing (#285). A
-     * fresh board already has its five columns — the same way a fresh table answers with no header
-     * instead of refusing — and the first write is what puts them into R2. Nothing has to be created
-     * twice for a board to be usable the moment it exists.
-     */
-    async function boardDocumentOf(node) {
-        if (node.currentVersionId === null)
-            return board.defaultBoard();
-        const version = await deps.repository.getVersion(node.currentVersionId);
-        if (!version)
-            throw new IntelError(500, "version_missing", "Current version is missing");
-        const body = await deps.content.get(version.contentKey);
-        if (body === null)
-            throw new IntelError(500, "content_missing", "Version content is missing");
-        return parseStoredBoard(body);
-    }
-    async function requireBoard(actor, nodeId) {
-        const node = await requireVisible(actor, nodeId);
-        if (node.kind !== "board") {
-            throw new IntelError(409, "not_a_board", "Only boards accept task operations");
-        }
-        if (!(await deps.repository.can(actor, node.id, "write"))) {
-            throw new IntelError(403, "node_forbidden", "Board cannot be edited");
-        }
-        return node;
-    }
-    /**
-     * What a task points at outside its own board, checked before anything is written (#285).
-     *
-     * ⚠️ Here rather than in `board.ts`, because both questions are reads against the tree and its
-     * ACL, and the board module is deliberately pure. A reference is refused when this actor cannot
-     * see it — with one wording for "there is no such node" and "you may not see it", because telling
-     * them apart would confirm the existence of a node somebody has no access to (#41).
-     */
-    async function checkBoardTargets(actor, task) {
-        const references = [...new Set(task.references)];
-        if (references.length > 0) {
-            const visible = new Set((await deps.repository.resolveVisibleTitles(actor, references)).map((entry) => entry.nodeId));
-            const missing = references.filter((reference) => !visible.has(reference));
-            if (missing.length > 0) {
-                throw new IntelError(422, "board_reference_unknown", `A reference has to name a node you can see, and ${missing.length === 1 ? "one does" : `${missing.length} do`} not`);
-            }
-        }
-        if (task.assignee?.type === "agent") {
-            const assignee = await deps.repository.getVisible(actor, task.assignee.nodeId);
-            if (assignee?.kind !== "agent") {
-                throw new IntelError(422, "board_assignee_unknown", "An agent assignee has to name an agent you can see");
-            }
-        }
-    }
-    /**
-     * One new board version, or `null` when somebody wrote in between.
-     *
-     * ⚠️ `segment` is `null`, like a document's and unlike a table's (#135): every version here holds
-     * the whole board, so there is nothing for a snapshot to mark off from what came before it.
-     *
-     * ⚠️ `baseVersionId` is the version this service just read, never one a caller sent. It is the
-     * board's optimistic lock and it is entirely internal — see `applyToBoard`.
-     *
-     * ⚠️ The R2 object is written before the version row and deleted again if the row does not land,
-     * the same order `save` keeps: an orphaned object is invisible, while a version row pointing at
-     * nothing is a board that cannot be read at all.
-     */
-    async function writeBoardVersion(input) {
-        const body = JSON.stringify(input.document);
-        const versionId = deps.id();
-        const contentKey = contentKeyFor(input.node.id, versionId);
-        const version = {
-            id: versionId,
-            nodeId: input.node.id,
-            sequence: await nextSequence(input.node),
-            contentKey,
-            mediaType: BoardMediaType,
-            contentHash: await deps.hash(body),
-            size: new TextEncoder().encode(body).byteLength,
-            segment: null,
-            createdBy: input.actor.id,
-            createdAt: deps.now().toISOString(),
-        };
-        await deps.content.put(contentKey, body, BoardMediaType);
-        let saved;
-        try {
-            saved = await deps.repository.appendSnapshotVersion({
-                version,
-                actorId: input.actor.id,
-                baseVersionId: input.node.currentVersionId,
-                operation: input.operation,
-                metadata: input.metadata,
-                idempotencyKey: input.idempotencyKey,
-                auditId: deps.id(),
-            });
-        }
-        catch (error) {
-            await deps.content.delete(contentKey).catch(() => undefined);
-            // ⚠️ The same key at the same moment, from the caller's own retry. `idempotency_keys` is keyed
-            // by (actor, operation, key), so the second write's row collides and D1 rolls the whole batch
-            // back — which is the right outcome and the wrong error. The first write owns the act; this
-            // one reports a conflict so the caller answers with it, exactly as `appendTableVersion` does
-            // one layer down. Anything else is a real failure and still raises.
-            const owned = await deps.repository.findIdempotentNode(input.actor.id, input.operation, input.idempotencyKey);
-            if (owned === null)
-                throw error;
-            return null;
-        }
-        if (saved === "conflict") {
-            await deps.content.delete(contentKey);
-            return null;
-        }
-        // A board's `references` are links in the graph exactly like a document's inline ones, so the
-        // same reconciliation runs on the same body (#285, #41).
-        await reconcileTextLinks(input.actor, input.node.id, BoardMediaType, body);
-        await deps.indexing.enqueue(version.id);
-        return version;
-    }
-    /**
-     * One task operation, applied to the board and written as its next version (#285).
-     *
-     * ⚠️ THIS is why a board has no `baseVersionId` on its inputs. The caller names a task id; the
-     * service reads the current board, applies the change to THAT document and writes it against the
-     * version it read. When somebody else landed a write in between, the insert refuses, and the
-     * answer is not `version_conflict` but another round: read again, apply the same change to the
-     * board as it now stands, write again. Two agents moving two different cards therefore both get
-     * through, which is the whole difference to a table's positions (`TableRowPosition`) — those
-     * cannot survive a rewrite, a task id can.
-     *
-     * ⚠️ Bounded, and the bound is not decoration. A board somebody is hammering must eventually
-     * answer rather than loop; after `boardWriteAttempts` rounds the caller hears the same
-     * `version_conflict` any other contended write gives them.
-     *
-     * ⚠️ A replayed key answers out of the version it wrote AND the audit metadata beside it. The
-     * document alone cannot say which task an operation touched or how many a delete removed — it is
-     * the state after the write, and a deleted subtree is not in it.
-     */
-    async function applyToBoard(actor, input, operation, apply) {
-        let node = await requireBoard(actor, input.nodeId);
-        const replayed = await replayedBoardWrite(actor, node, operation, input.idempotencyKey);
-        if (replayed)
-            return replayed;
-        for (let attempt = 0; attempt < boardWriteAttempts; attempt += 1) {
-            const applied = apply(await boardDocumentOf(node));
-            const version = await writeBoardVersion({
-                actor,
-                node,
-                document: applied.document,
-                metadata: applied.metadata,
-                operation,
-                idempotencyKey: input.idempotencyKey,
-            });
-            if (version !== null) {
-                return {
-                    node: await requireVisible(actor, node.id),
-                    version,
-                    document: applied.document,
-                    metadata: applied.metadata,
-                };
-            }
-            node = await requireVisible(actor, input.nodeId);
-            /**
-             * ⚠️ Asked again after EVERY refused round, not only before the first (#285).
-             *
-             * A conflict says "somebody wrote in between" and usually that somebody was working on
-             * another task — retrying is then exactly right. But it can also have been this very call,
-             * arriving twice: a double click, or a client that retried before the first answer came back.
-             * Retrying THAT blindly would re-use an idempotency key the winning write already owns, and
-             * the second attempt would die on the primary key of `idempotency_keys` — an internal error
-             * where the caller was promised a replay. So the key is asked again first, and if it is spent
-             * the answer is the write that owns it.
-             */
-            const raced = await replayedBoardWrite(actor, node, operation, input.idempotencyKey);
-            if (raced)
-                return raced;
-        }
-        throw new IntelError(409, "version_conflict", "This board is being written to too quickly");
-    }
-    // The write this key already made, or `null` while it is unspent. The version, the document it
-    // holds and the metadata beside it — all three, or nothing: a half-readable replay would answer
-    // with a task the caller never got.
-    async function replayedBoardWrite(actor, node, operation, idempotencyKey) {
-        const replayedId = await deps.repository.findIdempotentNode(actor.id, operation, idempotencyKey);
-        if (replayedId === null)
-            return null;
-        const version = await deps.repository.getVersion(replayedId);
-        if (!version)
-            return null;
-        const metadata = await deps.repository.findSnapshotMetadata(actor.id, operation, idempotencyKey);
-        if (!metadata)
-            return null;
-        const body = await deps.content.get(version.contentKey);
-        if (body === null)
-            return null;
-        return { node, version, document: parseStoredBoard(body), metadata };
-    }
-    // The task an operation reports, read back out of the version it wrote. The id comes from the
-    // audit metadata, so a replay answers with exactly the task the first attempt created.
-    function writtenTask(written) {
-        const taskId = written.metadata.taskId;
-        const task = typeof taskId === "string"
-            ? written.document.tasks.find((candidate) => candidate.id === taskId)
-            : undefined;
-        if (!task)
-            throw new IntelError(500, "board_unreadable", "The written task cannot be read back");
-        return task;
-    }
-    /**
-     * What the grant just written does not cover: the documents the flows in this folder read that
-     * the new principal still cannot.
-     *
-     * ⚠️ It warns and never blocks. A node reference across the folder edge is a possible
-     * failure, not a way around permissions — that distinction is the whole of ADR-0004 §4, and a
-     * block here would force everyone using one central policy document to duplicate it.
-     *
-     * ⚠️ Which documents may be named is `getVisible`, the lookup every other node read goes
-     * through, and never a second rule written for a message: the ones this actor may see are named,
-     * the rest are counted. That is exactly where #17 and #19 went wrong in review.
-     *
-     * The flow side is filtered by the flow list's own predicate as well. It changes nothing today —
-     * sharing needs `read` on the folder and `read` inherits over the whole subtree, so every flow in
-     * it is already visible — but the verbs are independent by decision (ADR-0004 §2), and the day
-     * `share` stops implying `read` this must not be the place that quietly starts leaking.
-     *
-     * It does say one thing about the grantee: that a named document is not readable for them. That
-     * is the consequence of this actor's own decision, on their own folder, at the moment they make
-     * it, and it is the smallest answer that lets them make it — the alternative is the flow failing
-     * for someone else next week with nobody able to say why. It never enumerates the principal's
-     * access in general and never leaves the documents these flows actually name.
-     */
-    /**
-     * The nodes the agents in this folder's subtree name in their definitions (#139, ADR-0005 §2).
-     *
-     * ⚠️ Read from R2 and parsed, because an agent's references live in its definition body and not
-     * in D1 — unlike a flow's, which sit in `flow_versions.graph_json` and can be matched in SQL.
-     * There is no query that can answer this, and writing one against a guessed JSON shape is exactly
-     * how the flow side came to match a graph that migration 0008 had already abolished
-     * (anchrd/intel#153): the query kept returning nothing and the warning silently stopped arriving.
-     * Parsing the real contract schema is what makes this one fail loudly instead of quietly.
-     *
-     * ⚠️ A definition that will not parse is SKIPPED rather than thrown — the opposite of the read
-     * path above, deliberately. This runs while somebody is sharing a folder, and a warning that
-     * raises would turn one broken agent into a folder nobody can share. The read path is where a
-     * corrupt definition has to be loud; here the cost of loudness is paid by the wrong person.
-     */
-    async function agentNodeReferences(actor, folderId) {
-        const keys = await deps.repository.listVisibleAgentDefinitionKeys(actor, folderId);
-        const referenced = [];
-        for (const key of keys) {
-            const body = await deps.content.get(key);
-            if (body === null)
-                continue;
-            try {
-                const parsed = AgentDefinition.safeParse(JSON.parse(body));
-                if (!parsed.success)
-                    continue;
-                for (const reference of parsed.data.references)
-                    referenced.push(reference.nodeId);
-            }
-            catch {
-                // Unparsable JSON is skipped for the reason above: this runs inside a share, and one
-                // broken agent must not be able to make a folder unshareable.
-            }
-        }
-        return referenced;
-    }
     async function unreadableForPrincipal(actor, folderId, principal) {
         const grantee = asPrincipalActor(principal);
         const titles = [];
         let hidden = 0;
-        // Flows and agents reach for material the same way and the grant covers neither, so they are
-        // one list. Deduplicated, because a document that is both a flow's input and an agent's system
-        // message is one thing the new principal cannot read, not two.
-        const referenced = [
-            ...new Set([
-                ...(await deps.flowNodeReferences(actor, folderId)),
-                ...(await agentNodeReferences(actor, folderId)),
-            ]),
-        ];
+        // What a flow reaches for and the grant does not cover. Deduplicated, because a document two
+        // flows both name is one thing the new principal cannot read, not two.
+        const referenced = [...new Set(await deps.flowNodeReferences(actor, folderId))];
         for (const resourceId of referenced) {
             if (await deps.repository.can(grantee, resourceId, "read"))
                 continue;
@@ -884,12 +422,6 @@ export function createNodes(deps) {
             return (await deps.repository.can(actor, folder.id, "write")) ? "ok" : "forbidden";
         },
         async create(actor, input) {
-            // The generic path can file an agent row too — one without a definition or a principal — so
-            // the #190 gate stands here as well. Only where no runtime exists: with one, this path stays
-            // exactly as it was, which is part of the same ticket.
-            if (input.kind === "agent" && !deps.agentRuntimeAvailable()) {
-                throw new IntelError(503, "agent_runtime_not_configured", "This installation has no agent runtime, so agents cannot be created");
-            }
             const existingId = await deps.repository.findIdempotentNode(actor.id, "node.create", input.idempotencyKey);
             if (existingId)
                 return await requireVisible(actor, existingId);
@@ -974,230 +506,6 @@ export function createNodes(deps) {
             await deps.indexing.enqueue(version.id);
             return { node: updated, version, content: input.content };
         },
-        async getAgent(actor, input) {
-            return await agentOf(await requireVisible(actor, input.nodeId));
-        },
-        async listAgents(actor, input) {
-            return { items: await deps.repository.listVisibleAgents(actor, input) };
-        },
-        /**
-         * The Gate Application, the node, and its first definition, in that order.
-         *
-         * ⚠️ Two writes behind one call, so the replay has to be answered for both. The node
-         * carries the caller's key under `node.create`; the definition carries a derived one under
-         * `node.save`, because the two operations share an idempotency table and the same key twice
-         * would make the second write look like a replay of the first. A caller who repeats the
-         * request gets the agent that already exists rather than a second one beside it.
-         *
-         * ⚠️ A REPLAY MAKES NO SECOND APPLICATION. It still returns the agent that exists — that promise
-         * is not weakened — but a repeat that minted a fresh principal would leave the installation with
-         * two machine accounts for one agent, one of which nobody would ever switch off, and would
-         * replace a working agent's key with one it never asked for. Gate is not asked at all on that
-         * path, and no key travels either. What a replay DOES do is arm the agent's schedules again
-         * (#214) — that is idempotent, and it is the repair for a create whose arming failed.
-         *
-         * ⚠️ Gate is asked BEFORE anything is written, and that ordering IS the answer to "what if Gate
-         * is down". Nothing exists yet at that moment, so a Gate that does not answer leaves no node, no
-         * version, no R2 object and no audit event — the agent simply does not come into being, and the
-         * caller repeats the request. The alternative, a node that exists without a principal plus a
-         * way to fill it in later, buys nothing: such an agent starts no run (`agent_key_missing` in the
-         * runtime), so it would be a broken row waiting for a second, easily forgotten step — and
-         * "somebody must remember to do it in Gate" is the exact chore this ticket removes.
-         *
-         * ⚠️ If the node write fails after Gate succeeded, the fresh Application is switched off again,
-         * best effort. A live principal nobody references is precisely the invisible access #182 exists
-         * to prevent, and disabling rather than deleting keeps the compensation consistent with what
-         * archiving does — Gate's `DELETE` would take the identity with it (`anchrd/gate#224`).
-         */
-        async createAgent(actor, input, caller) {
-            // Before anything else — before the idempotency read, before Gate (#190). An installation
-            // without a runtime refuses the agent by name, and the refusal costs no storage read, mints
-            // no principal, and is the same on every surface because it lives here.
-            if (!deps.agentRuntimeAvailable()) {
-                throw new IntelError(503, "agent_runtime_not_configured", "This installation has no agent runtime, so agents cannot be created");
-            }
-            const definitionKey = `${input.idempotencyKey}:definition`;
-            const existingId = await deps.repository.findIdempotentNode(actor.id, "node.create", input.idempotencyKey);
-            if (existingId) {
-                const existing = await agentOf(await requireVisible(actor, existingId));
-                // ⚠️ A replay arms as well, and that is what makes a create whose sync failed repairable
-                // (#214): repeating it with the same key mints nothing, returns this agent, and puts its
-                // alarm right. Without it the only repair left would be a fresh key — a second agent.
-                if ((existing.definition?.schedules.length ?? 0) > 0) {
-                    await deps.agentSchedules.sync({ token: caller.token, agentId: existing.node.id });
-                }
-                return existing;
-            }
-            if (input.parentId !== null && !(await deps.repository.can(actor, input.parentId, "write"))) {
-                throw new IntelError(403, "node_forbidden", "Parent folder cannot be edited");
-            }
-            // Before Gate, for the same reason the runtime check is before Gate: a delegation the saver
-            // cannot back — or a reference no role can use (#255) — must not leave a machine principal
-            // behind for an agent that was never created.
-            await checkReferences(actor, input.definition);
-            const definition = await delegationOf(actor, input.definition);
-            const nodeId = deps.id();
-            // One title for both, and it is the unescaped one: Gate's name is minted before the node row
-            // and can never be brought back into line with it afterwards (#202).
-            const title = plainTitle(input.title);
-            // The Application's name is what a person reads in Gate's list, so it has to be enough to
-            // recognise the agent by. Title alone would leave two agents called "Research" indis-
-            // tinguishable; the node ID is what the runtime's key map is keyed by anyway.
-            const application = await deps.applications.create({
-                token: caller.token,
-                name: `Intel agent ${title} (${nodeId})`,
-            });
-            // ⚠️ The handover happens BEFORE the node is written, for the same reason Gate is asked before
-            // it: at this moment nothing exists on Intel's side, so a runtime that does not take the key
-            // leaves no node, no version, no R2 object and no audit event — the agent simply does not come
-            // into being and the caller repeats the request. The other order would produce exactly the
-            // agent #200 is about: a node that looks finished and dies at its first run. What it can leave
-            // behind is a Durable Object holding a key for a node id that will never exist, which is
-            // ciphertext nobody can address — ULIDs are not reused.
-            try {
-                await deps.agentKeys.store({ token: caller.token, agentId: nodeId, key: application.key });
-            }
-            catch (error) {
-                await deps.applications
-                    .setEnabled({ token: caller.token, applicationId: application.id, enabled: false })
-                    .catch(() => undefined);
-                throw error;
-            }
-            const timestamp = deps.now().toISOString();
-            let node;
-            try {
-                node = await deps.repository.insertNode({
-                    node: {
-                        id: nodeId,
-                        parentId: input.parentId,
-                        kind: "agent",
-                        title,
-                        description: input.description,
-                        ownerId: actor.id,
-                        currentVersionId: null,
-                        createdAt: timestamp,
-                        updatedAt: timestamp,
-                        archivedAt: null,
-                    },
-                    actorId: actor.id,
-                    idempotencyKey: input.idempotencyKey,
-                    auditId: deps.id(),
-                    application: { id: application.id },
-                });
-            }
-            catch (error) {
-                await deps.applications
-                    .setEnabled({ token: caller.token, applicationId: application.id, enabled: false })
-                    .catch(() => undefined);
-                throw error;
-            }
-            // ⚠️ No key in the answer, and no field one could travel in (D29). `application.key` has been
-            // in one local variable since Gate returned it, went into the runtime, and is out of reach of
-            // every surface above this line.
-            const created = (await writeAgentVersion(actor, node, definition, null, definitionKey));
-            /**
-             * ⚠️ Only when this definition actually schedules something — unlike the save below, which
-             * arms unconditionally. A brand-new agent has no earlier definition, so there is no alarm that
-             * could be left standing: no schedules means there is nothing to arm and nothing to clear, and
-             * the screen creates every agent that way (the profile is where schedules are added).
-             *
-             * ⚠️ It fails loudly, and the agent stays. Everything is written by now and nothing here can
-             * roll an agent back, so the caller is told the one thing they can act on: the schedules are
-             * not armed. The repair is repeating the create with the SAME idempotency key — which returns
-             * this agent, mints no second Application, and arms it. A fresh key would create a second
-             * agent beside this one, which is why the message says "again" and not "retry".
-             */
-            if (definition.schedules.length > 0) {
-                await deps.agentSchedules.sync({ token: caller.token, agentId: node.id });
-            }
-            return created;
-        },
-        /**
-         * A new key for the Application this agent runs as, handed straight to the runtime (D29, #207).
-         *
-         * ⚠️ A write on the agent node, not a run: `knowledge/write` at the door and the resource ACL
-         * here. Whoever may change what an agent does may change which key it does it with; being
-         * allowed to press "Run now" says nothing about being allowed to decide its principal.
-         *
-         * ⚠️ Gate first, runtime second, and nothing in between. Gate issues the replacement before it
-         * revokes the old one, so a rotation that fails at Gate changes nothing at all; one that fails
-         * at the handover leaves the agent with a key it no longer has — named, repairable, and fixed by
-         * rotating again. The alternative order cannot exist: the runtime has nothing to store until
-         * Gate has answered.
-         *
-         * ⚠️ The key is in one local variable and in no answer. This is the operation that exists BECAUSE
-         * Gate hands a key out exactly once — reading one back is not something any repair can do.
-         */
-        async rotateAgentKey(actor, input, caller) {
-            const node = await requireVisible(actor, input.nodeId);
-            if (node.kind !== "agent") {
-                throw new IntelError(409, "not_an_agent", "Only agents have an application key");
-            }
-            if (!(await deps.repository.can(actor, node.id, "write"))) {
-                throw new IntelError(403, "node_forbidden", "This agent cannot be edited");
-            }
-            if (!deps.agentRuntimeAvailable()) {
-                throw new IntelError(503, "agent_runtime_not_configured", "This installation has no agent runtime, so there is nothing to give a key to");
-            }
-            const applicationId = await deps.repository.agentApplicationId(node.id);
-            if (applicationId === null) {
-                // An agent written before #182, restored from a bundle, or imported. Giving it a principal
-                // is an act in Gate, and inventing one here would make Intel the author of a machine
-                // account nobody asked for.
-                throw new IntelError(409, "agent_application_missing", "This agent has no Gate application, so there is no key to replace");
-            }
-            const rotated = await deps.applications.rotateKey({ token: caller.token, applicationId });
-            await deps.agentKeys.store({ token: caller.token, agentId: node.id, key: rotated.key });
-            const rotatedAt = deps.now().toISOString();
-            // ⚠️ Written LAST, and only once both sides took the change. An event ahead of the runtime
-            // would record a rotation that may not have arrived, and this row is the only trace the act
-            // leaves in Intel — nothing about the node itself changes, so a reader who diffed versions
-            // would see an agent that silently began acting with a different credential.
-            await deps.repository.recordAgentKeyRotation({
-                auditId: deps.id(),
-                actorId: actor.id,
-                nodeId: node.id,
-                applicationId,
-                occurredAt: rotatedAt,
-            });
-            return { nodeId: node.id, applicationId, rotatedAt };
-        },
-        /**
-         * A new definition version, and the alarm that has to match it (#214).
-         *
-         * ⚠️ The runtime is told to re-arm after EVERY definition write, not only after one that names a
-         * schedule. The alternative — comparing against the definition that was there before — needs the
-         * previous document read back out of R2, and it is wrong in exactly the direction that matters:
-         * a save that removes the LAST schedule has nothing to compare against in the new definition and
-         * is precisely the write that has to clear the alarm. One binding call per save buys the rule
-         * "what is written is what is armed" without a comparison anybody could get backwards.
-         *
-         * ⚠️ Written first, armed second, and the definition STAYS when the arming fails. It has to: the
-         * runtime reads the definition back out of Intel to arm it, so there is no order in which it
-         * could be armed before it exists. What the caller gets instead of silence is
-         * `agent_schedules_not_armed` — the version is in the history, the profile shows it, and saving
-         * again arms it. Rolling the version back would be worse than the unarmed alarm: it would throw
-         * away an edit somebody made because a Worker was briefly unreachable.
-         */
-        async saveAgentDefinition(actor, input, caller) {
-            const existingId = await deps.repository.findIdempotentNode(actor.id, "node.save", input.idempotencyKey);
-            if (existingId)
-                return await agentOf(await requireVisible(actor, input.nodeId));
-            const node = await requireVisible(actor, input.nodeId);
-            if (node.kind !== "agent") {
-                throw new IntelError(409, "not_an_agent", "Only agents accept a definition");
-            }
-            if (!(await deps.repository.can(actor, node.id, "write"))) {
-                throw new IntelError(403, "node_forbidden", "This agent cannot be edited");
-            }
-            if (node.currentVersionId !== input.baseVersionId) {
-                throw new IntelError(409, "version_conflict", "A newer version already exists");
-            }
-            await checkReferences(actor, input.definition);
-            const saved = await writeAgentVersion(actor, node, await delegationOf(actor, input.definition), input.baseVersionId, input.idempotencyKey);
-            await deps.agentSchedules.sync({ token: caller.token, agentId: node.id });
-            return saved;
-        },
         async saveAttachment(actor, input) {
             const existingId = await deps.repository.findIdempotentNode(actor.id, "node.save", input.idempotencyKey);
             if (existingId) {
@@ -1436,80 +744,6 @@ export function createNodes(deps) {
             });
             return await tableOf(await requireVisible(actor, node.id));
         },
-        /**
-         * The board, as one document (#285).
-         *
-         * ⚠️ `read` and not `write`: seeing a board is the ordinary node read, and `requireBoard` — with
-         * its `write` check — is for the five operations that change it. A board nobody may edit is
-         * still a board they may look at.
-         */
-        async getBoard(actor, input) {
-            const node = await requireVisible(actor, input.nodeId);
-            if (node.kind !== "board") {
-                throw new IntelError(404, "board_not_found", "Board was not found");
-            }
-            return { node, board: await boardDocumentOf(node), versionId: node.currentVersionId };
-        },
-        async configureBoard(actor, input) {
-            const written = await applyToBoard(actor, input, "node.board_configure", (document) => ({
-                document: board.configure(document, input.statuses),
-                // The ids and not the labels: audit is metadata, and a label is text somebody wrote.
-                metadata: { statuses: input.statuses.map((status) => status.id) },
-            }));
-            return { node: written.node, version: written.version, statuses: written.document.statuses };
-        },
-        async addBoardTask(actor, input) {
-            // Before the document is touched at all: a task that names a node nobody can see is refused
-            // rather than stored, and the refusal costs no write (#285).
-            await checkBoardTargets(actor, { references: input.references, assignee: input.assignee });
-            const written = await applyToBoard(actor, input, "node.board_task_add", (document) => {
-                const added = board.addTask(document, input);
-                return { document: added.board, metadata: { taskId: added.task.id } };
-            });
-            return { node: written.node, version: written.version, task: writtenTask(written) };
-        },
-        async updateBoardTask(actor, input) {
-            await checkBoardTargets(actor, {
-                references: input.references ?? [],
-                assignee: input.assignee ?? null,
-            });
-            const written = await applyToBoard(actor, input, "node.board_task_update", (document) => {
-                const updated = board.updateTask(document, input);
-                return { document: updated.board, metadata: { taskId: updated.task.id } };
-            });
-            return { node: written.node, version: written.version, task: writtenTask(written) };
-        },
-        async moveBoardTask(actor, input) {
-            const written = await applyToBoard(actor, input, "node.board_task_move", (document) => {
-                const moved = board.moveTask(document, input);
-                return {
-                    document: moved.board,
-                    metadata: { taskId: moved.task.id, status: moved.task.status },
-                };
-            });
-            return { node: written.node, version: written.version, task: writtenTask(written) };
-        },
-        /**
-         * A task and everything under it (#285).
-         *
-         * ⚠️ The count is read back out of the write's own metadata rather than recomputed. A replay
-         * has to answer with what the first attempt actually removed, and by then the descendants are
-         * no longer in the document to be counted.
-         */
-        async deleteBoardTask(actor, input) {
-            const written = await applyToBoard(actor, input, "node.board_task_delete", (document) => {
-                const removed = board.deleteTask(document, input.taskId);
-                return {
-                    document: removed.board,
-                    metadata: { taskId: input.taskId, deleted: removed.deleted },
-                };
-            });
-            const deleted = written.metadata.deleted;
-            if (typeof deleted !== "number") {
-                throw new IntelError(500, "board_unreadable", "The delete did not record what it removed");
-            }
-            return { node: written.node, version: written.version, deleted };
-        },
         async listVersions(actor, nodeId) {
             await requireVisible(actor, nodeId);
             return { items: await deps.repository.listVersions(nodeId) };
@@ -1559,28 +793,18 @@ export function createNodes(deps) {
             return updated;
         },
         /**
-         * Archiving and restoring — and for an agent, its Gate Application with it (#182).
-         *
-         * ⚠️ Gate is switched BEFORE the node row, and the order is the whole safety argument. The state
-         * that must not exist is "archived agent, live principal": a machine account that still holds
-         * every grant the agent had, on a node nobody looks at any more. Writing the row first and then
-         * failing at Gate produces exactly that. The reverse leaves "live agent, switched-off
-         * principal" — the agent refuses its next run by name (`agent_principal_rejected` in the
-         * runtime), which somebody notices the same day and which repeating the call repairs.
+         * Archiving and restoring.
          *
-         * ⚠️ The optimistic check is made twice on purpose: cheaply here so a stale `baseUpdatedAt`
-         * never reaches Gate, and authoritatively in the statement that writes. Only a genuine race
-         * gets past the first, and that path puts Gate back the way it was before refusing.
+         * ⚠️ Nothing in this repository removes a `nodes` row — `archived_at` is what "delete" means
+         * here, which is why a restore is the same call with `archived: false` and why both directions
+         * go through the indexing queue below.
          *
-         * ⚠️ Gate is asked even when the node is already in the requested state. Both routes are
-         * idempotent there, and it is what makes a repeated call heal a run that died between the two
-         * writes — the alternative would be an agent stuck live because its node already said archived.
-         *
-         * ⚠️ Nothing here is skipped for an agent WITHOUT an Application. There is no principal to
-         * switch, Gate is not called, and the node archives like a document — the case of an agent
-         * imported, restored from a bundle, or written before #182.
+         * ⚠️ Until #390 this also switched an agent's Gate Application off with the node, and the ORDER
+         * of the two writes was the whole safety argument. With the agents parked there is no second
+         * system to keep in step, and `caller` survives only because `archive` is still the one node
+         * mutation a surface hands its bearer to.
          */
-        async archive(actor, input, caller) {
+        async archive(actor, input, _caller) {
             const current = await requireVisible(actor, input.nodeId);
             if (!(await deps.repository.can(actor, current.id, "write"))) {
                 throw new IntelError(403, "node_forbidden", "This node cannot be edited");
@@ -1590,17 +814,6 @@ export function createNodes(deps) {
             // about a request that is not happening.
             if (replayedId)
                 return await requireVisible(actor, replayedId);
-            const applicationId = current.kind === "agent" ? await deps.repository.agentApplicationId(current.id) : null;
-            if (applicationId !== null) {
-                if (current.updatedAt !== input.baseUpdatedAt) {
-                    throw new IntelError(409, "update_conflict", "This node was changed by another editor");
-                }
-                await deps.applications.setEnabled({
-                    token: caller.token,
-                    applicationId,
-                    enabled: !input.archived,
-                });
-            }
             const updatedAt = deps.now().toISOString();
             const updated = await deps.repository.archiveNode({
                 nodeId: current.id,
@@ -1612,19 +825,28 @@ export function createNodes(deps) {
                 auditId: deps.id(),
             });
             if (updated === "conflict") {
-                if (applicationId !== null) {
-                    // Back to what the node actually said, not to the inverse of what was asked: repeating an
-                    // archive on an already archived agent would otherwise switch its principal back ON.
-                    await deps.applications
-                        .setEnabled({
-                        token: caller.token,
-                        applicationId,
-                        enabled: current.archivedAt === null,
-                    })
-                        .catch(() => undefined);
-                }
                 throw new IntelError(409, "update_conflict", "This node was changed by another editor");
             }
+            /**
+             * ⚠️ Both directions, through the same queue every save goes through (anchrd/intel#348). The
+             * pass reads the node's state and does the matching thing: an archived node has its vectors
+             * taken out of the index, a restored one is embedded again from a record that was emptied when
+             * it went. Two calls to one door rather than a purge written out here, because Vectorize is a
+             * second system and a call into it can fail — the queue is the only thing in this repository
+             * that comes back for it, and a deletion nobody retries is a deletion that quietly did not
+             * happen.
+             *
+             * ⚠️ The full-text half is deliberately NOT emptied on the way in, and the asymmetry is the
+             * point rather than an oversight: an FTS row costs storage and is already invisible (every
+             * read joins `nodes` and drops what is archived), while a vector costs a place in a candidate
+             * list Vectorize caps at 100 for the whole installation. An archived node pays with
+             * somebody else's search results.
+             *
+             * A replayed archive never reaches this line — it returned above, on the idempotency key — so
+             * repeating the same call does not ask the index to forget the same names twice.
+             */
+            if (updated.currentVersionId)
+                await deps.indexing.enqueue(updated.currentVersionId);
             return updated;
         },
         async listGrants(actor, resourceId) {
@@ -1772,18 +994,50 @@ export function createNodes(deps) {
             if (!deps.semantic)
                 return { items: lexical.slice(0, input.limit) };
             try {
-                // ⚠️ The scope narrows the vector hits afterwards, in the same D1 statement that already
-                // re-checks the ACL — so the candidate set has to be wide enough for that cut to leave
-                // something. A folder holding a dozen documents inside a tree of thousands is not reached by
-                // the fan-out an unscoped search gets away with, and a starved scope looks like an empty
-                // folder. 100 is what the port clamps to, so a scoped search asks for all there is.
-                const candidates = input.scopeId === undefined ? Math.min(100, input.limit * 4) : 100;
+                /**
+                 * Every candidate Vectorize will give for one query, scoped or not (anchrd/intel#348).
+                 *
+                 * ⚠️ A candidate is a CARD since anchrd/intel#301, not a node, so a busy board can take a
+                 * large share of these places and push other nodes out before this code ever sees them —
+                 * the fold below cannot repair that, it runs on what came back. `limit * 4` was written when
+                 * a board was one vector and forty candidates were forty nodes; against one vector per card
+                 * it is a list a single board fills on its own. Asking for the ceiling is the one widening
+                 * available. Vectorize charges the query and not the depth, so that side is free; the price
+                 * is on the D1 side, where `hydrateVisibleCitations` batches 40 pairs per statement and the
+                 * ordinary unscoped search therefore goes from one statement to as many as three. Nothing
+                 * about the ceiling itself moves: a `limit` of 25 and every scoped search reached 100 before.
+                 *
+                 * ⚠️ It is a widening and not a fix, and the reason it is not is written down in
+                 * `packages/api/CLAUDE.md`: bounding the fan-out per NODE means filtering on a `nodeId`
+                 * metadata index, and Cloudflare only puts a vector into such an index when it is upserted
+                 * AFTER the index was created — so it would cost every installation a full re-embed of its
+                 * tree, plus an operational step no deployment has taken. That is anchrd/intel#356.
+                 *
+                 * ⚠️ 100 is the port's own clamp too, and it is Vectorize's documented ceiling for a query
+                 * that returns neither values nor metadata (50 for one that does). The scoped case has asked
+                 * for it since #126, because a scope cuts the candidates AFTERWARDS, in the D1 statement
+                 * that re-checks the ACL — a folder of a dozen documents inside a tree of thousands is not
+                 * reached by a narrow fan-out, and a starved scope looks like an empty folder.
+                 */
+                const candidates = 100;
                 const hits = await deps.semantic.search(input.query, candidates);
-                const semanticScores = new Map();
+                /**
+                 * The best-scoring chunk of each node, and its score (anchrd/intel#301).
+                 *
+                 * ⚠️ The best, not the sum and not the first. A board answers once per card whose vector
+                 * matched, and a citation names a node — so a board of three hundred mediocre cards must not
+                 * out-rank one document that actually answers, and the passage the reader is shown has to be
+                 * the card that scored, not the one that happened to come back first.
+                 */
+                const best = new Map();
                 for (const hit of hits) {
-                    semanticScores.set(hit.nodeId, Math.max(semanticScores.get(hit.nodeId) ?? 0, hit.score));
+                    const current = best.get(hit.nodeId);
+                    if (current === undefined || hit.score > current.score) {
+                        best.set(hit.nodeId, { chunkKey: hit.chunkKey, score: hit.score });
+                    }
                 }
-                const semantic = await deps.repository.hydrateVisibleCitations(actor, [...semanticScores.keys()], input.scopeId);
+                const semanticScores = new Map([...best].map(([nodeId, winner]) => [nodeId, winner.score]));
+                const semantic = await deps.repository.hydrateVisibleCitations(actor, [...best].map(([nodeId, winner]) => ({ nodeId, chunkKey: winner.chunkKey })), input.scopeId);
                 return {
                     items: mergeSearchResults(lexical, semantic, semanticScores, input.limit),
                 };
@@ -1796,6 +1050,18 @@ export function createNodes(deps) {
             if (actor.isAdmin !== true) {
                 throw new IntelError(403, "reindex_forbidden", "Reindex permission is required");
             }
+            /**
+             * ⚠️ First, and before a single version is enqueued: the record of what the vector index
+             * holds (anchrd/intel#301). Since #301 an indexing pass skips a chunk whose fingerprint has
+             * not moved, which is what keeps a board of three hundred cards from costing three hundred
+             * embeddings per save — and it would equally make `reindex` skip everything, so a vector
+             * index that had been emptied would stay empty while every version was dutifully requeued.
+             * That is the one failure this call exists to prevent, and it is a silent one: the answer
+             * would be a search that finds less and a `queued` count that says all is well.
+             *
+             * The full-text half needs no equivalent because its rows are overwritten, never skipped.
+             */
+            await deps.repository.invalidateVectors();
             let queued = 0;
             let after = null;
             for (;;) {