@anchrd/intel-contract 0.9.0 → 0.11.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,419 @@ 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;
+    terminal: z.ZodBoolean;
+}, 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;
+/**
+ * The tasks one task waits for (#285), each of them at most once (anchrd/intel#318).
+ *
+ * ⚠️ 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.
+ *
+ * ⚠️ Refused rather than folded together, the same shape as the status ids in `ConfigureBoardInput`.
+ * A repeat carries no information — but that is a fact about the value, not about the answer: a
+ * caller handed back a shorter list than it sent is told nothing, and composes the same one again.
+ * The refusal names the mistake once, and the caller is holding the list it has to fix. (The one
+ * place a repeat is folded instead is `upgradeStoredBoard`, where there is no caller to tell.)
+ *
+ * ⚠️ It sits on the STORED task as well as on the two inputs, so a consumer may rely on it rather
+ * than defend against it — `createBoardGraph` mints one edge key per pair, and a second one threw
+ * the whole graph view off the screen for everybody looking at that board.
+ */
+export declare const BoardTaskDependsOn: z.ZodArray<z.ZodString>;
+/**
+ * A task's labels, each of them at most once (anchrd/intel#318).
+ *
+ * ⚠️ The same rule the detail panel has always applied to what a person types — it refuses to add a
+ * label the task already carries — stated where every surface meets it, because the MCP write path
+ * did not. A repeated label draws the same chip twice on the card, with two remove buttons of which
+ * either takes both away, and weights that word higher in the search text (`indexing.ts`).
+ */
+export declare const BoardTaskLabels: z.ZodArray<z.ZodString>;
+/**
+ * The Intel nodes a task points at, each of them at most once (anchrd/intel#318).
+ *
+ * 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.
+ *
+ * ⚠️ Distinct for the same reason as `labels`: the picker in the detail panel already refuses one
+ * the task holds, and the link graph counts a repeat once anyway (`ON CONFLICT DO NOTHING`), so a
+ * duplicate is a second row in the panel and nothing else — which is exactly the kind of value that
+ * has no reading and should not be storable.
+ */
+export declare const BoardTaskReferences: z.ZodArray<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;
+        terminal: z.ZodBoolean;
+    }, 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;
+            terminal: z.ZodBoolean;
+        }, 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;
+    terminal: z.ZodOptional<z.ZodBoolean>;
+}, 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;
+        terminal: z.ZodOptional<z.ZodBoolean>;
+    }, 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;
+        terminal: z.ZodBoolean;
+    }, 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";
@@ -872,6 +1295,7 @@ export declare const NodeAgent: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -956,6 +1380,7 @@ export declare const CreatedAgent: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -1043,6 +1468,7 @@ export declare const AgentList: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -1137,6 +1563,7 @@ export declare const NodeGraph: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
         }>;
         title: z.ZodString;
         description: z.ZodNullable<z.ZodString>;
@@ -1379,6 +1806,7 @@ export declare const ToolCatalog: z.ZodObject<{
         }, z.core.$strict>;
         fingerprint: z.ZodString;
     }, z.core.$strict>>;
