@anchrd/intel-contract 0.8.0 → 0.10.0

package/dist/contract/contract.d.ts

@@ -28,6 +28,7 @@ export declare const NodeKind: z.ZodEnum<{
     attachment: "attachment";
     table: "table";
     agent: "agent";
+    board: "board";
 }>;
 export type NodeKind = z.infer<typeof NodeKind>;
 export declare const ResourceVerb: z.ZodEnum<{
@@ -56,6 +57,7 @@ export declare const Node: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
     }>;
     title: z.ZodString;
     description: z.ZodNullable<z.ZodString>;
@@ -114,6 +116,7 @@ export declare const CreateNodeInput: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
     }>;
     title: z.ZodString;
     description: z.ZodDefault<z.ZodNullable<z.ZodString>>;
@@ -162,6 +165,7 @@ export declare const NodeList: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -202,6 +206,7 @@ export declare const NodeDocument: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -239,6 +244,7 @@ export declare const NodeAttachment: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -296,6 +302,7 @@ export declare const NodeTable: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -320,6 +327,7 @@ export declare const AppendTableRowsResult: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -368,6 +376,7 @@ export declare const UpdateTableRowsResult: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -412,6 +421,7 @@ export declare const DeleteTableRowsResult: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -454,6 +464,374 @@ export declare const RedefineTableInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type RedefineTableInput = z.infer<typeof RedefineTableInput>;
+export declare const BoardMediaType = "application/vnd.anchrd.board+json";
+export declare const ArchivedBoardStatusId = "archived";
+export declare const BoardStatusId: z.ZodString;
+export declare const BoardStatus: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    order: z.ZodNumber;
+}, z.core.$strict>;
+export type BoardStatus = z.infer<typeof BoardStatus>;
+export declare const BoardDefaultStatuses: readonly BoardStatus[];
+/**
+ * Who a task is on: a person Gate knows, or an agent node in this installation (#285).
+ *
+ * ⚠️ A `user` id is deliberately NOT validated against Intel's own id shape. Identity is Gate's
+ * (see the product boundary), so a rule here would be Intel inventing one about somebody else's
+ * identifier — the same reason `GateApplicationId` is a plain bounded string.
+ */
+export declare const BoardAssignee: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"user">;
+    id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"agent">;
+    nodeId: z.ZodString;
+}, z.core.$strict>], "type">;
+export type BoardAssignee = z.infer<typeof BoardAssignee>;
+/**
+ * A task's place among the others, as a fractional index (#285).
+ *
+ * ⚠️ Server-assigned, and a caller can never send one. A move names its NEIGHBOURS and the server
+ * mints a key between theirs, so moving one task writes one task and renumbers nothing — the whole
+ * reason a board is not addressed by position the way a table's rows are (`TableRowPosition`).
+ * A hand-written key could collide, and two tasks sharing a key have no defined order at all.
+ */
+export declare const BoardTaskOrder: z.ZodString;
+export declare const BoardTaskId: z.ZodString;
+export declare const BoardTaskLabel: z.ZodString;
+export declare const BoardTaskDate: z.ZodISODate;
+export declare const BoardTaskDescription: z.ZodString;
+export declare const BoardTask: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodString;
+    assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        nodeId: z.ZodString;
+    }, z.core.$strict>], "type">>;
+    labels: z.ZodArray<z.ZodString>;
+    startDate: z.ZodNullable<z.ZodISODate>;
+    dueDate: z.ZodNullable<z.ZodISODate>;
+    parentId: z.ZodNullable<z.ZodString>;
+    dependsOn: z.ZodArray<z.ZodString>;
+    order: z.ZodString;
+    description: z.ZodString;
+    references: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type BoardTask = z.infer<typeof BoardTask>;
+export declare const BoardDocument: z.ZodObject<{
+    statuses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        order: z.ZodNumber;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            id: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            nodeId: z.ZodString;
+        }, z.core.$strict>], "type">>;
+        labels: z.ZodArray<z.ZodString>;
+        startDate: z.ZodNullable<z.ZodISODate>;
+        dueDate: z.ZodNullable<z.ZodISODate>;
+        parentId: z.ZodNullable<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        order: z.ZodString;
+        description: z.ZodString;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BoardDocument = z.infer<typeof BoardDocument>;
+export declare const BoardMaxTaskDepth = 5;
+export declare const GetBoardInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type GetBoardInput = z.infer<typeof GetBoardInput>;
+export declare const NodeBoard: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+            board: "board";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    board: z.ZodObject<{
+        statuses: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            order: z.ZodNumber;
+        }, z.core.$strict>>;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodString;
+            assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"user">;
+                id: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodLiteral<"agent">;
+                nodeId: z.ZodString;
+            }, z.core.$strict>], "type">>;
+            labels: z.ZodArray<z.ZodString>;
+            startDate: z.ZodNullable<z.ZodISODate>;
+            dueDate: z.ZodNullable<z.ZodISODate>;
+            parentId: z.ZodNullable<z.ZodString>;
+            dependsOn: z.ZodArray<z.ZodString>;
+            order: z.ZodString;
+            description: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    versionId: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type NodeBoard = z.infer<typeof NodeBoard>;
+export declare const BoardStatusInput: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strict>;
+export type BoardStatusInput = z.infer<typeof BoardStatusInput>;
+export declare const ConfigureBoardInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    statuses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type ConfigureBoardInput = z.infer<typeof ConfigureBoardInput>;
+/**
+ * A new task (#285).
+ *
+ * ⚠️ No `baseVersionId`, on this and on every other task operation, and that absence is the
+ * feature. A board is addressed by stable task id and never by position, so two agents touching two
+ * different tasks cannot collide — demanding a base version would invent the `version_conflict`
+ * that #285 exists to remove, and force every caller to read the whole board first.
+ */
+export declare const AddBoardTaskInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodDefault<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        nodeId: z.ZodString;
+    }, z.core.$strict>], "type">>>;
+    labels: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    startDate: z.ZodDefault<z.ZodNullable<z.ZodISODate>>;
+    dueDate: z.ZodDefault<z.ZodNullable<z.ZodISODate>>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    description: z.ZodDefault<z.ZodString>;
+    references: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    afterTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    beforeTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type AddBoardTaskInput = z.infer<typeof AddBoardTaskInput>;
+/**
+ * What a task says about itself.
+ *
+ * ⚠️ Deliberately no `status`, no `parentId` and no `order`: where a task SITS is a move, and a
+ * move is the operation that has to mint an order key and re-check the two cycle rules. Folding
+ * both into one call would mean every field edit pays for those checks and every move could quietly
+ * rewrite a description.
+ */
+export declare const UpdateBoardTaskInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    taskId: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        nodeId: z.ZodString;
+    }, z.core.$strict>], "type">>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    startDate: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+    dueDate: z.ZodOptional<z.ZodNullable<z.ZodISODate>>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type UpdateBoardTaskInput = z.infer<typeof UpdateBoardTaskInput>;
+export declare const MoveBoardTaskInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    taskId: z.ZodString;
+    status: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    afterTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    beforeTaskId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type MoveBoardTaskInput = z.infer<typeof MoveBoardTaskInput>;
+export declare const DeleteBoardTaskInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    taskId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type DeleteBoardTaskInput = z.infer<typeof DeleteBoardTaskInput>;
+export declare const BoardTaskResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+            board: "board";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    task: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodString;
+        assignee: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            id: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"agent">;
+            nodeId: z.ZodString;
+        }, z.core.$strict>], "type">>;
+        labels: z.ZodArray<z.ZodString>;
+        startDate: z.ZodNullable<z.ZodISODate>;
+        dueDate: z.ZodNullable<z.ZodISODate>;
+        parentId: z.ZodNullable<z.ZodString>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        order: z.ZodString;
+        description: z.ZodString;
+        references: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BoardTaskResult = z.infer<typeof BoardTaskResult>;
+export declare const DeleteBoardTaskResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+            board: "board";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    deleted: z.ZodNumber;
+}, z.core.$strict>;
+export type DeleteBoardTaskResult = z.infer<typeof DeleteBoardTaskResult>;
+export declare const ConfigureBoardResult: z.ZodObject<{
+    node: z.ZodObject<{
+        id: z.ZodString;
+        parentId: z.ZodNullable<z.ZodString>;
+        kind: z.ZodEnum<{
+            folder: "folder";
+            document: "document";
+            attachment: "attachment";
+            table: "table";
+            agent: "agent";
+            board: "board";
+        }>;
+        title: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+        ownerId: z.ZodString;
+        currentVersionId: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        archivedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>;
+    version: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        sequence: z.ZodNumber;
+        contentKey: z.ZodString;
+        mediaType: z.ZodString;
+        contentHash: z.ZodString;
+        size: z.ZodNumber;
+        segment: z.ZodNullable<z.ZodEnum<{
+            append: "append";
+            snapshot: "snapshot";
+        }>>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    statuses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        order: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ConfigureBoardResult = z.infer<typeof ConfigureBoardResult>;
 export declare const AgentMediaType = "application/vnd.anchrd.agent+json";
 export declare const AgentReferenceRole: z.ZodEnum<{
     "system-message": "system-message";
@@ -470,6 +848,41 @@ export declare const AgentReference: z.ZodObject<{
     }>;
 }, z.core.$strict>;
 export type AgentReference = z.infer<typeof AgentReference>;
+/**
+ * Which kinds of node each role can actually be given (#255).
+ *
+ * ⚠️ Not every role takes every kind, and the reasons are about what the runtime DOES with a
+ * reference rather than about tidiness:
+ *
+ *   `memory` is a folder because the agent WRITES there — `agent_remember` creates a note inside
+ *   it. A single document as memory would mean the agent overwrites the document it was given.
+ *
+ *   `semantic-context` is a folder because it is a search SPACE, searched per folder by
+ *   `loop/scoped-search`. A single document is not a narrower search space; reading it whole is a
+ *   different behaviour, and one that gets named before it is introduced, not slipped in.
+ *
+ *   `system-message` reads single nodes already and takes a document or a table as well as a
+ *   folder. A document is the natural case — a skill somebody wrote as ordinary text — and a table
+ *   is the same read: the runtime asks intel for the node and prepends its content, which for a
+ *   table is its CSV.
+ *
+ * ⚠️ `folder` stays on `system-message` although a folder carries no content of its own. Every
+ * definition written before #255 could only name folders, and taking the combination away here
+ * would refuse the next save of an agent that has been working for months — "existing definitions
+ * stay valid" is not only about reading them.
+ *
+ * ⚠️ This is the ONE place the rule lives. The screen offers what it says and the write path
+ * refuses what it forbids; a surface that made its own list would eventually disagree with the
+ * other, and the one that matters is whichever runs last.
+ */
+export declare const AgentReferenceKinds: {
+    readonly "system-message": readonly ["folder", "document", "table"];
+    readonly "semantic-context": readonly ["folder"];
+    readonly memory: readonly ["folder"];
+};
+export declare function agentReferenceAccepts(role: AgentReferenceRole, kind: NodeKind): boolean;
+/** The roles a node of this kind may be given — the same rule, read from the other side. */
+export declare function agentReferenceRolesFor(kind: NodeKind): AgentReferenceRole[];
 export declare const AgentScheduleTarget: z.ZodObject<{
     kind: z.ZodEnum<{
         document: "document";
@@ -673,6 +1086,116 @@ export declare const RunAgentNowInput: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type RunAgentNowInput = z.infer<typeof RunAgentNowInput>;
+/**
+ * What one agent has actually cost, read out of Cloudflare's AI Gateway log (#251).
+ *
+ * ⚠️ Intel computes none of this from tokens and a price table. The gateway publishes the billed
+ * figure per call, and that figure is the debit from the Cloudflare balance 1:1 — Cloudflare takes
+ * its 5 % when the balance is loaded and passes inference through unchanged (measured 2026-08-07).
+ * A second, self-maintained answer beside it would be wrong on the day the two disagreed, and the
+ * wrong one would be the one on screen.
+ *
+ * ⚠️ `status` travels with the numbers and may never be dropped. `runs: []` means "cost nothing"
+ * only when `status` is `read`; under `not_configured` or `unreadable` it means "not known", and a
+ * screen that renders the two alike reports an outage as a saving.
+ */
+export declare const AgentCostStatus: z.ZodEnum<{
+    read: "read";
+    not_configured: "not_configured";
+    unreadable: "unreadable";
+}>;
+export type AgentCostStatus = z.infer<typeof AgentCostStatus>;
+export declare const AgentRunCost: z.ZodObject<{
+    runId: z.ZodString;
+    cost: z.ZodNumber;
+    calls: z.ZodNumber;
+}, z.core.$strict>;
+export type AgentRunCost = z.infer<typeof AgentRunCost>;
+export declare const AgentCostWindow: z.ZodObject<{
+    days: z.ZodNumber;
+    cost: z.ZodNumber;
+    calls: z.ZodNumber;
+    models: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type AgentCostWindow = z.infer<typeof AgentCostWindow>;
+export declare const AgentCosts: z.ZodObject<{
+    status: z.ZodEnum<{
+        read: "read";
+        not_configured: "not_configured";
+        unreadable: "unreadable";
+    }>;
+    currency: z.ZodLiteral<"USD">;
+    runs: z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        cost: z.ZodNumber;
+        calls: z.ZodNumber;
+    }, z.core.$strict>>;
+    windows: z.ZodArray<z.ZodObject<{
+        days: z.ZodNumber;
+        cost: z.ZodNumber;
+        calls: z.ZodNumber;
+        models: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    partial: z.ZodBoolean;
+}, z.core.$strict>;
+export type AgentCosts = z.infer<typeof AgentCosts>;
+/**
+ * What the models on offer cost and how much they hold (#257).
+ *
+ * ⚠️ `source` is per ENTRY and not per response, and that is not over-engineering. Cloudflare
+ * publishes figures for the models it serves itself and none at all for the Anthropic models it
+ * resells through Unified Billing — so a perfectly healthy read still leaves half the list on a
+ * written-out table, and one flag for the whole answer would call either the read stale or the
+ * table live.
+ */
+export declare const ModelPrice: z.ZodObject<{
+    inputPerMillion: z.ZodNumber;
+    outputPerMillion: z.ZodNumber;
+}, z.core.$strict>;
+export type ModelPrice = z.infer<typeof ModelPrice>;
+export declare const ModelCatalogEntry: z.ZodObject<{
+    provider: z.ZodEnum<{
+        "workers-ai": "workers-ai";
+        anthropic: "anthropic";
+    }>;
+    model: z.ZodString;
+    name: z.ZodString;
+    contextTokens: z.ZodNullable<z.ZodNumber>;
+    price: z.ZodNullable<z.ZodObject<{
+        inputPerMillion: z.ZodNumber;
+        outputPerMillion: z.ZodNumber;
+    }, z.core.$strict>>;
+    source: z.ZodEnum<{
+        cloudflare: "cloudflare";
+        builtin: "builtin";
+    }>;
+}, z.core.$strict>;
+export type ModelCatalogEntry = z.infer<typeof ModelCatalogEntry>;
+export declare const ModelCatalog: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<{
+            "workers-ai": "workers-ai";
+            anthropic: "anthropic";
+        }>;
+        model: z.ZodString;
+        name: z.ZodString;
+        contextTokens: z.ZodNullable<z.ZodNumber>;
+        price: z.ZodNullable<z.ZodObject<{
+            inputPerMillion: z.ZodNumber;
+            outputPerMillion: z.ZodNumber;
+        }, z.core.$strict>>;
+        source: z.ZodEnum<{
+            cloudflare: "cloudflare";
+            builtin: "builtin";
+        }>;
+    }, z.core.$strict>>;
+    liveStatus: z.ZodEnum<{
+        read: "read";
+        not_configured: "not_configured";
+        unreadable: "unreadable";
+    }>;
+}, z.core.$strict>;
+export type ModelCatalog = z.infer<typeof ModelCatalog>;
 export declare const ListAgentsInput: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     includeArchived: z.ZodDefault<z.ZodBoolean>;
@@ -727,6 +1250,7 @@ export declare const NodeAgent: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -811,6 +1335,7 @@ export declare const CreatedAgent: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -898,6 +1423,7 @@ export declare const AgentList: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -992,6 +1518,7 @@ export declare const NodeGraph: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -2216,6 +2743,7 @@ export declare const RelationNodeKind: z.ZodEnum<{
     attachment: "attachment";
     table: "table";
     agent: "agent";
+    board: "board";
     flow: "flow";
 }>;
 export type RelationNodeKind = z.infer<typeof RelationNodeKind>;
@@ -2227,6 +2755,7 @@ export declare const RelationNode: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2278,6 +2807,7 @@ export declare const RelationGraph: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
             flow: "flow";
         }>;
         title: z.ZodString;
@@ -2648,6 +3178,7 @@ export declare const BundleEntryKind: z.ZodEnum<{
     attachment: "attachment";
     table: "table";
     agent: "agent";
+    board: "board";
     flow: "flow";
 }>;
 export type BundleEntryKind = z.infer<typeof BundleEntryKind>;
@@ -2659,6 +3190,7 @@ export declare const BundleManifestEntry: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2686,6 +3218,7 @@ export declare const BundleManifest: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
             flow: "flow";
         }>;
         title: z.ZodString;

package/dist/contract/contract.js

@@ -31,15 +31,17 @@ export const SessionUser = z.strictObject({
 export const IntelCapabilities = z.strictObject({
     agentRuntime: z.boolean(),
 });
-// The fourth kind is `table` (#40) and the fifth is `agent` (#139). Each is a kind of node, not a
-// kind of thing: it hangs in the same folder tree, inherits the same folder grants, carries the
-// same immutable versions and the same R2 body as a document (ADR-0004 §1, ADR-0005 §1). Only the
-// media type and the operations below differ.
+// The fourth kind is `table` (#40), the fifth is `agent` (#139) and the sixth is `board` (#285).
+// Each is a kind of node, not a kind of thing: it hangs in the same folder tree, inherits the same
+// folder grants, carries the same immutable versions and the same R2 body as a document
+// (ADR-0004 §1, ADR-0005 §1). Only the media type and the operations below differ.
 //
 // ⚠️ `agent` being optional is load-bearing (ADR-0005 §1): an installation without a single agent
 // node is complete, not unfinished, and nothing here asks anyone to classify a document as a skill
-// or a policy in order to file it.
-export const NodeKind = z.enum(["folder", "document", "attachment", "table", "agent"]);
+// or a policy in order to file it. The same holds for `board`: it is a file somebody may make, not
+// a place the tree grows a special corner for — which is exactly why a board is one node carrying
+// its tasks and not a folder that only tasks may live in (#285).
+export const NodeKind = z.enum(["folder", "document", "attachment", "table", "agent", "board"]);
 // ⚠️ There is no `ContextPolicy`, and it is not coming back in this shape (#76). It said whether a
 // document should be pinned into a context, be found by relevance, or be named explicitly — an
 // instruction to a retrieval Intel does not perform. Intel hands out references and the agent
@@ -266,6 +268,224 @@ export const RedefineTableInput = z.strictObject({
     }, { error: "A current column can fill only one new column" }),
     idempotencyKey: z.string().min(8).max(200),
 });
+// ── The board (#285) ─────────────────────────────────────────────────────────────────────────────
+//
+// A board's body is a whole project board — the status list and every task — stored as one
+// validated JSON version in R2, exactly the way an agent's definition is. It is a kind of node and
+// not a kind of thing (see `NodeKind`): it hangs in a folder, inherits that folder's grants, has
+// versions and is exported like everything else. Its own media type exists so a reader can tell a
+// board from prose without parsing it.
+export const BoardMediaType = "application/vnd.anchrd.board+json";
+// ⚠️ `archived` belongs to EVERY status list and cannot be configured away (#285). It is the shelf
+// tasks are swept onto, so that being finished with a task never has to mean deleting it — and
+// getting one back is an explicit move to another status, never an undelete.
+export const ArchivedBoardStatusId = "archived";
+// A status id is referenced by every task that sits in that column, so it is machine-shaped and
+// bounded rather than free text. Renaming a column changes its LABEL; the id stays, and no task has
+// to be rewritten to follow it.
+export const BoardStatusId = z.string().regex(/^[a-z0-9][a-z0-9_]{0,39}$/);
+export const BoardStatus = z.strictObject({
+    id: BoardStatusId,
+    label: z.string().trim().min(1).max(60),
+    // ⚠️ Server-assigned from the position in `ConfigureBoardInput.statuses`, never sent. Two columns
+    // both claiming position 3 is a board no surface could draw, and it is a state nobody has to be
+    // able to reason about if it cannot be expressed.
+    order: z.number().int().nonnegative(),
+});
+// What a board starts out with. Five columns, of which the last one is the fixed `archived` shelf.
+export const BoardDefaultStatuses = [
+    { id: "backlog", label: "Backlog", order: 0 },
+    { id: "in_progress", label: "In progress", order: 1 },
+    { id: "review", label: "Review", order: 2 },
+    { id: "done", label: "Done", order: 3 },
+    { id: ArchivedBoardStatusId, label: "Archived", order: 4 },
+];
+/**
+ * Who a task is on: a person Gate knows, or an agent node in this installation (#285).
+ *
+ * ⚠️ A `user` id is deliberately NOT validated against Intel's own id shape. Identity is Gate's
+ * (see the product boundary), so a rule here would be Intel inventing one about somebody else's
+ * identifier — the same reason `GateApplicationId` is a plain bounded string.
+ */
+export const BoardAssignee = z.discriminatedUnion("type", [
+    z.strictObject({ type: z.literal("user"), id: z.string().min(1).max(255) }),
+    z.strictObject({ type: z.literal("agent"), nodeId: IntelId }),
+]);
+/**
+ * A task's place among the others, as a fractional index (#285).
+ *
+ * ⚠️ Server-assigned, and a caller can never send one. A move names its NEIGHBOURS and the server
+ * mints a key between theirs, so moving one task writes one task and renumbers nothing — the whole
+ * reason a board is not addressed by position the way a table's rows are (`TableRowPosition`).
+ * A hand-written key could collide, and two tasks sharing a key have no defined order at all.
+ */
+export const BoardTaskOrder = z.string().regex(/^[0-9A-Za-z]{1,64}$/);
+export const BoardTaskId = IntelId;
+export const BoardTaskLabel = z.string().trim().min(1).max(60);
+// A day, not an instant. A task is due on a date; giving it a time zone would make the same task
+// due on two different days depending on who is looking at it.
+export const BoardTaskDate = z.iso.date();
+// Markdown, and capped: a task's description is a card, and what needs more than this is a document
+// the task can point at through `references`.
+export const BoardTaskDescription = z.string().max(20_000);
+export const BoardTask = z.strictObject({
+    id: BoardTaskId,
+    title: z.string().trim().min(1).max(240),
+    status: BoardStatusId,
+    assignee: BoardAssignee.nullable(),
+    labels: z.array(BoardTaskLabel).max(32),
+    startDate: BoardTaskDate.nullable(),
+    dueDate: BoardTaskDate.nullable(),
+    // ⚠️ The whole hierarchy in one field, deliberately: epic, task and subtask are a DEPTH and not a
+    // type (#285). A `kind` beside it would allow a subtask under nothing and an epic under an epic,
+    // and every surface would then need its own opinion about which combinations mean anything.
+    parentId: BoardTaskId.nullable(),
+    // ⚠️ Board-internal only, enforced on the write path: a dependency on a task in another board
+    // would hang this node on a file that can change without anyone here noticing. Across boards the
+    // link is `references`, which points at the board NODE and lands in the link graph.
+    dependsOn: z.array(BoardTaskId).max(64),
+    order: BoardTaskOrder,
+    description: BoardTaskDescription,
+    // Node ids. They land in the link graph as `text` links, the same way a document's inline links
+    // do, so what a board points at is visible from the other side too.
+    references: z.array(IntelId).max(64),
+});
+// The whole board, as it is stored and as it is read. There is no second representation to keep in
+// step with it — this document is the file.
+export const BoardDocument = z.strictObject({
+    statuses: z.array(BoardStatus).min(1).max(32),
+    tasks: z.array(BoardTask).max(5_000),
+});
+// How deep `parentId` may nest. Five is epic → task → subtask with room left over; without a bound
+// a chain of a thousand tasks would be a valid board that no view can draw and no walk can afford.
+export const BoardMaxTaskDepth = 5;
+export const GetBoardInput = z.strictObject({ nodeId: IntelId });
+// A board as it is read. `versionId` is `null` while nothing has been written yet — the same answer
+// a table gives before its header exists — and the document is then the defaults.
+export const NodeBoard = z.strictObject({
+    node: Node,
+    board: BoardDocument,
+    versionId: IntelId.nullable(),
+});
+export const BoardStatusInput = z.strictObject({
+    id: BoardStatusId,
+    label: z.string().trim().min(1).max(60),
+});
+// The status list, written whole and in the order it should be drawn — never a patch. Adding,
+// renaming and reordering are all this one call, and `archived` has to be in what it is given.
+export const ConfigureBoardInput = z.strictObject({
+    nodeId: IntelId,
+    statuses: z
+        .array(BoardStatusInput)
+        .min(1)
+        .max(32)
+        .refine((statuses) => new Set(statuses.map((status) => status.id)).size === statuses.length, {
+        error: "Status ids must be distinct",
+    })
+        .refine((statuses) => statuses.some((status) => status.id === ArchivedBoardStatusId), {
+        error: `The "${ArchivedBoardStatusId}" status cannot be removed`,
+    }),
+    idempotencyKey: z.string().min(8).max(200),
+});
+/**
+ * A new task (#285).
+ *
+ * ⚠️ No `baseVersionId`, on this and on every other task operation, and that absence is the
+ * feature. A board is addressed by stable task id and never by position, so two agents touching two
+ * different tasks cannot collide — demanding a base version would invent the `version_conflict`
+ * that #285 exists to remove, and force every caller to read the whole board first.
+ */
+export const AddBoardTaskInput = z.strictObject({
+    nodeId: IntelId,
+    title: z.string().trim().min(1).max(240),
+    // Omitted means the first status that is not `archived`: a new task belongs on the board, not on
+    // the shelf.
+    status: BoardStatusId.optional(),
+    assignee: BoardAssignee.nullable().default(null),
+    labels: z.array(BoardTaskLabel).max(32).default([]),
+    startDate: BoardTaskDate.nullable().default(null),
+    dueDate: BoardTaskDate.nullable().default(null),
+    parentId: BoardTaskId.nullable().default(null),
+    dependsOn: z.array(BoardTaskId).max(64).default([]),
+    description: BoardTaskDescription.default(""),
+    references: z.array(IntelId).max(64).default([]),
+    // Where among its neighbours it goes. Both absent puts it last in its column.
+    afterTaskId: BoardTaskId.nullable().default(null),
+    beforeTaskId: BoardTaskId.nullable().default(null),
+    idempotencyKey: z.string().min(8).max(200),
+});
+/**
+ * What a task says about itself.
+ *
+ * ⚠️ Deliberately no `status`, no `parentId` and no `order`: where a task SITS is a move, and a
+ * move is the operation that has to mint an order key and re-check the two cycle rules. Folding
+ * both into one call would mean every field edit pays for those checks and every move could quietly
+ * rewrite a description.
+ */
+export const UpdateBoardTaskInput = z
+    .strictObject({
+    nodeId: IntelId,
+    taskId: BoardTaskId,
+    title: z.string().trim().min(1).max(240).optional(),
+    assignee: BoardAssignee.nullable().optional(),
+    labels: z.array(BoardTaskLabel).max(32).optional(),
+    startDate: BoardTaskDate.nullable().optional(),
+    dueDate: BoardTaskDate.nullable().optional(),
+    dependsOn: z.array(BoardTaskId).max(64).optional(),
+    description: BoardTaskDescription.optional(),
+    references: z.array(IntelId).max(64).optional(),
+    idempotencyKey: z.string().min(8).max(200),
+})
+    .refine((input) => input.title !== undefined ||
+    input.assignee !== undefined ||
+    input.labels !== undefined ||
+    input.startDate !== undefined ||
+    input.dueDate !== undefined ||
+    input.dependsOn !== undefined ||
+    input.description !== undefined ||
+    input.references !== undefined, { error: "At least one change is required" });
+// Where a task sits: its column, its parent, its place among its neighbours. Archiving is this call
+// with `status: "archived"` — there is no separate verb, because it is not a separate act.
+export const MoveBoardTaskInput = z
+    .strictObject({
+    nodeId: IntelId,
+    taskId: BoardTaskId,
+    status: BoardStatusId.optional(),
+    parentId: BoardTaskId.nullable().optional(),
+    afterTaskId: BoardTaskId.nullable().default(null),
+    beforeTaskId: BoardTaskId.nullable().default(null),
+    idempotencyKey: z.string().min(8).max(200),
+})
+    .refine((input) => input.status !== undefined ||
+    input.parentId !== undefined ||
+    input.afterTaskId !== null ||
+    input.beforeTaskId !== null, { error: "A move needs a status, a parent or a neighbour" });
+// ⚠️ Deleting cascades to every descendant, and the count comes back so a surface can warn BEFORE
+// asking. See `DeleteBoardTaskResult`.
+export const DeleteBoardTaskInput = z.strictObject({
+    nodeId: IntelId,
+    taskId: BoardTaskId,
+    idempotencyKey: z.string().min(8).max(200),
+});
+// The one task that was written, not the whole board: a board can hold thousands of tasks, and
+// answering a one-card edit with all of them would make every write pay for the read.
+export const BoardTaskResult = z.strictObject({
+    node: Node,
+    version: NodeVersion,
+    task: BoardTask,
+});
+// `deleted` counts the task AND every descendant that went with it, so a caller can say what
+// happened rather than "done".
+export const DeleteBoardTaskResult = z.strictObject({
+    node: Node,
+    version: NodeVersion,
+    deleted: z.number().int().positive(),
+});
+export const ConfigureBoardResult = z.strictObject({
+    node: Node,
+    version: NodeVersion,
+    statuses: z.array(BoardStatus),
+});
 // ── The agent definition (#139, ADR-0005 §4) ─────────────────────────────────────────────────────
 //
 // An agent's body is a definition, stored as an immutable version in R2 exactly like a document's.
@@ -281,6 +501,45 @@ export const AgentMediaType = "application/vnd.anchrd.agent+json";
 //   memory            write target — ordinary Knowledge, versioned and readable like everything else
 export const AgentReferenceRole = z.enum(["system-message", "semantic-context", "memory"]);
 export const AgentReference = z.strictObject({ nodeId: IntelId, role: AgentReferenceRole });
+/**
+ * Which kinds of node each role can actually be given (#255).
+ *
+ * ⚠️ Not every role takes every kind, and the reasons are about what the runtime DOES with a
+ * reference rather than about tidiness:
+ *
+ *   `memory` is a folder because the agent WRITES there — `agent_remember` creates a note inside
+ *   it. A single document as memory would mean the agent overwrites the document it was given.
+ *
+ *   `semantic-context` is a folder because it is a search SPACE, searched per folder by
+ *   `loop/scoped-search`. A single document is not a narrower search space; reading it whole is a
+ *   different behaviour, and one that gets named before it is introduced, not slipped in.
+ *
+ *   `system-message` reads single nodes already and takes a document or a table as well as a
+ *   folder. A document is the natural case — a skill somebody wrote as ordinary text — and a table
+ *   is the same read: the runtime asks intel for the node and prepends its content, which for a
+ *   table is its CSV.
+ *
+ * ⚠️ `folder` stays on `system-message` although a folder carries no content of its own. Every
+ * definition written before #255 could only name folders, and taking the combination away here
+ * would refuse the next save of an agent that has been working for months — "existing definitions
+ * stay valid" is not only about reading them.
+ *
+ * ⚠️ This is the ONE place the rule lives. The screen offers what it says and the write path
+ * refuses what it forbids; a surface that made its own list would eventually disagree with the
+ * other, and the one that matters is whichever runs last.
+ */
+export const AgentReferenceKinds = {
+    "system-message": ["folder", "document", "table"],
+    "semantic-context": ["folder"],
+    memory: ["folder"],
+};
+export function agentReferenceAccepts(role, kind) {
+    return AgentReferenceKinds[role].includes(kind);
+}
+/** The roles a node of this kind may be given — the same rule, read from the other side. */
+export function agentReferenceRolesFor(kind) {
+    return AgentReferenceRole.options.filter((role) => agentReferenceAccepts(role, kind));
+}
 // A `document` target means the content of that document is the instruction — a "skill" somebody
 // wrote as ordinary text; a `flow` target means a run is started through Intel MCP and worked step
 // by step. Both are references, so nothing in here goes stale (ADR-0005 §4).
@@ -442,6 +701,68 @@ export const RunAgentNowInput = z.strictObject({
     nodeId: IntelId,
     target: AgentScheduleTarget,
 });
+/**
+ * What one agent has actually cost, read out of Cloudflare's AI Gateway log (#251).
+ *
+ * ⚠️ Intel computes none of this from tokens and a price table. The gateway publishes the billed
+ * figure per call, and that figure is the debit from the Cloudflare balance 1:1 — Cloudflare takes
+ * its 5 % when the balance is loaded and passes inference through unchanged (measured 2026-08-07).
+ * A second, self-maintained answer beside it would be wrong on the day the two disagreed, and the
+ * wrong one would be the one on screen.
+ *
+ * ⚠️ `status` travels with the numbers and may never be dropped. `runs: []` means "cost nothing"
+ * only when `status` is `read`; under `not_configured` or `unreadable` it means "not known", and a
+ * screen that renders the two alike reports an outage as a saving.
+ */
+export const AgentCostStatus = z.enum(["read", "not_configured", "unreadable"]);
+export const AgentRunCost = z.strictObject({
+    runId: z.string(),
+    cost: z.number(),
+    calls: z.number(),
+});
+export const AgentCostWindow = z.strictObject({
+    days: z.number(),
+    cost: z.number(),
+    calls: z.number(),
+    // Which models produced this figure. It is here so the model select can say the number is about
+    // the PAST (#257) — a reader who switched model would otherwise take it for a forecast.
+    models: z.array(z.string()),
+});
+export const AgentCosts = z.strictObject({
+    status: AgentCostStatus,
+    currency: z.literal("USD"),
+    runs: z.array(AgentRunCost),
+    windows: z.array(AgentCostWindow),
+    // The read hit its page limit, so every total above is a floor rather than a total.
+    partial: z.boolean(),
+});
+/**
+ * What the models on offer cost and how much they hold (#257).
+ *
+ * ⚠️ `source` is per ENTRY and not per response, and that is not over-engineering. Cloudflare
+ * publishes figures for the models it serves itself and none at all for the Anthropic models it
+ * resells through Unified Billing — so a perfectly healthy read still leaves half the list on a
+ * written-out table, and one flag for the whole answer would call either the read stale or the
+ * table live.
+ */
+export const ModelPrice = z.strictObject({
+    inputPerMillion: z.number(),
+    outputPerMillion: z.number(),
+});
+export const ModelCatalogEntry = z.strictObject({
+    provider: z.enum(["workers-ai", "anthropic"]),
+    model: z.string(),
+    name: z.string(),
+    contextTokens: z.number().nullable(),
+    // `null` where this installation has no figure. Never zero and never a guess — an invented number
+    // is a false statement about money.
+    price: ModelPrice.nullable(),
+    source: z.enum(["cloudflare", "builtin"]),
+});
+export const ModelCatalog = z.strictObject({
+    entries: z.array(ModelCatalogEntry),
+    liveStatus: z.enum(["read", "not_configured", "unreadable"]),
+});
 // ⚠️ Three states, not two, and the same three the flow list makes: omitted is the whole tree,
 // `null` is the root level, an ID is that folder. "Which agents may I use" is a question about the
 // tree rather than about one folder, so the useful answer has to be reachable without knowing where
@@ -1116,6 +1437,7 @@ export const RelationNodeKind = z.enum([
     "attachment",
     "table",
     "agent",
+    "board",
     "flow",
 ]);
 export const RelationNode = z.strictObject({
@@ -1300,7 +1622,7 @@ export const FlowRunHistory = z.strictObject({
 // The one name the importer looks for at the zip root. A different spelling would make a bundle a
 // naked folder, so the constant lives in the contract rather than in each surface.
 export const BundleManifestFilename = "manifest.json";
-// What a bundle entry can be. `flow` joins the five node kinds because a flow shares the folder
+// What a bundle entry can be. `flow` joins the six node kinds because a flow shares the folder
 // tree without being a node (ADR-0004), and the bundle mirrors the tree, not the tables.
 export const BundleEntryKind = z.enum([
     "folder",
@@ -1308,6 +1630,7 @@ export const BundleEntryKind = z.enum([
     "table",
     "attachment",
     "agent",
+    "board",
     "flow",
 ]);
 // One entry of the manifest: the identity a re-import needs, next to the relative path where the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-contract",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {