@cat-factory/contracts 0.162.0 → 0.163.0

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

@@ -0,0 +1,602 @@
+import { ContractNoBody } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+/** List a run's currently-parked decisions (findings, fork options) — `read`. */
+export declare const listPublicRunDecisionsContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Answer one reviewer finding. */
+export declare const replyPublicRunFindingContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly runId: v.StringSchema<undefined>;
+        readonly itemId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId, itemId }: {
+        runId: string;
+        itemId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly reply: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 4000, undefined>]>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Dismiss a finding as not applicable, or reopen one dismissed by mistake. */
+export declare const setPublicRunFindingStatusContract: {
+    readonly method: "patch";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        readonly runId: v.StringSchema<undefined>;
+        readonly itemId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId, itemId }: {
+        runId: string;
+        itemId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly status: v.PicklistSchema<["dismissed", "open"], undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/**
+ * Fold the recorded answers into the standardized requirements document. ASYNCHRONOUS — the
+ * durable driver folds and re-reviews in the background, so the response shows the review
+ * `incorporating`; poll (or watch the SSE stream) for the next round or convergence.
+ */
+export declare const incorporatePublicRunRequirementsContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly feedback: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 4000, undefined>]>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Run one more reviewer pass over the incorporated document. */
+export declare const reReviewPublicRunRequirementsContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly requestBodySchema: typeof ContractNoBody;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Settle the requirements phase and advance the parked run (used when nothing is outstanding). */
+export declare const proceedPublicRunRequirementsContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly requestBodySchema: typeof ContractNoBody;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Resolve a review that hit its iteration cap (extra round / proceed / stop and reset). */
+export declare const resolvePublicRunRequirementsExceededContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly choice: v.PicklistSchema<["extra-round", "proceed", "stop-reset"], undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** Choose an implementation approach (a proposed fork id or a custom approach). */
+export declare const choosePublicRunForkContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        runId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly requestBodySchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+        readonly forkId: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+        readonly custom: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 8000, undefined>]>, undefined>, undefined>;
+        readonly note: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 4000, undefined>]>, undefined>, undefined>;
+    }, undefined>, v.CheckAction<{
+        forkId?: string | null | undefined;
+        custom?: string | null | undefined;
+        note?: string | null | undefined;
+    }, "Provide exactly one of forkId or custom.">]>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly runId: v.StringSchema<undefined>;
+            readonly taskId: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["running", "blocked", "paused", "done", "failed"], undefined>;
+            readonly parked: v.BooleanSchema<undefined>;
+            readonly decisions: v.ArraySchema<v.VariantSchema<"kind", [v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"requirements-review", undefined>;
+                readonly reviewId: v.StringSchema<undefined>;
+                readonly taskId: v.StringSchema<undefined>;
+                readonly status: v.PicklistSchema<["ready", "incorporating", "reviewing", "merged", "exceeded", "incorporated"], undefined>;
+                readonly iteration: v.NumberSchema<undefined>;
+                readonly maxIterations: v.NumberSchema<undefined>;
+                readonly findings: v.ArraySchema<v.ObjectSchema<{
+                    readonly itemId: v.StringSchema<undefined>;
+                    readonly category: v.PicklistSchema<["gap", "clarification", "assumption", "risk", "question"], undefined>;
+                    readonly severity: v.PicklistSchema<["low", "medium", "high"], undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly detail: v.StringSchema<undefined>;
+                    readonly status: v.PicklistSchema<["open", "answered", "resolved", "dismissed", "recommend_requested"], undefined>;
+                    readonly reply: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly incorporatedRequirements: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, v.ObjectSchema<{
+                readonly kind: v.LiteralSchema<"fork", undefined>;
+                readonly status: v.PicklistSchema<["proposing", "awaiting_choice", "answering", "chosen", "single_path", "skipped"], undefined>;
+                readonly seamSummary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                readonly forks: v.ArraySchema<v.ObjectSchema<{
+                    readonly id: v.StringSchema<undefined>;
+                    readonly title: v.StringSchema<undefined>;
+                    readonly summary: v.StringSchema<undefined>;
+                    readonly approach: v.StringSchema<undefined>;
+                    readonly tradeoffs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    readonly riskNotes: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    readonly recommended: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>], undefined>, undefined>;
+        }, undefined>;
+    };
+};
+//# sourceMappingURL=public-decisions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"public-decisions.d.ts","sourceRoot":"","sources":["../../src/routes/public-decisions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AA6B5B,iFAAiF;AACjF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKzC,CAAA;AAIF,mCAAmC;AACnC,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOxC,CAAA;AAEF,+EAA+E;AAC/E,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAO5C,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnD,CAAA;AAEF,iEAAiE;AACjE,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMhD,CAAA;AAEF,mGAAmG;AACnG,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM/C,CAAA;AAEF,4FAA4F;AAC5F,eAAO,MAAM,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMvD,CAAA;AAIF,mFAAmF;AACnF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMtC,CAAA"}