+    reached: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type ToolCatalog = z.infer<typeof ToolCatalog>;
 /**
@@ -2361,6 +2789,7 @@ export declare const RelationNodeKind: z.ZodEnum<{
     attachment: "attachment";
     table: "table";
     agent: "agent";
+    board: "board";
     flow: "flow";
 }>;
 export type RelationNodeKind = z.infer<typeof RelationNodeKind>;
@@ -2372,6 +2801,7 @@ export declare const RelationNode: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2423,6 +2853,7 @@ export declare const RelationGraph: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
             flow: "flow";
         }>;
         title: z.ZodString;
@@ -2793,6 +3224,7 @@ export declare const BundleEntryKind: z.ZodEnum<{
     attachment: "attachment";
     table: "table";
     agent: "agent";
+    board: "board";
     flow: "flow";
 }>;
 export type BundleEntryKind = z.infer<typeof BundleEntryKind>;
@@ -2804,6 +3236,7 @@ export declare const BundleManifestEntry: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2831,6 +3264,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,306 @@ 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(),
+    /**
+     * Whether standing in this column means the work is finished (anchrd/intel#311).
+     *
+     * It answers the one question #285 left open — when a `dependsOn` is satisfied — and it is the
+     * ONLY answer to it. There is deliberately no second reading anywhere: a surface that decided
+     * "done" for itself would decide it differently the first time somebody reconfigured a board.
+     *
+     * ⚠️ It is a property of the status, not a position in the list, and that distinction is the
+     * whole ticket. #286 first read "the last column before `archived`" as done, reasoning by symmetry
+     * with the server's rule that a new task lands in the first column that is not `archived`. But a
+     * status list is configurable on purpose, so `… done → blocked → archived` makes "blocked" mean
+     * finished — silently, with a wrong blocked marker as the only symptom.
+     *
+     * ⚠️ Several columns may carry it. "Done" and a cancelled-like column are both ends of the work,
+     * and nothing waiting on a cancelled task is still blocked by it.
+     */
+    terminal: z.boolean(),
+});
+// What a board starts out with. Five columns, of which the last one is the fixed `archived` shelf.
+// `done` and the shelf are where work ends; the three before them are not (anchrd/intel#311).
+export const BoardDefaultStatuses = [
+    { id: "backlog", label: "Backlog", order: 0, terminal: false },
+    { id: "in_progress", label: "In progress", order: 1, terminal: false },
+    { id: "review", label: "Review", order: 2, terminal: false },
+    { id: "done", label: "Done", order: 3, terminal: true },
+    { id: ArchivedBoardStatusId, label: "Archived", order: 4, terminal: true },
+];
+/**
+ * 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);
+/**
+ * The tasks one task waits for (#285), each of them at most once (anchrd/intel#318).
+ *
+ * ⚠️ 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.
+ *
+ * ⚠️ Refused rather than folded together, the same shape as the status ids in `ConfigureBoardInput`.
+ * A repeat carries no information — but that is a fact about the value, not about the answer: a
+ * caller handed back a shorter list than it sent is told nothing, and composes the same one again.
+ * The refusal names the mistake once, and the caller is holding the list it has to fix. (The one
+ * place a repeat is folded instead is `upgradeStoredBoard`, where there is no caller to tell.)
+ *
+ * ⚠️ It sits on the STORED task as well as on the two inputs, so a consumer may rely on it rather
+ * than defend against it — `createBoardGraph` mints one edge key per pair, and a second one threw
+ * the whole graph view off the screen for everybody looking at that board.
+ */
+export const BoardTaskDependsOn = z
+    .array(BoardTaskId)
+    .max(64)
+    .refine((ids) => new Set(ids).size === ids.length, {
+    error: "A task can be named only once in dependsOn",
+});
+/**
+ * A task's labels, each of them at most once (anchrd/intel#318).
+ *
+ * ⚠️ The same rule the detail panel has always applied to what a person types — it refuses to add a
+ * label the task already carries — stated where every surface meets it, because the MCP write path
+ * did not. A repeated label draws the same chip twice on the card, with two remove buttons of which
+ * either takes both away, and weights that word higher in the search text (`indexing.ts`).
+ */
+export const BoardTaskLabels = z
+    .array(BoardTaskLabel)
+    .max(32)
+    .refine((labels) => new Set(labels).size === labels.length, {
+    error: "A label can be named only once",
+});
+/**
+ * The Intel nodes a task points at, each of them at most once (anchrd/intel#318).
+ *
+ * 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.
+ *
+ * ⚠️ Distinct for the same reason as `labels`: the picker in the detail panel already refuses one
+ * the task holds, and the link graph counts a repeat once anyway (`ON CONFLICT DO NOTHING`), so a
+ * duplicate is a second row in the panel and nothing else — which is exactly the kind of value that
+ * has no reading and should not be storable.
+ */
+export const BoardTaskReferences = z
+    .array(IntelId)
+    .max(64)
+    .refine((ids) => new Set(ids).size === ids.length, {
+    error: "A node can be referenced only once",
+});
+export const BoardTask = z.strictObject({
+    id: BoardTaskId,
+    title: z.string().trim().min(1).max(240),
+    status: BoardStatusId,
+    assignee: BoardAssignee.nullable(),
+    labels: BoardTaskLabels,
+    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(),
+    dependsOn: BoardTaskDependsOn,
+    order: BoardTaskOrder,
+    description: BoardTaskDescription,
+    references: BoardTaskReferences,
+});
+// 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),
+    /**
+     * Whether this column means finished (anchrd/intel#311).
+     *
+     * ⚠️ Optional, and the absence is not the same as `false`. A caller who says nothing gets the
+     * server's answer — `false` for an ordinary column, `true` for the shelf, which cannot be
+     * anything else. Making it a required boolean would force every caller that only wanted to rename
+     * a column to restate the whole board's notion of done, and getting one entry wrong there is a
+     * silent change to what counts as blocked.
+     */
+    terminal: z.boolean().optional(),
+});
+// 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`,
+    })
+        // ⚠️ Refused rather than corrected, the same way removing the shelf is refused. A task swept
+        // onto `archived` is finished with, and a board that could declare the shelf non-terminal would
+        // hold every archived task open as a blocker forever. Only an EXPLICIT `false` is refused —
+        // saying nothing is fine and means the server's `true` (anchrd/intel#311).
+        .refine((statuses) => statuses.find((status) => status.id === ArchivedBoardStatusId)?.terminal !== false, { error: `The "${ArchivedBoardStatusId}" status is always terminal` }),
+    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: BoardTaskLabels.default([]),
+    startDate: BoardTaskDate.nullable().default(null),
+    dueDate: BoardTaskDate.nullable().default(null),
+    parentId: BoardTaskId.nullable().default(null),
+    dependsOn: BoardTaskDependsOn.default([]),
+    description: BoardTaskDescription.default(""),
+    references: BoardTaskReferences.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: BoardTaskLabels.optional(),
+    startDate: BoardTaskDate.nullable().optional(),
+    dueDate: BoardTaskDate.nullable().optional(),
+    dependsOn: BoardTaskDependsOn.optional(),
+    description: BoardTaskDescription.optional(),
+    references: BoardTaskReferences.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.
@@ -810,6 +1112,24 @@ export const ToolCapability = z.strictObject({
 export const ToolCatalog = z.strictObject({
     portalConnected: z.boolean(),
     items: z.array(ToolCapability),
+    /**
+     * Which delegated servers actually contributed a tool to this catalog (#289).
+     *
+     * ⚠️ Present only where the attribution was actually made — a delegated caller whose catalog was
+     * read. It is absent for an ordinary user, and absent as well when the answer comes from one of
+     * the short paths that never reach the portal (nothing delegated, no portal sign-in, connection
+     * dropped). Absent therefore means "not stated", never "nothing arrived"; `[]` is the second one.
+     *
+     * That it is missing rather than empty on those paths is deliberate rather than half-finished:
+     * the attribution already happens for a delegation — `capabilities` has to make it to cut the
+     * list — so naming it costs nothing there, while computing the same thing for an ordinary user
+     * would mean a second portal request per call, for a question their screen does not ask.
+     *
+     * ⚠️ It is the answer to "what arrived", never to "what was granted". A server missing here has
+     * been switched off, revoked, or is failing right now; the delegation in the definition is
+     * unchanged. Reading it the other way round would turn an outage into a permission change.
+     */
+    reached: z.array(ToolServerHandle).optional(),
 });
 /**
  * One MCP server the asking user reaches right now, as the portal itself names it (D30).
@@ -1217,6 +1537,7 @@ export const RelationNodeKind = z.enum([
     "attachment",
     "table",
     "agent",
+    "board",
     "flow",
 ]);
 export const RelationNode = z.strictObject({
@@ -1401,7 +1722,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",
@@ -1409,6 +1730,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.9.0",
+  "version": "0.11.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {