@anchrd/intel-api 0.14.0 → 0.15.0

package/dist/adapters/cloudflare/cloudflare.js

@@ -1,18 +1,14 @@
 import { createGateClient } from "@anchrd/gate-sdk";
 import { ulid } from "ulid";
-import { createAgentCosts } from "../../agent-costs/agent-costs.js";
-import { createAgentRuntimeService } from "../../agent-runtime/agent-runtime.js";
 import { createBrowserAuth } from "../../auth/auth.js";
 import { createBundle } from "../../bundle/bundle.js";
 import { createFlows } from "../../flows/flows.js";
 import { createIndexing, PermanentIndexingError } from "../../indexing/indexing.js";
 import { createIntel } from "../../intel/intel.js";
-import { createModelCatalog } from "../../model-catalog/model-catalog.js";
 import { createNodes } from "../../nodes/nodes.js";
 import { IntelError } from "../../shared/intel-error/intel-error.js";
 import { sha256Hex } from "../../shared/sha256/sha256.js";
 import { createTools } from "../../tools/tools.js";
-import { createCloudflareApi } from "../cloudflare-api/cloudflare-api.js";
 import { createContentStore } from "../content/content.js";
 import { createNodeRepository } from "../db/db.js";
 import { createFlowRepository } from "../db/db-flows.js";
@@ -20,7 +16,6 @@ import { createNodeIndexRepository } from "../db/db-indexing.js";
 import { createOAuthClientStore } from "../db/db-oauth.js";
 import { createDocumentConverter } from "../document-converter/document-converter.js";
 import { createFlowRuntime } from "../flow-runtime/flow-runtime.js";
-import { createGateApplications } from "../gate-applications/gate-applications.js";
 import { createIndexQueue, IndexMessage } from "../index-queue/index-queue.js";
 import { createJsonSchemaValidator } from "../json-schema/json-schema.js";
 import { createOpenId } from "../openid/openid.js";
@@ -28,7 +23,6 @@ import { createPortalTokenStore } from "../portal-tokens/portal-tokens.js";
 import { createRemoteTools } from "../remote-tools/remote-tools.js";
 import { createSemanticIndex } from "../semantic-index/semantic-index.js";
 import { createSessionCodec } from "../session-cookie/session-cookie.js";
-import { createToolDelegation } from "../tool-delegation/tool-delegation.js";
 import { createToolSourcePolicy } from "../tool-source-policy/tool-source-policy.js";
 // biome-ignore lint/performance/noBarrelFile: The package entry must expose Wrangler's named Workflow class.
 export { IntelFlowWorkflow } from "./cloudflare-flow-workflow.js";
@@ -82,22 +76,10 @@ export default {
             crypto,
             now,
         });
-        // Built before the tree since D30: saving an agent has to ask the portal, live, whether the
-        // person saving reaches every server they are delegating. The dependency runs one way — the
-        // tool service knows nothing about the tree, and the delegation lookup below reads D1 directly
-        // rather than through the node service.
-        const toolDelegation = createToolDelegation({
-            db: env.DB,
-            content: contentStore,
-            id: ulid,
-            now,
-        });
         const tools = createTools({
             portalUrl,
             remote: createRemoteTools({ fetch: globalThis.fetch.bind(globalThis) }),
             tokens: portalTokens,
-            delegation: toolDelegation.resolve,
-            audit: toolDelegation.audit,
             refresh: async (token) => {
                 try {
                     const refreshed = await oauth.refresh({
@@ -126,56 +108,9 @@ export default {
                 return await sha256Hex(crypto, JSON.stringify(value));
             },
         });
-        // ⚠️ Built before `nodes` and not after, because creating an agent has to be able to hand the
-        // runtime its key inside the same call (D29). Its `visibleNode` closes over `nodes` and is only
-        // ever called later, which is what keeps the two from being a cycle.
-        const agents = createAgentRuntimeService({
-            ...(env.AGENT ? { runtime: env.AGENT } : {}),
-            ...(env.AGENT_HANDOVER_SECRET ? { handoverSecret: env.AGENT_HANDOVER_SECRET } : {}),
-            // The tree's own visibility lookup, unchanged: whether somebody may reach an agent is the
-            // same question as whether they may see the node, and no second answer is invented here.
-            visibleNode: async (actor, nodeId) => await nodes.visibleNode(actor, nodeId),
-        });
-        // ⚠️ One Cloudflare read client for both of the account's answers — the gateway's cost log
-        // (#251) and the Workers AI price list (#257) — because it is one token and one account. It is
-        // absent as a whole where any of the three variables is missing: a half-configured client would
-        // fail per call with a 401 that reads like a permission problem instead of saying, once, that
-        // this deployment was never given a token.
-        const gatewayAccountId = env.AI_GATEWAY_ACCOUNT_ID?.trim();
-        const gatewayId = env.AI_GATEWAY_ID?.trim();
-        const gatewayReadToken = env.AI_GATEWAY_READ_TOKEN?.trim();
-        const cloudflareApi = gatewayAccountId && gatewayId && gatewayReadToken
-            ? createCloudflareApi({
-                accountId: gatewayAccountId,
-                gatewayId,
-                token: gatewayReadToken,
-                fetch: globalThis.fetch.bind(globalThis),
-            })
-            : undefined;
-        const agentCosts = createAgentCosts({
-            ...(cloudflareApi ? { gateway: cloudflareApi } : {}),
-            visibleNode: async (actor, nodeId) => await nodes.visibleNode(actor, nodeId),
-            now,
-        });
-        const models = createModelCatalog({ ...(cloudflareApi ? { cloudflare: cloudflareApi } : {}) });
         const nodes = createNodes({
             repository: nodeRepository,
             content: contentStore,
-            // ⚠️ Built from `GATE_URL` alone — no service key is handed to it, and none would help. The
-            // Applications surface is admin-gated on a real principal, so every call carries the bearer
-            // of the person making it, which the tree passes in per operation (#182).
-            applications: createGateApplications({
-                fetch: globalThis.fetch.bind(globalThis),
-                gateUrl: env.GATE_URL,
-            }),
-            // The binding's presence IS the signal (#190) — no separate configuration option exists.
-            agentRuntimeAvailable: () => env.AGENT !== undefined,
-            // Where the Application key goes, and the only place it goes (D29). The same service the
-            // browser paths are proxied through, so there is one door to the runtime and not two.
-            agentKeys: { store: async (input) => await agents.storeKey(input) },
-            // The same door again (#214): a definition that was written is a schedule that has to be
-            // armed, and the runtime only looks when it is told to.
-            agentSchedules: { sync: async (input) => await agents.syncSchedules(input) },
             id: ulid,
             now,
             indexing: createIndexQueue(env.INDEXING),
@@ -247,9 +182,6 @@ export default {
                 },
                 indexing: createIndexQueue(env.INDEXING),
             }),
-            agents,
-            agentCosts,
-            models,
             auth,
         }).fetch(request);
     },

package/dist/adapters/cloudflare/cloudflare.types.d.ts

@@ -9,17 +9,6 @@ export interface CloudflareEnv {
     ASSETS?: {
         fetch(request: Request): Promise<Response>;
     };
-    /**
-     * The agent runtime Worker, bound as a service.
-     *
-     * ⚠️ Optional, and it has to be: a deployment may run Intel without agents, and a hard requirement
-     * here would make the whole installation fail to start over a feature nobody uses. Where it is
-     * absent the agent routes answer 503 by name; where it is present the browser reaches the runtime
-     * through Intel and never across a second origin (#178).
-     */
-    AGENT?: {
-        fetch(request: Request): Promise<Response>;
-    };
     DB: D1Database;
     CONTENT: R2Bucket;
     INDEXING: QueueProducer<IndexMessage>;
@@ -30,34 +19,6 @@ export interface CloudflareEnv {
     GATE_SERVICE_KEY: string;
     INTEL_URL: string;
     INTEL_SESSION_SECRET: string;
-    /**
-     * The shared secret that proves a key handover reached the agent runtime through this Worker
-     * (D29, #207). The SAME value the agent Worker holds as `AGENT_HANDOVER_SECRET`.
-     *
-     * ⚠️ Optional exactly like `AGENT`: a deployment may run Intel without agents, and a hard
-     * requirement would make the whole installation fail to start over a feature nobody uses. Where
-     * it is absent, creating an agent refuses by name instead of leaving one without a key.
-     */
-    AGENT_HANDOVER_SECRET?: string;
-    /**
-     * Where the AI Gateway lives and how to READ it (#251, #257).
-     *
-     * ⚠️ `AI_GATEWAY_READ_TOKEN` is not the agent runtime's `AI_GATEWAY_TOKEN` and must never be the
-     * same value. That one carries `AI Gateway: Run` and buys inference; this one carries
-     * `AI Gateway: Read` — plus `Workers AI: Read` for the model catalog — and buys nothing at all.
-     * One credential doing both would put a spending permission into the Worker that only reads.
-     *
-     * ⚠️ Cloudflare cannot scope `AI Gateway: Read` to a single gateway; it is account-wide, the same
-     * limitation `AI Gateway: Run` already had in #239. It is worth knowing when the token is created
-     * and is not a reason against the route: it reads and writes nothing.
-     *
-     * ⚠️ All three optional, together. A deployment that configures none of them gets a cost view that
-     * says "not configured" and a model catalog off the built-in table — both named states, neither an
-     * error. Intel without a Cloudflare token is a supported installation.
-     */
-    AI_GATEWAY_ACCOUNT_ID?: string;
-    AI_GATEWAY_ID?: string;
-    AI_GATEWAY_READ_TOKEN?: string;
     TOOL_SOURCE_ORIGINS: string;
     MCP_PORTAL_URL?: string;
     ALLOW_INSECURE_OAUTH?: string;

package/dist/adapters/db/db-flows.js

@@ -219,7 +219,7 @@ export function createFlowRepository(deps) {
           SELECT
             EXISTS (SELECT 1 FROM ancestors WHERE id = ?) AS in_subtree,
             EXISTS (
-              SELECT 1 FROM tree_grants grant_row
+              SELECT 1 FROM node_grants grant_row
               JOIN ancestors ON ancestors.id = grant_row.node_id
               WHERE grant_row.principal_type = 'organization'
                 AND grant_row.verb = 'execute'

package/dist/adapters/db/db-grants.js

@@ -5,7 +5,7 @@ const principalMatch = `(
 )`;
 function grantExists(nodeColumn) {
     return `EXISTS (
-    SELECT 1 FROM tree_grants grant_row
+    SELECT 1 FROM node_grants grant_row
     WHERE grant_row.node_id = ${nodeColumn}
       AND ${principalMatch}
       AND grant_row.verb = ?

package/dist/adapters/db/db.js

@@ -5,7 +5,7 @@ const grantColumns = `id, node_id, principal_type, principal_id, verb, expires_a
   created_by, created_at`;
 const linkColumns = `link.id, link.source_node_id, link.target_node_id, link.relation,
   link.origin, link.label, link.created_by, link.created_at`;
-// The first row of each node, in the order they arrive. A chunked kind — a board, whose index holds
+// The first row of each node, in the order they arrive. A chunked kind — one whose index holds
 // one row per task (#285) — answers a query once per matching card; a citation names a node, so the
 // best of them is the one that gets to speak for it.
 function dedupedByNode(rows) {
@@ -146,66 +146,7 @@ export function createNodeRepository(deps) {
     JOIN allowed ON allowed.id = n.id
     WHERE n.archived_at IS NOT NULL
     ORDER BY n.archived_at DESC, lower(n.title), n.id`;
-    /**
-     * The agents this actor may see, over the whole tree or under one folder (#139).
-     *
-     * ⚠️ The same `allowed` set every other read joins against, not a second predicate written for
-     * agents. An agent is a node, and the moment its list answers from its own rule it can answer
-     * differently from `list` about the very same row.
-     *
-     * Three scopes, matching the flow list: no clause at all for the whole tree, `IS NULL` for the
-     * root level, and one folder by ID.
-     */
-    const visibleAgents = (clause, includeArchived) => `${visibleCte}
-    SELECT ${nodeColumns}
-    FROM nodes n
-    JOIN allowed ON allowed.id = n.id
-    WHERE n.kind = 'agent' ${includeArchived ? "" : "AND n.archived_at IS NULL"} ${clause}
-    ORDER BY lower(n.title), n.id`;
-    const agentScopeOf = (parentId) => parentId === undefined
-        ? { clause: "", bindings: [] }
-        : parentId === null
-            ? { clause: "AND n.parent_id IS NULL", bindings: [] }
-            : { clause: "AND n.parent_id = ?", bindings: [parentId] };
     return {
-        async listVisibleAgents(actor, input) {
-            const scope = agentScopeOf(input.parentId);
-            const result = await deps.db
-                .prepare(visibleAgents(scope.clause, input.includeArchived === true))
-                .bind(...readBindings(actor), ...scope.bindings)
-                .all();
-            return (result.results ?? []).map(mapNode);
-        },
-        /**
-         * The R2 keys of the current definitions of every agent in this folder's subtree that this
-         * actor may see — the input to the share warning (#139, ADR-0005 §2).
-         *
-         * ⚠️ Keys, never bodies and never titles. Whether a referenced node may be NAMED to whoever is
-         * sharing is the tree's question and is asked afterwards through `getVisible`, exactly as the
-         * flow side does it. Answering it here would be the second rule that #17 and #19 got wrong.
-         *
-         * ⚠️ Agents this actor may not see contribute nothing, not even a count. Their references would
-         * otherwise be attributed to a folder this actor administers, which discloses that the agent is
-         * there at all.
-         */
-        async listVisibleAgentDefinitionKeys(actor, folderId) {
-            const result = await deps.db
-                .prepare(`${visibleCte},
-          scope(id) AS (
-            SELECT id FROM nodes WHERE id = ?
-            UNION
-            SELECT child.id FROM nodes child JOIN scope ON child.parent_id = scope.id
-          )
-          SELECT version.content_key AS content_key
-          FROM nodes n
-          JOIN allowed ON allowed.id = n.id
-          JOIN node_versions version ON version.id = n.current_version_id
-          WHERE n.kind = 'agent' AND n.archived_at IS NULL AND n.id IN (SELECT id FROM scope)
-          ORDER BY n.id`)
-                .bind(...readBindings(actor), folderId)
-                .all();
-            return (result.results ?? []).map((row) => row.content_key);
-        },
         async listVisible(actor, input) {
             const result = await deps.db
                 .prepare(input.archivedOnly ? archivedEverywhere : visibleChildren(false))
@@ -377,7 +318,7 @@ export function createNodeRepository(deps) {
          *
          * ⚠️ The idempotency row points at the VERSION, and the audit event points at the node, so the
          * two are joined through the version id the snapshot writer puts into the metadata. That
-         * metadata is where a board operation says which task it touched and how many it removed —
+         * metadata is where a snapshot says which positions it touched and how many it removed —
          * facts a replay cannot recompute from the stored document, because the document is the state
          * AFTER the write. Without this, repeating a delete would answer with a count nobody measured.
          */
@@ -439,19 +380,8 @@ export function createNodeRepository(deps) {
                 return null;
             return row.resource_id.startsWith("1:");
         },
-        // ⚠️ Its own statement rather than a column on the node read: four of the five kinds can never
-        // have an Application, and the two joins every node read already carries are not going to grow
-        // a third for a question only agents ask (#182).
-        async agentApplicationId(nodeId) {
-            const row = await deps.db
-                .prepare("SELECT application_id FROM agent_applications WHERE node_id = ?")
-                .bind(nodeId)
-                .first();
-            return row?.application_id ?? null;
-        },
         async insertNode(input) {
             const node = input.node;
-            const application = input.application;
             try {
                 await deps.db.batch([
                     deps.db
@@ -469,23 +399,7 @@ export function createNodeRepository(deps) {
                         .prepare(`INSERT INTO audit_events (
             id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
           ) VALUES (?, ?, 'node.create', 'node', ?, ?, ?)`)
-                        .bind(input.auditId, input.actorId, node.id, 
-                    // ⚠️ The Application ID is deliberately NOT in this metadata, and the key is not
-                    // within reach of it at all. An audit event is read back by people and by the
-                    // reindexer; what belongs in it is that an agent was created, not the name of the
-                    // principal behind it — the mapping row below is where that is kept, once (D27).
-                    JSON.stringify({ kind: node.kind, parentId: node.parentId }), node.createdAt),
-                    // Last in the batch, and in the SAME batch: D1 runs a batch as one transaction, so the
-                    // mapping cannot end up without its node or the node without its mapping. An agent whose
-                    // principal is recorded nowhere is one that archiving would quietly fail to switch off.
-                    ...(application
-                        ? [
-                            deps.db
-                                .prepare(`INSERT INTO agent_applications (node_id, application_id, created_at)
-                     VALUES (?, ?, ?)`)
-                                .bind(node.id, application.id, node.createdAt),
-                        ]
-                        : []),
+                        .bind(input.auditId, input.actorId, node.id, JSON.stringify({ kind: node.kind, parentId: node.parentId }), node.createdAt),
                 ]);
             }
             catch (error) {
@@ -832,7 +746,7 @@ export function createNodeRepository(deps) {
                     .bind(version.id, version.nodeId, version.sequence, version.contentKey, version.mediaType, version.contentHash, version.size, 
                 // ⚠️ Taken from the version rather than written in as `'snapshot'`. A table's mutation
                 // marks a snapshot, because reading a table starts at the newest one and everything
-                // before it is history (#135). A board's version carries the whole board by
+                // before it is history (#135). A snapshot version carries the whole document by
                 // construction, so it marks nothing — the same `null` a document's version carries, and
                 // for the same reason (#285).
                 version.segment, version.createdBy, version.createdAt, version.nodeId, input.baseVersionId),
@@ -868,7 +782,7 @@ export function createNodeRepository(deps) {
         },
         async listGrants(resourceId) {
             const result = await deps.db
-                .prepare(`SELECT ${grantColumns} FROM tree_grants
+                .prepare(`SELECT ${grantColumns} FROM node_grants
           WHERE node_id = ?
           ORDER BY principal_type, principal_id, verb`)
                 .bind(resourceId)
@@ -887,7 +801,7 @@ export function createNodeRepository(deps) {
             JOIN ancestors child ON child.parent_id = parent.id
           )
           SELECT 1 AS reaches
-          FROM tree_grants grant_row
+          FROM node_grants grant_row
           JOIN ancestors ON ancestors.id = grant_row.node_id
           WHERE grant_row.id <> ?
             AND grant_row.principal_type = 'organization'
@@ -966,17 +880,6 @@ export function createNodeRepository(deps) {
                     .bind(input.auditId, input.actorId, input.sourceNodeId, JSON.stringify({ targetNodeIds: input.links.map((link) => link.targetNodeId) }), input.occurredAt),
             ]);
         },
-        async recordAgentKeyRotation(input) {
-            // ⚠️ No node row moves, so there is nothing to batch this with — the event IS the write. The
-            // key is not among the columns and must not be added to them: audit is metadata, and a row
-            // that carried the credential would outlive every other copy of it.
-            await deps.db
-                .prepare(`INSERT INTO audit_events (
-          id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
-        ) VALUES (?, ?, 'agent.rotate_key', 'node', ?, ?, ?)`)
-                .bind(input.auditId, input.actorId, input.nodeId, JSON.stringify({ applicationId: input.applicationId }), input.occurredAt)
-                .run();
-        },
         async graphVisible(actor, input) {
             const nodeResult = await deps.db
                 .prepare(`${visibleCte}
@@ -1021,7 +924,7 @@ export function createNodeRepository(deps) {
                     deps.db
                         // The verb is part of the key, so re-granting the same verb only refreshes its expiry
                         // and never turns one verb into another.
-                        .prepare(`INSERT INTO tree_grants (
+                        .prepare(`INSERT INTO node_grants (
               id, node_id, principal_type, principal_id, verb,
               expires_at, created_by, created_at
             ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
@@ -1031,7 +934,7 @@ export function createNodeRepository(deps) {
                     deps.db
                         .prepare(`INSERT INTO idempotency_keys (
               actor_id, operation, idempotency_key, resource_id, created_at
-            ) SELECT ?, 'node.share', ?, id, ? FROM tree_grants
+            ) SELECT ?, 'node.share', ?, id, ? FROM node_grants
               WHERE node_id = ? AND principal_type = ? AND principal_id = ? AND verb = ?`)
                         .bind(input.actorId, input.idempotencyKey, grant.createdAt, grant.resourceId, principalType, principalId, grant.verb),
                     deps.db
@@ -1041,7 +944,7 @@ export function createNodeRepository(deps) {
                         .bind(input.auditId, input.actorId, grant.resourceId, JSON.stringify({ principalType, verb: grant.verb }), grant.createdAt),
                 ]);
                 const stored = await deps.db
-                    .prepare(`SELECT ${grantColumns} FROM tree_grants
+                    .prepare(`SELECT ${grantColumns} FROM node_grants
             WHERE node_id = ? AND principal_type = ? AND principal_id = ? AND verb = ?`)
                     .bind(grant.resourceId, principalType, principalId, grant.verb)
                     .first();
@@ -1057,7 +960,7 @@ export function createNodeRepository(deps) {
                     .first();
                 if (replayed) {
                     const row = await deps.db
-                        .prepare(`SELECT ${grantColumns} FROM tree_grants WHERE id = ?`)
+                        .prepare(`SELECT ${grantColumns} FROM node_grants WHERE id = ?`)
                         .bind(replayed.resource_id)
                         .first();
                     if (row)
@@ -1074,11 +977,11 @@ export function createNodeRepository(deps) {
               actor_id, operation, idempotency_key, resource_id, created_at
             ) SELECT ?, 'node.revoke', ?,
               (CASE WHEN EXISTS (
-                SELECT 1 FROM tree_grants WHERE id = ? AND node_id = ?
+                SELECT 1 FROM node_grants WHERE id = ? AND node_id = ?
               ) THEN '1:' ELSE '0:' END) || ?, ?`)
                         .bind(input.actorId, input.idempotencyKey, input.grantId, input.resourceId, input.grantId, input.occurredAt),
                     deps.db
-                        .prepare("DELETE FROM tree_grants WHERE id = ? AND node_id = ?")
+                        .prepare("DELETE FROM node_grants WHERE id = ? AND node_id = ?")
                         .bind(input.grantId, input.resourceId),
                     deps.db
                         .prepare(`INSERT INTO audit_events (
@@ -1121,10 +1024,10 @@ export function createNodeRepository(deps) {
           LIMIT ?`)
                 .bind(...readBindings(actor), ...scopeBindings(input.scopeId), query, input.limit)
                 .all();
-            // ⚠️ One citation per node, and the FIRST is the one kept. A board holds one index row per
-            // task (#285), so a query matching three cards of the same board arrives here three times;
+            // ⚠️ One citation per node, and the FIRST is the one kept. The index is CHUNKED — a node
+            // may hold several rows (#285) — so a query matching three of them arrives here three times;
             // the rows come back in rank order, so the survivor is the best-matching card and its own
-            // passage is what the reader is shown. Without this, one busy board could fill a whole page
+            // passage is what the reader is shown. Without this, one busy node could fill a whole page
             // of results and push every other node off it.
             return dedupedByNode(result.results ?? []).map((row) => ({
                 nodeId: row.node_id,
@@ -1139,7 +1042,7 @@ export function createNodeRepository(deps) {
         },
         async hydrateVisibleCitations(actor, hits, scopeId) {
             // One entry per node: the caller has already picked the best-scoring chunk of each, so a
-            // board that answered with four cards arrives as the one card that answered best.
+            // node that answered with four passages arrives as the one passage that answered best.
             const unique = [...new Map(hits.map((hit) => [hit.nodeId, hit])).values()].slice(0, 100);
             if (unique.length === 0)
                 return [];

package/dist/bundle/bundle.js

@@ -1,6 +1,5 @@
-import { AgentDefinition, AgentMediaType, BlockNoteMediaType, BoardDocument, BoardMediaType, BundleImportResult, BundleManifest, BundleManifestFilename, DocumentLinkInlineType, FlowGraph, TableMediaType, } from "@anchrd/intel-contract";
+import { BlockNoteMediaType, 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";
@@ -217,13 +216,11 @@ function nakedKindOf(name) {
     if (lower.endsWith(".csv")) {
         return { kind: "table", mediaType: TableMediaType, title: name.slice(0, -4) };
     }
-    // ⚠️ Before any plain `.json` rule and with a compound suffix on purpose (#285). A board is not
-    // recognisable from `.json` alone — an agent definition wears the same extension — so the export
-    // writes `.board.json` and a naked upload has to spell it out too. A file that only says `.json`
-    // is an attachment, which is what it was before boards existed.
-    if (lower.endsWith(".board.json")) {
-        return { kind: "board", mediaType: BoardMediaType, title: name.slice(0, -11) };
-    }
+    // ⚠️ `.board.json` had its own rule here until #390 and deliberately does not any more. This is
+    // the NAKED-folder path — a directory somebody picked, with no manifest — so a file called
+    // `plan.board.json` is a JSON file on a disk, and keeping it as an attachment preserves it. A
+    // real export is a different matter: its manifest declares the kind, and that is where such an
+    // entry is refused by name.
     return { kind: "attachment", mediaType: guessedMediaType(lower), title: name };
 }
 const KnownMediaTypes = {
@@ -402,41 +399,11 @@ export function createBundle(deps) {
                 },
             };
         }
-        // A board is one JSON file, exactly like an agent's definition: the document IS the board, so
-        // there is nothing to serialize differently for an export (#285). A board with no version yet
-        // exports as an empty file, the same way an agent without a definition does.
-        if (node.kind === "board") {
-            const path = `${directory}${uniqueName(used, base, ".board.json")}`;
-            return {
-                manifest: {
-                    id: node.id,
-                    kind: "board",
-                    title: node.title,
-                    description: node.description,
-                    mediaType: version?.mediaType ?? BoardMediaType,
-                    path,
-                },
-                content: version === null
-                    ? { type: "text", load: async () => "" }
-                    : { type: "text", load: textLoader(version.contentKey) },
-            };
-        }
-        if (node.kind === "agent") {
-            const path = `${directory}${uniqueName(used, base, ".json")}`;
-            return {
-                manifest: {
-                    id: node.id,
-                    kind: "agent",
-                    title: node.title,
-                    description: node.description,
-                    mediaType: version?.mediaType ?? "application/json",
-                    path,
-                },
-                content: version === null
-                    ? { type: "text", load: async () => "" }
-                    : { type: "text", load: textLoader(version.contentKey) },
-            };
-        }
+        // ⚠️ A row of a kind this build no longer makes — an `agent` or a `board` written before #390
+        // — falls through to the document branch and travels as its raw body. Deliberately forgiving:
+        // refusing here would make one leftover row enough to stop a whole subtree from being exported,
+        // and the file it produces is exactly the bytes that were stored. The IMPORT is where such a
+        // bundle is turned away, by name.
         // A document: markdown stays `.md`, a BlockNote body is JSON and says so with its name.
         const mediaType = version?.mediaType ?? "text/markdown";
         const extension = mediaType === BlockNoteMediaType ? ".json" : ".md";
@@ -945,103 +912,23 @@ export function createBundle(deps) {
                         version = versionRowFor(entry, text, TableMediaType, await deps.hash(text), "snapshot");
                     }
                 }
-                else if (entry.kind === "board") {
-                    const text = entry.body === null ? "" : decodeText(entry.body, entry.path);
-                    if (text.trim().length > 0) {
-                        let document;
-                        try {
-                            // 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,
-                        // whose ids the import does not touch. Renumbering those would break every edge in the
-                        // board for no reason.
-                        const remapped = {
-                            statuses: document.statuses,
-                            tasks: document.tasks.map((task) => ({
-                                ...task,
-                                references: task.references.map((reference) => idMap.get(reference) ?? reference),
-                            })),
-                        };
-                        const body = JSON.stringify(remapped);
-                        version = versionRowFor(entry, body, BoardMediaType, await deps.hash(body), null);
-                        // Into the same link pass as an imported document: a board's references are `text`
-                        // links, so they have to survive the import the same way.
-                        documentBodies.set(entry.newId, { mediaType: BoardMediaType, content: body });
-                    }
-                }
-                else if (entry.kind === "agent") {
-                    const text = entry.body === null ? "" : decodeText(entry.body, entry.path);
-                    if (text.trim().length > 0) {
-                        let definition;
-                        try {
-                            definition = AgentDefinition.parse(JSON.parse(text));
-                        }
-                        catch {
-                            throw new IntelError(400, "import_invalid_agent", `Bundle entry is not an agent definition: ${entry.path}`);
-                        }
-                        const remapped = {
-                            ...definition,
-                            /**
-                             * ⚠️ A delegation NEVER travels in a file (#208, D30). `tools.delegatedBy` names
-                             * whose portal connection an agent acts on, and the only thing that may write it is
-                             * a person saving the agent in a session Intel authorized — the save path proves
-                             * they reach every named server first. A bundle is a document somebody hands over;
-                             * carrying the field through would let a crafted file name a local user and hand an
-                             * imported agent that person's connection, with no act of theirs anywhere.
-                             *
-                             * The consequence is deliberate and mild: an imported agent arrives with no tools,
-                             * and whoever wants it to have some gives them in the profile — which is the same
-                             * act D30 made the only way in.
-                             */
-                            tools: null,
-                            references: definition.references.map((reference) => idMap.has(reference.nodeId)
-                                ? { ...reference, nodeId: idMap.get(reference.nodeId) }
-                                : reference),
-                            schedules: definition.schedules.map((schedule) => idMap.has(schedule.target.id)
-                                ? {
-                                    ...schedule,
-                                    target: { ...schedule.target, id: idMap.get(schedule.target.id) },
-                                }
-                                : schedule),
-                        };
-                        const body = JSON.stringify(remapped);
-                        version = versionRowFor(entry, body, AgentMediaType, await deps.hash(body), null);
-                    }
+                else if (entry.kind === "board" || entry.kind === "agent") {
+                    /**
+                     * ⚠️ Refused by name, and the name says WHY rather than what the parser tripped over.
+                     *
+                     * Agents and Boards were parked with #385; nothing in this build can hold either kind.
+                     * A bundle that carries one is not malformed — it is a correct export of an installation
+                     * that still had the feature, and the person holding it is usually moving a tree between
+                     * two installations rather than the author of the file. Left to the schema they would get
+                     * `unexpected enum value`, look for a broken file, and find nothing wrong with it.
+                     *
+                     * The refusal names the entry, the kind and the branch the feature is parked on, so the
+                     * answer to "where did my board go" is in the message and not in somebody's memory.
+                     *
+                     * ⚠️ Only a MANIFEST can reach this, because only a manifest declares a kind. A naked
+                     * folder holding a `plan.board.json` imports it as an attachment — see `kindOfFile`.
+                     */
+                    throw new IntelError(400, "import_kind_parked", `Bundle entry “${entry.path}” is a ${entry.kind}, and ${entry.kind}s are not part of this installation any more (anchrd/intel#385). The bundle was exported from a version that still had them; the code is on the branch parked/agents-and-board. Remove the entry from the bundle to import the rest.`);
                 }
                 else if (entry.kind === "attachment") {
                     const bytes = entry.body ?? new Uint8Array(0);