@anchrd/intel-contract 0.9.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";
@@ -872,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>;
@@ -956,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>;
@@ -1043,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>;
@@ -1137,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>;
@@ -2361,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>;
@@ -2372,6 +2755,7 @@ export declare const RelationNode: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2423,6 +2807,7 @@ export declare const RelationGraph: z.ZodObject<{
             attachment: "attachment";
             table: "table";
             agent: "agent";
+            board: "board";
             flow: "flow";
         }>;
         title: z.ZodString;
@@ -2793,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>;
@@ -2804,6 +3190,7 @@ export declare const BundleManifestEntry: z.ZodObject<{
         attachment: "attachment";
         table: "table";
         agent: "agent";
+        board: "board";
         flow: "flow";
     }>;
     title: z.ZodString;
@@ -2831,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.
@@ -1217,6 +1437,7 @@ export const RelationNodeKind = z.enum([
     "attachment",
     "table",
     "agent",
+    "board",
     "flow",
 ]);
 export const RelationNode = z.strictObject({
@@ -1401,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",
@@ -1409,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.9.0",
+  "version": "0.10.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {