@anchrd/intel-api 0.6.7 → 0.7.0

package/dist/nodes/nodes.types.d.ts

@@ -0,0 +1,314 @@
+import type { AgentList, AppendTableRowsInput, AppendTableRowsResult, ArchiveNodeInput, CreateAgentInput, CreatedAgent, CreateNodeInput, DefineTableInput, DeleteTableRowsInput, DeleteTableRowsResult, Flow, FlowVersion, GetAgentInput, ListAgentsInput, ListNodesInput, Node, NodeAgent, NodeAttachment, NodeCitation, NodeDocument, NodeGraph, NodeGraphInput, NodeLink, NodeTable, NodeVersion, RedefineTableInput, ResolveNodeLinksInput, ResolveNodeLinksResult, ResourceGrant, ResourceGrantList, ResourceVerb, RevokeGrantInput, SaveAgentDefinitionInput, SaveAttachmentInput, SaveNodeVersionInput, SearchInput, ShareInput, ShareResult, UpdateNodeInput, UpdateTableRowsInput, UpdateTableRowsResult } from "@anchrd/intel-contract";
+import type { SemanticIndex } from "../adapters/semantic-index/semantic-index.types.js";
+export interface Actor {
+    id: string;
+    email: string;
+    isAdmin?: boolean;
+}
+export interface NewNode {
+    node: Node;
+    actorId: string;
+    idempotencyKey: string;
+    auditId: string;
+    application?: {
+        id: string;
+    } | undefined;
+}
+export interface NewNodeVersion {
+    version: NodeVersion;
+    actorId: string;
+    baseVersionId: string | null;
+    idempotencyKey: string;
+    auditId: string;
+}
+export interface NewTableVersion {
+    version: Omit<NodeVersion, "sequence">;
+    actorId: string;
+    idempotencyKey: string;
+    auditId: string;
+}
+export type TableSnapshotOperation = "node.table_update" | "node.table_delete" | "node.table_redefine";
+export interface NewTableSnapshot {
+    version: NodeVersion;
+    actorId: string;
+    baseVersionId: string;
+    operation: TableSnapshotOperation;
+    metadata: Record<string, unknown>;
+    idempotencyKey: string;
+    auditId: string;
+}
+export interface NodeRepository {
+    listVisible(actor: Actor, input: ListNodesInput): Promise<{
+        items: Node[];
+        withChildren: string[];
+    }>;
+    listVisibleBounded(actor: Actor, input: {
+        parentId: string | null;
+        limit: number;
+    }): Promise<BoundedChildren>;
+    listVisibleAgents(actor: Actor, input: ListAgentsInput): Promise<Node[]>;
+    listVisibleAgentDefinitionKeys(actor: Actor, folderId: string): Promise<string[]>;
+    getVisible(actor: Actor, nodeId: string): Promise<Node | null>;
+    listVisibleSubtree(actor: Actor, rootId: string | null): Promise<SubtreeNode[]>;
+    can(actor: Actor, nodeId: string, verb: ResourceVerb): Promise<boolean>;
+    findIdempotentNode(actorId: string, operation: "node.create" | "node.save" | "node.append" | "node.update" | "node.archive" | "node.share" | "node.revoke" | TableSnapshotOperation, idempotencyKey: string): Promise<string | null>;
+    findIdempotentRevocation(actorId: string, idempotencyKey: string): Promise<boolean | null>;
+    insertNode(input: NewNode): Promise<Node>;
+    agentApplicationId(nodeId: string): Promise<string | null>;
+    getVersion(versionId: string): Promise<NodeVersion | null>;
+    appendVersion(input: NewNodeVersion): Promise<"saved" | "conflict">;
+    appendTableVersion(input: NewTableVersion): Promise<NodeVersion>;
+    appendTableSnapshot(input: NewTableSnapshot): Promise<"saved" | "conflict">;
+    listVersionContentKeys(nodeId: string): Promise<string[]>;
+    tableHeaderContentKey(nodeId: string): Promise<string | null>;
+    listVersions(nodeId: string): Promise<NodeVersion[]>;
+    updateNode(input: {
+        node: Node;
+        baseUpdatedAt: string;
+        actorId: string;
+        idempotencyKey: string;
+        auditId: string;
+    }): Promise<"cycle" | "conflict" | Node>;
+    archiveNode(input: {
+        nodeId: string;
+        baseUpdatedAt: string;
+        archivedAt: string | null;
+        updatedAt: string;
+        actorId: string;
+        idempotencyKey: string;
+        auditId: string;
+    }): Promise<"conflict" | Node>;
+    listGrants(resourceId: string): Promise<ResourceGrant[]>;
+    organizationExecuteReaches(nodeId: string, exceptGrantId: string): Promise<boolean>;
+    listLinksVisible(actor: Actor, nodeId: string): Promise<NodeLink[]>;
+    resolveVisibleTitles(actor: Actor, nodeIds: string[]): Promise<Array<{
+        nodeId: string;
+        title: string;
+    }>>;
+    replaceTextLinks(input: {
+        sourceNodeId: string;
+        links: Array<{
+            id: string;
+            targetNodeId: string;
+        }>;
+        actorId: string;
+        auditId: string;
+        occurredAt: string;
+    }): Promise<void>;
+    graphVisible(actor: Actor, input: NodeGraphInput): Promise<NodeGraph>;
+    setGrant(input: {
+        grant: ResourceGrant;
+        actorId: string;
+        idempotencyKey: string;
+        auditId: string;
+    }): Promise<ResourceGrant>;
+    revokeGrant(input: {
+        resourceId: string;
+        grantId: string;
+        actorId: string;
+        idempotencyKey: string;
+        auditId: string;
+        occurredAt: string;
+    }): Promise<boolean>;
+    searchVisible(actor: Actor, input: SearchInput): Promise<NodeCitation[]>;
+    hydrateVisibleCitations(actor: Actor, nodeIds: string[], scopeId?: string): Promise<NodeCitation[]>;
+    listCurrentVersionIds(input: {
+        after: string | null;
+        limit: number;
+    }): Promise<string[]>;
+    importTree(input: ImportTreeInput): Promise<"created" | "replayed">;
+    findImportReplay(actorId: string, idempotencyKey: string): Promise<Record<string, unknown> | null>;
+}
+export interface ImportedLink {
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+}
+/**
+ * Everything one bundle import creates, as one write (#137).
+ *
+ * ⚠️ The whole point of this shape is the atomicity: every row lands in one `db.batch`, which D1
+ * runs as one transaction, so a partial import cannot exist — either the whole subtree stands or
+ * nothing does. The R2 objects behind `versions` are written before and deleted again by the
+ * caller when the batch refuses.
+ *
+ * `nodes` must come parents before children: the tree's foreign key checks each row as it lands.
+ */
+export interface ImportTreeInput {
+    nodes: Node[];
+    versions: NodeVersion[];
+    links: ImportedLink[];
+    flows: Flow[];
+    flowVersions: FlowVersion[];
+    actorId: string;
+    idempotencyKey: string;
+    auditId: string;
+    auditResourceId: string;
+    metadata: Record<string, unknown>;
+    occurredAt: string;
+}
+export interface ContentStore {
+    get(key: string): Promise<string | null>;
+    getBytes(key: string): Promise<ArrayBuffer | null>;
+    getStream(key: string): Promise<ReadableStream<Uint8Array> | null>;
+    put(key: string, content: string, mediaType: string): Promise<void>;
+    putBytes(key: string, content: ArrayBuffer, mediaType: string): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+export interface NodeAttachmentBody {
+    attachment: NodeAttachment;
+    body: ReadableStream<Uint8Array>;
+}
+/**
+ * Gate's Applications surface, as the tree needs it (#182).
+ *
+ * ⚠️ Every call carries the CALLER's own Gate bearer, never a service key. Creating and switching a
+ * machine principal is an administrative act in Gate, gated on `applications:write` and audited
+ * there under the person who performed it; Intel's service key does not open that door at all
+ * (Gate's two-token rule). The token is therefore a parameter of the operation rather than a field
+ * of the actor: it must be impossible to reach for by accident from a service that has no business
+ * with it, and it must never end up on an audit row or in a log line.
+ */
+export interface AgentApplications {
+    /**
+     * A new machine principal, named so a person can recognise the agent behind it.
+     *
+     * ⚠️ The returned key is plain text, the only time it exists in readable form anywhere, and it is
+     * gone from Gate the moment this call returns. It is passed straight back to the caller who asked
+     * for it and is written nowhere on the way (D27).
+     */
+    create(input: {
+        token: string;
+        name: string;
+    }): Promise<{
+        id: string;
+        key: string;
+    }>;
+    setEnabled(input: {
+        token: string;
+        applicationId: string;
+        enabled: boolean;
+    }): Promise<void>;
+}
+export interface GateCaller {
+    token: string;
+}
+export interface NodesDeps {
+    repository: NodeRepository;
+    content: ContentStore;
+    applications: AgentApplications;
+    agentRuntimeAvailable(): boolean;
+    id(): string;
+    now(): Date;
+    externalFlowCallers(actor: Actor, folderId: string): Promise<{
+        visible: string[];
+        hidden: number;
+    }>;
+    flowNodeReferences(actor: Actor, folderId: string): Promise<string[]>;
+    hash(content: string | Uint8Array): Promise<string>;
+    indexing: {
+        enqueue(versionId: string): Promise<void>;
+    };
+    semantic?: SemanticIndex | undefined;
+}
+export type FolderAccess = "ok" | "missing" | "not-a-folder" | "forbidden";
+export interface SubtreeNode {
+    node: Node;
+    version: {
+        id: string;
+        mediaType: string;
+        contentKey: string;
+    } | null;
+}
+export interface BoundedChildren {
+    items: Node[];
+    total: number;
+}
+export interface NodeService {
+    list(actor: Actor, input: ListNodesInput): Promise<{
+        items: Node[];
+    }>;
+    /**
+     * One level of the tree as this actor may see it, bounded: at most `limit` current children, and
+     * `total` for how many there are. Its caller is the relation graph, which draws a bounded picture
+     * and must not read a folder of a thousand documents to do it (#30).
+     *
+     * ⚠️ `total` counts what passed the visibility predicate and nothing else, or the size a picture
+     * reports would become a way of learning that something is filed here.
+     */
+    childrenBounded(actor: Actor, input: {
+        parentId: string | null;
+        limit: number;
+    }): Promise<BoundedChildren>;
+    get(actor: Actor, nodeId: string): Promise<NodeDocument>;
+    getVersion(actor: Actor, nodeId: string, versionId: string): Promise<NodeDocument>;
+    folderAccess(actor: Actor, folderId: string): Promise<FolderAccess>;
+    create(actor: Actor, input: CreateNodeInput): Promise<Node>;
+    save(actor: Actor, input: SaveNodeVersionInput): Promise<NodeDocument>;
+    saveAttachment(actor: Actor, input: SaveAttachmentInput): Promise<NodeDocument>;
+    getTable(actor: Actor, nodeId: string): Promise<NodeTable>;
+    defineTable(actor: Actor, input: DefineTableInput): Promise<NodeTable>;
+    appendTableRows(actor: Actor, input: AppendTableRowsInput): Promise<AppendTableRowsResult>;
+    updateTableRows(actor: Actor, input: UpdateTableRowsInput): Promise<UpdateTableRowsResult>;
+    deleteTableRows(actor: Actor, input: DeleteTableRowsInput): Promise<DeleteTableRowsResult>;
+    redefineTable(actor: Actor, input: RedefineTableInput): Promise<NodeTable>;
+    getAgent(actor: Actor, input: GetAgentInput): Promise<NodeAgent>;
+    /**
+     * An agent node, its first definition, and the Gate Application it runs as (#182).
+     *
+     * ⚠️ The answer carries the Application key ONCE. It is the only value any Intel service returns
+     * that is a credential, it is never written down on the way out, and the caller who receives it
+     * is the only one who will ever see it.
+     */
+    createAgent(actor: Actor, input: CreateAgentInput, caller: GateCaller): Promise<CreatedAgent>;
+    saveAgentDefinition(actor: Actor, input: SaveAgentDefinitionInput): Promise<NodeAgent>;
+    listAgents(actor: Actor, input: ListAgentsInput): Promise<AgentList>;
+    getAttachment(actor: Actor, nodeId: string): Promise<NodeAttachment>;
+    readAttachment(actor: Actor, nodeId: string): Promise<NodeAttachmentBody>;
+    listVersions(actor: Actor, nodeId: string): Promise<{
+        items: NodeVersion[];
+    }>;
+    update(actor: Actor, input: UpdateNodeInput): Promise<Node>;
+    /**
+     * Archiving and restoring, for every kind — and for an agent, its Gate Application with it (#182).
+     *
+     * ⚠️ The Gate call comes FIRST and the node row second. An archived agent whose principal is
+     * still live is exactly the access nobody can see any more, so that state must not be reachable
+     * by a write that half succeeded; the opposite order can only leave a live agent whose principal
+     * is off, which stops working loudly and is repaired by repeating the call.
+     */
+    archive(actor: Actor, input: ArchiveNodeInput, caller: GateCaller): Promise<Node>;
+    listGrants(actor: Actor, resourceId: string): Promise<ResourceGrantList>;
+    listLinks(actor: Actor, nodeId: string): Promise<{
+        items: NodeLink[];
+    }>;
+    resolveLinks(actor: Actor, input: ResolveNodeLinksInput): Promise<ResolveNodeLinksResult>;
+    graph(actor: Actor, input: NodeGraphInput): Promise<NodeGraph>;
+    visibleNode(actor: Actor, nodeId: string): Promise<Node | null>;
+    share(actor: Actor, input: ShareInput): Promise<ShareResult>;
+    revokeGrant(actor: Actor, input: RevokeGrantInput): Promise<{
+        revoked: boolean;
+    }>;
+    search(actor: Actor, input: SearchInput): Promise<{
+        items: NodeCitation[];
+    }>;
+    reindex(actor: Actor): Promise<{
+        queued: number;
+    }>;
+}
+export interface NodeIndexTarget {
+    nodeId: string;
+    versionId: string;
+    title: string;
+    description: string | null;
+    contentKeys: string[];
+    mediaType: string;
+    kind: "document" | "attachment" | "table" | "agent";
+    updatedAt: string;
+}
+export interface NodeIndexRepository {
+    getTarget(versionId: string): Promise<NodeIndexTarget | null>;
+    replace(target: NodeIndexTarget, content: string): Promise<void>;
+    markIndexed(versionId: string, occurredAt: string): Promise<void>;
+    markError(versionId: string, message: string, occurredAt: string): Promise<void>;
+}

package/dist/nodes/nodes.types.js

@@ -0,0 +1 @@
+export {};

package/migrations/0011_one_name_for_the_tree.sql

@@ -0,0 +1,53 @@
+-- #125: `knowledge` was the first draft's word for the shared tree. The product is called intel,
+-- and a second name for one concept costs a translation in every session. The prefix goes: the tree
+-- is `nodes`, and the four tables around it are named after the node they belong to.
+--
+-- Nothing is rebuilt here, and that is the whole point of the file. `ALTER TABLE ... RENAME TO` is
+-- the one way to change a table's name without a `DROP TABLE`, and `DROP TABLE` is what made the
+-- two migrations that touched this table difficult:
+--
+--   - 0005 had to carry `knowledge_links` out of the way and put it back afterwards, because the
+--     implicit `DELETE FROM` behind `DROP TABLE` fires the ON DELETE CASCADE those rows hang on.
+--     Without the rescue the migration would have committed with every relationship between two
+--     documents quietly gone.
+--   - 0009 gave up on a rebuild altogether. D1 commits the statements of a migration file one at a
+--     time, so `PRAGMA defer_foreign_keys` is spent before the DROP arrives, and
+--     `PRAGMA foreign_keys = OFF` is ignored by D1 over its HTTP API while miniflare honours it —
+--     which is how a green local test can accompany a red remote migration.
+--
+-- A rename touches no row, so neither trap is reachable from here. SQLite rewrites the REFERENCES
+-- clauses of every table pointing at the renamed one — `node_versions`, `node_links` (twice),
+-- `tree_grants`, `flows`, and the tree's reference to itself — so all six foreign keys survive under
+-- the new name and no cascade has anything to fire on. That rewriting is conditional on foreign keys
+-- being enabled, which is exactly what 0005 established the hard way when the cascade took its link
+-- rows: D1 has them on.
+--
+-- ⚠️ Indexes do not follow a rename. They keep working, because an index is bound to its table
+-- rather than to its table's name, but they keep the old name in `sqlite_master` and would be the
+-- last place `knowledge` survives. Dropping and recreating one is free of everything above: an
+-- index holds no rows of its own, and no foreign key points at it.
+--
+-- `node_fts` is a derived FTS5 index and is renamed along with the rest rather than rebuilt; FTS5
+-- renames its own shadow tables. If it ever did come out empty, `intel reindex` builds it back from
+-- D1 and R2 — but nothing here asks it to.
+ALTER TABLE knowledge_nodes RENAME TO nodes;
+ALTER TABLE knowledge_versions RENAME TO node_versions;
+ALTER TABLE knowledge_links RENAME TO node_links;
+ALTER TABLE knowledge_index_state RENAME TO node_index_state;
+ALTER TABLE knowledge_fts RENAME TO node_fts;
+
+DROP INDEX knowledge_nodes_parent_idx;
+DROP INDEX knowledge_nodes_owner_idx;
+DROP INDEX knowledge_versions_node_idx;
+DROP INDEX knowledge_links_source_idx;
+DROP INDEX knowledge_links_target_idx;
+DROP INDEX knowledge_links_origin_idx;
+DROP INDEX knowledge_index_state_status_idx;
+
+CREATE INDEX nodes_parent_idx ON nodes(parent_id, archived_at, title);
+CREATE INDEX nodes_owner_idx ON nodes(owner_id, archived_at);
+CREATE INDEX node_versions_node_idx ON node_versions(node_id, sequence DESC);
+CREATE INDEX node_links_source_idx ON node_links(source_node_id, created_at);
+CREATE INDEX node_links_target_idx ON node_links(target_node_id, created_at);
+CREATE INDEX node_links_origin_idx ON node_links(source_node_id, origin);
+CREATE INDEX node_index_state_status_idx ON node_index_state(status, updated_at);

package/migrations/0012_table_snapshots.sql

@@ -0,0 +1,29 @@
+-- #135: a table version says what it carries. An 'append' holds only the rows one write added; a
+-- 'snapshot' holds the complete table — header and every row — so reading starts at the newest
+-- snapshot and everything before it stays history. Update, delete, and redefine write snapshots;
+-- append keeps writing appends; documents and attachments stay NULL because each of their versions
+-- is complete by construction and the word would say nothing about them.
+--
+-- A plain ADD COLUMN, deliberately: unlike 0005 this touches no CHECK an existing column carries,
+-- so nothing has to be rebuilt and no foreign key is ever in flight.
+ALTER TABLE node_versions ADD COLUMN segment TEXT
+  CHECK (segment IS NULL OR segment IN ('append', 'snapshot'));
+
+-- Every table that exists was defined through `defineTable`, so its first version is the header
+-- segment — the complete state of the moment it was written, which is exactly what a snapshot is.
+-- Marking it so is what lets "read from the newest snapshot" answer for old tables without a
+-- special case for "no snapshot yet". Every later segment of an existing table is an append.
+UPDATE node_versions
+SET segment = CASE
+  WHEN sequence = (
+    SELECT MIN(inner_version.sequence) FROM node_versions inner_version
+    WHERE inner_version.node_id = node_versions.node_id
+  ) THEN 'snapshot'
+  ELSE 'append'
+END
+WHERE node_id IN (SELECT id FROM nodes WHERE kind = 'table');
+
+-- The two questions every table read asks — "where is the newest snapshot" and "which segments
+-- follow it" — must not scan the whole history to be answered (#30).
+CREATE INDEX node_versions_segment_idx
+  ON node_versions(node_id, segment, sequence DESC);

package/migrations/0013_agents_in_the_tree.sql

@@ -0,0 +1,76 @@
+-- #139: a fifth kind in the shared tree — `agent`. It is a node like the other four: same
+-- `parent_id`, same folder grants, same immutable `node_versions` rows, same R2 body (ADR-0005 §1).
+-- Its body happens to be a JSON definition rather than prose, which the schema neither knows nor
+-- needs to: nothing here creates a second content model, only the CHECK has to learn the word.
+--
+-- SQLite cannot alter a CHECK constraint, so the table is rebuilt — the same rebuild 0005 performed
+-- for `table`, written the same long way round for the same two reasons. Both detours below are
+-- copied from a file that earned them against a real database, not from caution.
+--
+-- ⚠️ First detour: the new table is created under the final name rather than built beside the old
+-- one and renamed over it. `DROP TABLE` on a parent runs an implicit `DELETE FROM` first, so the
+-- moment the old `nodes` goes, every row of `node_versions`, `tree_grants` and `flows` pointing at a
+-- node is a foreign-key violation. `defer_foreign_keys` postpones the complaint to COMMIT but does
+-- not withdraw it, and `ALTER TABLE ... RENAME` does not settle it either: a rename puts the name
+-- back, not the rows. Only inserting the nodes again, under the name the children have referenced
+-- all along, does. This is also why the self-reference below reads `REFERENCES nodes(id)` — the
+-- final name — which is lesson 2 of the three recorded in `0009_no_context_policy.sql`.
+--
+-- ⚠️ Second detour: `node_links` is the only child of `nodes` declared ON DELETE CASCADE, so that
+-- same implicit delete does not merely flag its rows, it removes them — the migration would commit
+-- with every relationship between two documents quietly gone. The rows are carried out of the way
+-- first and put back afterwards. That is a rescue, not a decision about the data: nothing is
+-- dropped, rewritten or reinterpreted here.
+--
+-- ⚠️ On an empty database neither detour is visible, because nothing points at anything. That is
+-- exactly how 0005's first version passed a green suite and then failed against the first database
+-- with content in it, and why the proof for this file is a row count of every referencing table
+-- before and after rather than a migration that merely ran.
+--
+-- `context_policy` is carried over unchanged and still NOT NULL. It is dead for every consumer
+-- (#76) and only D1's refusal to drop a column a CHECK names keeps it here; removing it is #86 and
+-- deliberately not smuggled into this rebuild.
+PRAGMA defer_foreign_keys = TRUE;
+
+-- Plain holding tables on purpose: no keys, no CHECKs, no foreign keys, and the column set taken
+-- from whatever the live table has. Anything enforced here would only be enforced a second time on
+-- the way back in, and a holding table that can reject a row is a holding table that can lose one.
+CREATE TABLE nodes_carry AS SELECT * FROM nodes;
+CREATE TABLE node_links_carry AS SELECT * FROM node_links;
+
+DROP TABLE nodes;
+
+CREATE TABLE nodes (
+  id TEXT PRIMARY KEY NOT NULL,
+  parent_id TEXT REFERENCES nodes(id),
+  kind TEXT NOT NULL CHECK (kind IN ('folder', 'document', 'attachment', 'table', 'agent')),
+  title TEXT NOT NULL CHECK (length(title) BETWEEN 1 AND 240),
+  description TEXT CHECK (description IS NULL OR length(description) <= 2000),
+  context_policy TEXT NOT NULL CHECK (context_policy IN ('pinned', 'relevant', 'explicit')),
+  owner_id TEXT NOT NULL,
+  current_version_id TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  archived_at TEXT
+);
+
+INSERT INTO nodes (
+  id, parent_id, kind, title, description, context_policy, owner_id,
+  current_version_id, created_at, updated_at, archived_at
+)
+SELECT
+  id, parent_id, kind, title, description, context_policy, owner_id,
+  current_version_id, created_at, updated_at, archived_at
+FROM nodes_carry;
+
+-- `OR IGNORE` because whether the cascade above actually fired is SQLite's business, not this
+-- migration's: if it did, this puts the rows back; if it did not, each one is already present under
+-- the same primary key and this is a no-op. Either way `node_links` ends up holding exactly what it
+-- held before, which is the only outcome this statement is permitted to have.
+INSERT OR IGNORE INTO node_links SELECT * FROM node_links_carry;
+
+DROP TABLE nodes_carry;
+DROP TABLE node_links_carry;
+
+CREATE INDEX nodes_parent_idx ON nodes(parent_id, archived_at, title);
+CREATE INDEX nodes_owner_idx ON nodes(owner_id, archived_at);

package/migrations/0014_agent_applications.sql

@@ -0,0 +1,25 @@
+-- #182: which Gate Application an agent node runs as. One row per agent that has a principal, and
+-- nothing else — the row is a NAME, never a credential.
+--
+-- ⚠️ The Application KEY has no column here and must never get one (D27). Gate hands a key out once
+-- in plain text and keeps only its hash, so there is nothing to store even in principle; the key
+-- lives in the runtime's `AGENT_APPLICATION_KEYS` secret and reaches it through the one response
+-- that created the agent. A column for it would turn every backup of this database into a set of
+-- machine credentials.
+--
+-- ⚠️ A table rather than a column on `nodes`, for two reasons. The column would be NULL for every
+-- folder, document, attachment and table there will ever be, which is a shape that says nothing
+-- about four of the five kinds; and adding it would mean rebuilding `nodes` — SQLite cannot alter
+-- a table a CHECK constrains — with the two detours `0013_agents_in_the_tree.sql` records. This
+-- file writes one new table and touches nothing that exists.
+--
+-- ⚠️ Deliberately NOT `ON DELETE CASCADE`, unlike `node_links`. Migration 0013 explains what that
+-- one cascade cost the rebuild it had to survive: an implicit `DELETE FROM` on the parent removed
+-- its rows outright rather than merely flagging them, and they had to be carried out of the way and
+-- put back. A second cascading child would hand the next rebuild the same trap twice. Nodes are
+-- archived, never deleted, so nothing is being kept alive by leaving the cascade off.
+CREATE TABLE agent_applications (
+  node_id TEXT PRIMARY KEY NOT NULL REFERENCES nodes(id),
+  application_id TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-api",
-  "version": "0.6.7",
+  "version": "0.7.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {
@@ -43,9 +43,10 @@
   },
   "dependencies": {
     "@anchrd/gate-sdk": "^0.7.0",
-    "@anchrd/intel-contract": "^0.4.0",
+    "@anchrd/intel-contract": "^0.5.0",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "ajv": "^8.20.0",
+    "fflate": "^0.8.3",
     "hono": "^4.12.32",
     "openid-client": "^6.8.4",
     "ulid": "^3.0.2",

package/dist/knowledge/knowledge.d.ts

@@ -1,2 +0,0 @@
-import type { KnowledgeDeps, KnowledgeService } from "./knowledge.types.js";
-export declare function createKnowledge(deps: KnowledgeDeps): KnowledgeService;