@cat-factory/contracts 0.274.0 → 0.276.0

package/dist/routes/public-api.d.ts

@@ -453,6 +453,8 @@ export declare const createPublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -510,6 +512,8 @@ export declare const listPublicServiceTasksContract: {
                 readonly progress: import("valibot").NumberSchema<undefined>;
                 readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                 readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
             }, undefined>, undefined>;
             readonly nextCursor: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
         }, undefined>;
@@ -559,6 +563,8 @@ export declare const getPublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -609,6 +615,8 @@ export declare const startPublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -627,6 +635,7 @@ export declare const updatePublicTaskContract: {
         readonly title: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>;
         readonly description: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 2000, undefined>]>, undefined>;
         readonly fields: import("valibot").OptionalSchema<import("valibot").RecordSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 80, undefined>]>, import("valibot").UnionSchema<[import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, import("valibot").SchemaWithPipe<readonly [import("valibot").ArraySchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").MaxLengthAction<string, 2000, undefined>]>, undefined>, import("valibot").MaxLengthAction<string[], 50, undefined>]>, import("valibot").BooleanSchema<undefined>, import("valibot").NumberSchema<undefined>], undefined>, undefined>, undefined>;
+        readonly autoStartDependents: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
     }, undefined>;
     readonly responsesByStatusCode: {
         readonly '4xx': import("valibot").ObjectSchema<{
@@ -661,6 +670,8 @@ export declare const updatePublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -709,6 +720,8 @@ export declare const stopPublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -757,6 +770,8 @@ export declare const retryPublicTaskContract: {
             readonly progress: import("valibot").NumberSchema<undefined>;
             readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
         }, undefined>;
     };
 } & {
@@ -809,6 +824,9 @@ export declare const getPublicRunContract: {
                     readonly inProgress: import("valibot").NumberSchema<undefined>;
                     readonly total: import("valibot").NumberSchema<undefined>;
                 }, undefined>, undefined>;
+                readonly output: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly data: import("valibot").NullableSchema<import("valibot").UnknownSchema, undefined>;
+                readonly truncated: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
             }, undefined>, undefined>;
             readonly externalIdentity: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
             readonly externalIdentityWithheld: import("valibot").BooleanSchema<undefined>;

package/dist/routes/public-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["../../src/routes/public-api.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"public-api.d.ts","sourceRoot":"","sources":["../../src/routes/public-api.ts"],"names":[],"mappings":"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"}

package/dist/routes/public-board.d.ts

@@ -0,0 +1,369 @@
+import { ContractNoBody } from '@toad-contracts/valibot';
+/**
+ * List the repositories this workspace can back a service with.
+ *
+ * The discovery half of service creation, and what makes it usable with no browser: the create
+ * takes a provider repo id, and nothing on this surface served one. `read` scope, like every other
+ * discovery endpoint here (`/pipelines`, `/task-types`): it names what the workspace has already
+ * connected, and an integration must be able to see what it is about to ask for without holding the
+ * credential that could change it.
+ */
+export declare const listPublicReposContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly repos: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly repoId: import("valibot").NumberSchema<undefined>;
+                readonly provider: import("valibot").StringSchema<undefined>;
+                readonly owner: import("valibot").StringSchema<undefined>;
+                readonly name: import("valibot").StringSchema<undefined>;
+                readonly defaultBranch: import("valibot").StringSchema<undefined>;
+                readonly private: import("valibot").BooleanSchema<undefined>;
+                readonly monorepo: import("valibot").BooleanSchema<undefined>;
+                readonly serviceId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly linkedElsewhere: import("valibot").BooleanSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "read";
+};
+/**
+ * Create a board service, optionally backed by a repository: the last act of board setup that had
+ * no headless counterpart, so a deployment that could provision its own keys and enrol its own
+ * webhook still had to open the app once to have anywhere to file work.
+ *
+ * Delegates to the SAME service methods the app's own "import a repository" button and drag-drop
+ * call, so every guard holds identically: a whole-repo repository that already backs a service in
+ * this account is MOUNTED here rather than duplicated, a monorepo must name its subdirectory, and a
+ * subdirectory another service already claims is refused.
+ */
+export declare const createPublicServiceContract: {
+    readonly method: "post";
+    readonly pathResolver: () => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly title: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>, undefined>;
+        readonly description: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 2000, undefined>]>, undefined>;
+        readonly type: import("valibot").OptionalSchema<import("valibot").PicklistSchema<["service", "frontend", "library", "document"], undefined>, undefined>;
+        readonly repo: import("valibot").OptionalSchema<import("valibot").ObjectSchema<{
+            readonly repoId: import("valibot").NumberSchema<undefined>;
+            readonly directory: import("valibot").OptionalSchema<import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MaxLengthAction<string, 400, undefined>]>, undefined>;
+            readonly monorepo: import("valibot").OptionalSchema<import("valibot").BooleanSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: import("valibot").ObjectSchema<{
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly type: import("valibot").PicklistSchema<["frontend", "service", "library", "document", "api", "database", "queue", "integration", "external", "environment"], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "admin";
+};
+/**
+ * Declare that this task must wait for another one. Idempotent: an edge that already exists is
+ * returned as-is rather than toggled off, which is what separates this from the app's own toggle
+ * and what lets a provisioning integration re-run without inverting the graph it declared last time.
+ */
+export declare const addPublicTaskDependencyContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly dependsOnTaskId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly taskId: import("valibot").StringSchema<undefined>;
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly taskType: import("valibot").UnionSchema<[import("valibot").PicklistSchema<readonly ["feature", "bug", "document", "spike", "review", "ralph", "recurring"], undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Consumer id must be <namespace>:<name> (lowercase a-z0-9, dash-separated)">]>], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+            readonly progress: import("valibot").NumberSchema<undefined>;
+            readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/** Drop a dependency edge. Idempotent, for the same reason the add is. */
+export declare const removePublicTaskDependencyContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly dependsOnTaskId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 120, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly taskId: import("valibot").StringSchema<undefined>;
+            readonly serviceId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly description: import("valibot").StringSchema<undefined>;
+            readonly taskType: import("valibot").UnionSchema<[import("valibot").PicklistSchema<readonly ["feature", "bug", "document", "spike", "review", "ralph", "recurring"], undefined>, import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").RegexAction<string, "Consumer id must be <namespace>:<name> (lowercase a-z0-9, dash-separated)">]>], undefined>;
+            readonly status: import("valibot").PicklistSchema<["planned", "ready", "in_progress", "blocked", "pr_ready", "done"], undefined>;
+            readonly progress: import("valibot").NumberSchema<undefined>;
+            readonly runId: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly pullRequestUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly dependsOn: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            readonly autoStartDependents: import("valibot").BooleanSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/** The requirements documents attached to a task, in the order the agents read them. */
+export declare const listPublicTaskDocumentsContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly documents: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+                readonly externalId: import("valibot").StringSchema<undefined>;
+                readonly title: import("valibot").StringSchema<undefined>;
+                readonly url: import("valibot").StringSchema<undefined>;
+                readonly excerpt: import("valibot").StringSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "read";
+};
+/**
+ * Attach a requirements document to an EXISTING task: the same two forms creation takes, at the
+ * moment a spec actually arrives.
+ */
+export declare const attachPublicTaskDocumentContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly document: import("valibot").VariantSchema<"kind", [import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"source", undefined>;
+            readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear"], undefined>;
+            readonly ref: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 500, undefined>]>;
+        }, undefined>, import("valibot").ObjectSchema<{
+            readonly kind: import("valibot").LiteralSchema<"upload", undefined>;
+            readonly title: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 200, undefined>]>;
+            readonly content: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 100000, undefined>]>;
+        }, undefined>], undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 201: import("valibot").ObjectSchema<{
+            readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+            readonly externalId: import("valibot").StringSchema<undefined>;
+            readonly title: import("valibot").StringSchema<undefined>;
+            readonly url: import("valibot").StringSchema<undefined>;
+            readonly excerpt: import("valibot").StringSchema<undefined>;
+        }, undefined>;
+    };
+} & {
+    readonly minScope: "write";
+};
+/**
+ * Detach a document from a task, naming it by the `(source, externalId)` pair the list serves.
+ *
+ * A POST rather than a `DELETE .../documents/{id}`: a document's identity is two values, one of
+ * which is a free-form external id that is a path for some sources (`docs/adr/0001.md`), so
+ * addressing it in a path segment would need escaping rules a caller has to get right to reach its
+ * own document.
+ */
+export declare const detachPublicTaskDocumentContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        taskId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ taskId }: {
+        taskId: string;
+    }) => string;
+    readonly requestBodySchema: import("valibot").ObjectSchema<{
+        readonly source: import("valibot").PicklistSchema<["confluence", "notion", "github", "figma", "zeplin", "linear", "upload"], undefined>;
+        readonly externalId: import("valibot").SchemaWithPipe<readonly [import("valibot").StringSchema<undefined>, import("valibot").TrimAction, import("valibot").MinLengthAction<string, 1, undefined>, import("valibot").MaxLengthAction<string, 500, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 204: typeof ContractNoBody;
+    };
+} & {
+    readonly minScope: "write";
+};
+//# sourceMappingURL=public-board.d.ts.map

package/dist/routes/public-board.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-board.d.ts","sourceRoot":"","sources":["../../src/routes/public-board.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAsC3E;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOnC,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS3C,CAAA;AAED,0EAA0E;AAC1E,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS9C,CAAA;AAID,wFAAwF;AACxF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ3C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5C,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAS5C,CAAA"}

package/dist/routes/public-board.js

@@ -0,0 +1,112 @@
+import { ContractNoBody, defineApiContract } from '@toad-contracts/valibot';
+import { attachPublicTaskDocumentSchema, createPublicServiceSchema, detachPublicTaskDocumentSchema, publicAttachedDocumentListSchema, publicAttachedDocumentSchema, publicRepoListSchema, publicTaskDependencySchema, } from '../public-board.js';
+import { publicServiceSchema, publicTaskSchema } from '../public-api.js';
+import { errorResponses, singleStringParam, withMinScope } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Board PROVISIONING and the two task relationships that outlive a create call, on `/api/v1`.
+//
+// Their own file rather than more of `public-api.ts`, which had grown to carry the whole surface:
+// these are one cohesive addition (what a headless deployment needs to SET UP and RELATE the board
+// it drives, as opposed to what it needs to run one task) and they share a scope argument that is
+// worth stating once.
+//
+// **Scope.** Service creation is `admin`; the task-level writes are `write`.
+//
+// The split follows what each act CHANGES rather than how destructive it feels. Creating a service
+// is board STRUCTURE, which is what `admin` already covers on this surface for keys and the
+// outbound webhook, and it is the rung a provisioning integration holds anyway. Attaching a
+// document, declaring an ordering: those edit ONE task the caller can already create, edit and
+// start with a `write` key, so putting them a rung higher would mean handing an integration that
+// files tickets a credential that can also merge pull requests and delete tasks.
+//
+// Where the two readings were close, the REVERSIBLE one wins (ADR 0034): a scope can be relaxed
+// later and never tightened, because narrowing what a live key may do is a break however small.
+// ---------------------------------------------------------------------------
+const taskIdParams = singleStringParam('taskId');
+// ---- provisioning: the repositories, and the services they back --------------
+/**
+ * List the repositories this workspace can back a service with.
+ *
+ * The discovery half of service creation, and what makes it usable with no browser: the create
+ * takes a provider repo id, and nothing on this surface served one. `read` scope, like every other
+ * discovery endpoint here (`/pipelines`, `/task-types`): it names what the workspace has already
+ * connected, and an integration must be able to see what it is about to ask for without holding the
+ * credential that could change it.
+ */
+export const listPublicReposContract = withMinScope('read', defineApiContract({
+    method: 'get',
+    pathResolver: () => '/api/v1/repos',
+    responsesByStatusCode: { 200: publicRepoListSchema, ...errorResponses },
+}));
+/**
+ * Create a board service, optionally backed by a repository: the last act of board setup that had
+ * no headless counterpart, so a deployment that could provision its own keys and enrol its own
+ * webhook still had to open the app once to have anywhere to file work.
+ *
+ * Delegates to the SAME service methods the app's own "import a repository" button and drag-drop
+ * call, so every guard holds identically: a whole-repo repository that already backs a service in
+ * this account is MOUNTED here rather than duplicated, a monorepo must name its subdirectory, and a
+ * subdirectory another service already claims is refused.
+ */
+export const createPublicServiceContract = withMinScope('admin', defineApiContract({
+    method: 'post',
+    pathResolver: () => '/api/v1/services',
+    requestBodySchema: createPublicServiceSchema,
+    responsesByStatusCode: { 201: publicServiceSchema, ...errorResponses },
+}));
+// ---- task ordering ----------------------------------------------------------
+/**
+ * Declare that this task must wait for another one. Idempotent: an edge that already exists is
+ * returned as-is rather than toggled off, which is what separates this from the app's own toggle
+ * and what lets a provisioning integration re-run without inverting the graph it declared last time.
+ */
+export const addPublicTaskDependencyContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/dependencies`,
+    requestBodySchema: publicTaskDependencySchema,
+    responsesByStatusCode: { 200: publicTaskSchema, ...errorResponses },
+}));
+/** Drop a dependency edge. Idempotent, for the same reason the add is. */
+export const removePublicTaskDependencyContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/dependencies/remove`,
+    requestBodySchema: publicTaskDependencySchema,
+    responsesByStatusCode: { 200: publicTaskSchema, ...errorResponses },
+}));
+// ---- a task's documents, after it exists -------------------------------------
+/** The requirements documents attached to a task, in the order the agents read them. */
+export const listPublicTaskDocumentsContract = withMinScope('read', defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents`,
+    responsesByStatusCode: { 200: publicAttachedDocumentListSchema, ...errorResponses },
+}));
+/**
+ * Attach a requirements document to an EXISTING task: the same two forms creation takes, at the
+ * moment a spec actually arrives.
+ */
+export const attachPublicTaskDocumentContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents`,
+    requestBodySchema: attachPublicTaskDocumentSchema,
+    responsesByStatusCode: { 201: publicAttachedDocumentSchema, ...errorResponses },
+}));
+/**
+ * Detach a document from a task, naming it by the `(source, externalId)` pair the list serves.
+ *
+ * A POST rather than a `DELETE .../documents/{id}`: a document's identity is two values, one of
+ * which is a free-form external id that is a path for some sources (`docs/adr/0001.md`), so
+ * addressing it in a path segment would need escaping rules a caller has to get right to reach its
+ * own document.
+ */
+export const detachPublicTaskDocumentContract = withMinScope('write', defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: taskIdParams,
+    pathResolver: ({ taskId }) => `/api/v1/tasks/${taskId}/documents/detach`,
+    requestBodySchema: detachPublicTaskDocumentSchema,
+    responsesByStatusCode: { 204: ContractNoBody, ...errorResponses },
+}));
+//# sourceMappingURL=public-board.js.map

package/dist/routes/public-board.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-board.js","sourceRoot":"","sources":["../../src/routes/public-board.ts"],"names":[],"mappings":"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"}

package/dist/routes/public-evidence.d.ts

@@ -458,6 +458,7 @@ export declare const listPublicRunArtifactsContract: {
             readonly artifacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
                 readonly artifactId: import("valibot").StringSchema<undefined>;
                 readonly kind: import("valibot").PicklistSchema<["screenshot", "reference"], undefined>;
+                readonly scope: import("valibot").PicklistSchema<["run", "task"], undefined>;
                 readonly view: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
                 readonly contentType: import("valibot").StringSchema<undefined>;
                 readonly byteSize: import("valibot").NumberSchema<undefined>;

package/dist/routes/public-evidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1C,CAAA"}
+{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQtC,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQvC,CAAA;AAED,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQ1C,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cat-factory/contracts",
-  "version": "0.274.0",
+  "version": "0.276.0",
   "description": "Valibot wire contract shared between the Agent Architecture Board frontend and backend.",
   "repository": {
     "type": "git",