@cat-factory/contracts 0.354.0 → 0.355.0

package/dist/public-decisions.d.ts

@@ -7,7 +7,7 @@ import * as v from 'valibot';
  * route behind it is exactly the "refusal advertising a capability we do not have" defect that set
  * builds. Add a member only together with its routes.
  */
-export declare const publicDecisionKindSchema: v.PicklistSchema<["requirements-review", "fork", "judge", "input-gate", "approval-gate", "agent-decision", "clarity-review", "brainstorm", "pr-review", "human-test", "visual-confirmation", "follow-ups", "interview"], undefined>;
+export declare const publicDecisionKindSchema: v.PicklistSchema<["requirements-review", "fork", "judge", "input-gate", "approval-gate", "agent-decision", "clarity-review", "brainstorm", "pr-review", "bug-fishing", "human-test", "visual-confirmation", "follow-ups", "interview"], undefined>;
 export type PublicDecisionKind = v.InferOutput<typeof publicDecisionKindSchema>;
 /**
  * One reviewer finding as exposed externally — the question, how serious it is, and where it
@@ -725,6 +725,278 @@ export type PublicPrReviewDecision = v.InferOutput<typeof publicPrReviewDecision
  * `reportedSlices` and `lastActivityAt` on the decision are what it reads instead.
  */
 export declare const PUBLIC_PR_REVIEW_MAX_RESUME_ATTEMPTS = 3;
+/**
+ * One angle of an expedition as exposed externally: what the pass was told to hunt, how far it
+ * got, and which slice of the codebase it covered.
+ *
+ * `title` / `goal` / `territoryLabel` are the values the expedition RECORDED when it planned the
+ * pass, never a lookup against today's catalog. An angle this build has since retired, or a
+ * territory a later survey of a moved tree no longer produces, therefore still renders as the
+ * thing that actually ran rather than as a blank or a guess at a current member.
+ */
+export declare const publicBugFishingPhaseSchema: v.ObjectSchema<{
+    /** The angle's id. An OPEN string on the wire: a stored run can name one this build retired. */
+    readonly phaseId: v.StringSchema<undefined>;
+    /** The angle's label as it stood when this expedition planned it. */
+    readonly title: v.StringSchema<undefined>;
+    /** What this pass was told to hunt, as it stood when this expedition planned it. */
+    readonly goal: v.StringSchema<undefined>;
+    readonly status: v.PicklistSchema<["pending", "fishing", "completed", "failed"], undefined>;
+    /** The agent's account of what it covered; null until the pass settles. */
+    readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Why the pass failed, on a `failed` phase. Null otherwise. */
+    readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The territory this pass fished, or null for a whole-codebase pass. */
+    readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The territory's label as it stood when this pass ran. */
+    readonly territoryLabel: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Epoch ms the pass settled; null while pending or fishing. */
+    readonly settledAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    /**
+     * How many manifest files the pass reported reading, against how many the territory held.
+     * SELF-REPORTED by the agent, which the field names say: a low share is what tells a reader
+     * that "found nothing here" may mean "did not look". Null when the pass reported none, which is
+     * a different fact from a share of zero.
+     */
+    readonly filesRead: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly manifestFiles: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export type PublicBugFishingPhase = v.InferOutput<typeof publicBugFishingPhaseSchema>;
+/** One cell of the planned (territory x angle) matrix the pass budget cut before it was fished. */
+export declare const publicBugFishingUnfishedCellSchema: v.ObjectSchema<{
+    readonly territoryId: v.StringSchema<undefined>;
+    readonly territoryLabel: v.StringSchema<undefined>;
+    readonly phaseId: v.StringSchema<undefined>;
+    readonly phaseTitle: v.StringSchema<undefined>;
+}, undefined>;
+export type PublicBugFishingUnfishedCell = v.InferOutput<typeof publicBugFishingUnfishedCellSchema>;
+/**
+ * What the expedition decided to fish, and what it decided not to.
+ *
+ * `unfished` is the reason this is published rather than left as an implementation detail: a cap
+ * that says nothing about its tail teaches a reader that the tail was clean. An integration
+ * filing what an expedition caught has to be able to say which ground nobody covered.
+ */
+export declare const publicBugFishingPlanSchema: v.ObjectSchema<{
+    /** The most container dispatches this expedition may make. */
+    readonly passBudget: v.NumberSchema<undefined>;
+    /** How many cells the full matrix held before the budget trimmed it. */
+    readonly plannedCells: v.NumberSchema<undefined>;
+    /** The cells the budget cut. Empty when the whole matrix fitted. */
+    readonly unfished: v.ArraySchema<v.ObjectSchema<{
+        readonly territoryId: v.StringSchema<undefined>;
+        readonly territoryLabel: v.StringSchema<undefined>;
+        readonly phaseId: v.StringSchema<undefined>;
+        readonly phaseTitle: v.StringSchema<undefined>;
+    }, undefined>, undefined>;
+    /**
+     * True when the tree the survey partitioned was TRUNCATED by the provider. The coverage numbers
+     * are then a share of what was read rather than of the repository, which are opposite readings.
+     */
+    readonly treeTruncated: v.BooleanSchema<undefined>;
+    /**
+     * Why the codebase survey could not run at all (no repository bound to the run, or a client that
+     * cannot enumerate a tree). Non-null means the single territory the expedition fished is a
+     * FALLBACK rather than a small repository, and the two look identical without it.
+     */
+    readonly surveyUnavailableReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type PublicBugFishingPlan = v.InferOutput<typeof publicBugFishingPlanSchema>;
+/**
+ * The bug-fix task a marked finding spawned.
+ *
+ * Read `status`, never the mere presence of this record: a `pending` row is the CLAIM taken before
+ * the task exists (which is what stops two markings spawning two tasks for one finding), and a
+ * `failed` row means nothing was created and the finding is markable again.
+ */
+export declare const publicBugFishingSpawnSchema: v.ObjectSchema<{
+    readonly status: v.PicklistSchema<["pending", "spawned", "failed"], undefined>;
+    /** The spawned task's id, addressable through `GET /api/v1/tasks/{taskId}`. */
+    readonly taskId: v.StringSchema<undefined>;
+    /** The run started on that task; null while the claim is pending. */
+    readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The pipeline the spawned task runs (the expedition's default, or the marking's override). */
+    readonly pipelineId: v.StringSchema<undefined>;
+    /** Epoch ms the claim was taken. */
+    readonly requestedAt: v.NumberSchema<undefined>;
+    /** Why the spawn failed, on a `failed` record. Null otherwise. */
+    readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type PublicBugFishingSpawn = v.InferOutput<typeof publicBugFishingSpawnSchema>;
+/**
+ * One finding an expedition caught. Every string in it is MODEL-AUTHORED: treat it as data, never
+ * as markup.
+ *
+ * `evidence` is carried apart from `detail` for the reason the internal record keeps them apart:
+ * an expedition that cannot point at the code it is describing is speculating, and merging the two
+ * would leave a triaging human to infer that from the prose.
+ */
+export declare const publicBugFishingFindingSchema: v.ObjectSchema<{
+    readonly findingId: v.StringSchema<undefined>;
+    /** The angle that surfaced it. */
+    readonly phaseId: v.StringSchema<undefined>;
+    /** The territory that angle was fishing, or null for a whole-codebase pass. */
+    readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Repo-relative path; EMPTY when the finding is not anchored to one file. */
+    readonly path: v.StringSchema<undefined>;
+    readonly line: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    readonly severity: v.PicklistSchema<["critical", "high", "medium", "low"], undefined>;
+    readonly kind: v.PicklistSchema<["bug", "logic-gap", "edge-case", "footgun", "requirement-gap", "other"], undefined>;
+    /** The agent's own judgement of how sure it is. Never platform-derived. */
+    readonly confidence: v.PicklistSchema<["high", "medium", "low"], undefined>;
+    readonly title: v.StringSchema<undefined>;
+    readonly detail: v.StringSchema<undefined>;
+    /** The concrete inputs / interleaving / state that triggers the defect, when it named one. */
+    readonly failureScenario: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** What the agent actually read that supports the claim. */
+    readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly suggestedFix: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** The bug-fix task marking this finding spawned; null when nobody has marked it. */
+    readonly spawn: v.NullableSchema<v.ObjectSchema<{
+        readonly status: v.PicklistSchema<["pending", "spawned", "failed"], undefined>;
+        /** The spawned task's id, addressable through `GET /api/v1/tasks/{taskId}`. */
+        readonly taskId: v.StringSchema<undefined>;
+        /** The run started on that task; null while the claim is pending. */
+        readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The pipeline the spawned task runs (the expedition's default, or the marking's override). */
+        readonly pipelineId: v.StringSchema<undefined>;
+        /** Epoch ms the claim was taken. */
+        readonly requestedAt: v.NumberSchema<undefined>;
+        /** Why the spawn failed, on a `failed` record. Null otherwise. */
+        readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /** True when a human waved it off. It stays on the record and is not markable. */
+    readonly dismissed: v.BooleanSchema<undefined>;
+}, undefined>;
+export type PublicBugFishingFinding = v.InferOutput<typeof publicBugFishingFindingSchema>;
+/**
+ * A BUG-FISHING EXPEDITION: the read-only `bug-fisher` agent reads a service's codebase once per
+ * ANGLE per TERRITORY, and the run waits for a person to mark which of the things it caught are
+ * worth acting on. Each mark spawns its own bug-fix task.
+ *
+ * Listed while the expedition is still `fishing` as well as once it parks, and that is the shape
+ * of the flow rather than a convenience: a completed angle's findings are actionable the moment
+ * they land, so marking is accepted mid-hunt and a caller waiting for `awaiting_triage` before it
+ * reads anything would sit out the very overlap the separate passes exist to create.
+ *
+ * Reachable only through `POST /api/v1/tasks/{taskId}/start`, since `bug-fisher` is
+ * container-backed and the jobs surface is inline-only.
+ */
+export declare const publicBugFishingDecisionSchema: v.ObjectSchema<{
+    readonly kind: v.LiteralSchema<"bug-fishing", undefined>;
+    /** `fishing` while angles are still in flight, `awaiting_triage` once every one has settled. */
+    readonly status: v.PicklistSchema<["fishing", "awaiting_triage", "done"], undefined>;
+    /** The step this expedition rides, lined up against `publicRun.steps`. */
+    readonly stepKind: v.StringSchema<undefined>;
+    readonly stepIndex: v.NumberSchema<undefined>;
+    /** The planned angles, in the order they are fished. */
+    readonly phases: v.ArraySchema<v.ObjectSchema<{
+        /** The angle's id. An OPEN string on the wire: a stored run can name one this build retired. */
+        readonly phaseId: v.StringSchema<undefined>;
+        /** The angle's label as it stood when this expedition planned it. */
+        readonly title: v.StringSchema<undefined>;
+        /** What this pass was told to hunt, as it stood when this expedition planned it. */
+        readonly goal: v.StringSchema<undefined>;
+        readonly status: v.PicklistSchema<["pending", "fishing", "completed", "failed"], undefined>;
+        /** The agent's account of what it covered; null until the pass settles. */
+        readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Why the pass failed, on a `failed` phase. Null otherwise. */
+        readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The territory this pass fished, or null for a whole-codebase pass. */
+        readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The territory's label as it stood when this pass ran. */
+        readonly territoryLabel: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Epoch ms the pass settled; null while pending or fishing. */
+        readonly settledAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /**
+         * How many manifest files the pass reported reading, against how many the territory held.
+         * SELF-REPORTED by the agent, which the field names say: a low share is what tells a reader
+         * that "found nothing here" may mean "did not look". Null when the pass reported none, which is
+         * a different fact from a share of zero.
+         */
+        readonly filesRead: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly manifestFiles: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Index into `phases` of the pass being fished. Equal to `phases.length` once every angle has
+     * settled, which is the same fact `status: "awaiting_triage"` states.
+     */
+    readonly currentPhaseIndex: v.NumberSchema<undefined>;
+    /** Every finding caught so far, oldest angle first and severity-ordered within an angle. */
+    readonly findings: v.ArraySchema<v.ObjectSchema<{
+        readonly findingId: v.StringSchema<undefined>;
+        /** The angle that surfaced it. */
+        readonly phaseId: v.StringSchema<undefined>;
+        /** The territory that angle was fishing, or null for a whole-codebase pass. */
+        readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Repo-relative path; EMPTY when the finding is not anchored to one file. */
+        readonly path: v.StringSchema<undefined>;
+        readonly line: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly severity: v.PicklistSchema<["critical", "high", "medium", "low"], undefined>;
+        readonly kind: v.PicklistSchema<["bug", "logic-gap", "edge-case", "footgun", "requirement-gap", "other"], undefined>;
+        /** The agent's own judgement of how sure it is. Never platform-derived. */
+        readonly confidence: v.PicklistSchema<["high", "medium", "low"], undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly detail: v.StringSchema<undefined>;
+        /** The concrete inputs / interleaving / state that triggers the defect, when it named one. */
+        readonly failureScenario: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** What the agent actually read that supports the claim. */
+        readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly suggestedFix: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The bug-fix task marking this finding spawned; null when nobody has marked it. */
+        readonly spawn: v.NullableSchema<v.ObjectSchema<{
+            readonly status: v.PicklistSchema<["pending", "spawned", "failed"], undefined>;
+            /** The spawned task's id, addressable through `GET /api/v1/tasks/{taskId}`. */
+            readonly taskId: v.StringSchema<undefined>;
+            /** The run started on that task; null while the claim is pending. */
+            readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The pipeline the spawned task runs (the expedition's default, or the marking's override). */
+            readonly pipelineId: v.StringSchema<undefined>;
+            /** Epoch ms the claim was taken. */
+            readonly requestedAt: v.NumberSchema<undefined>;
+            /** Why the spawn failed, on a `failed` record. Null otherwise. */
+            readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /** True when a human waved it off. It stays on the record and is not markable. */
+        readonly dismissed: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    /**
+     * What the expedition planned and what the budget cut; null on an expedition that recorded no
+     * plan. See {@link publicBugFishingPlanSchema} for why the cut cells are published.
+     */
+    readonly plan: v.NullableSchema<v.ObjectSchema<{
+        /** The most container dispatches this expedition may make. */
+        readonly passBudget: v.NumberSchema<undefined>;
+        /** How many cells the full matrix held before the budget trimmed it. */
+        readonly plannedCells: v.NumberSchema<undefined>;
+        /** The cells the budget cut. Empty when the whole matrix fitted. */
+        readonly unfished: v.ArraySchema<v.ObjectSchema<{
+            readonly territoryId: v.StringSchema<undefined>;
+            readonly territoryLabel: v.StringSchema<undefined>;
+            readonly phaseId: v.StringSchema<undefined>;
+            readonly phaseTitle: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        /**
+         * True when the tree the survey partitioned was TRUNCATED by the provider. The coverage numbers
+         * are then a share of what was read rather than of the repository, which are opposite readings.
+         */
+        readonly treeTruncated: v.BooleanSchema<undefined>;
+        /**
+         * Why the codebase survey could not run at all (no repository bound to the run, or a client that
+         * cannot enumerate a tree). Non-null means the single territory the expedition fished is a
+         * FALLBACK rather than a small repository, and the two look identical without it.
+         */
+        readonly surveyUnavailableReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * The pipeline a marked finding's spawned task runs when the marking names none. Null when the
+     * expedition resolved none, in which case a marking must name one.
+     */
+    readonly defaultFixPipelineId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Identifier of the model that fished, for transparency. Null when the run recorded none. */
+    readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type PublicBugFishingDecision = v.InferOutput<typeof publicBugFishingDecisionSchema>;
 /** The ephemeral environment a `human-test` gate parked against, as exposed externally. */
 export declare const publicHumanTestEnvironmentSchema: v.ObjectSchema<{
     /** The public URL to test against; null while still provisioning. */
@@ -1353,6 +1625,119 @@ export declare const publicDecisionSchema: v.VariantSchema<"kind", [v.ObjectSche
      * poller resuming on a bare timer, which kills a container that may be seconds from returning.
      */
     readonly lastActivityAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly kind: v.LiteralSchema<"bug-fishing", undefined>;
+    /** `fishing` while angles are still in flight, `awaiting_triage` once every one has settled. */
+    readonly status: v.PicklistSchema<["fishing", "awaiting_triage", "done"], undefined>;
+    /** The step this expedition rides, lined up against `publicRun.steps`. */
+    readonly stepKind: v.StringSchema<undefined>;
+    readonly stepIndex: v.NumberSchema<undefined>;
+    /** The planned angles, in the order they are fished. */
+    readonly phases: v.ArraySchema<v.ObjectSchema<{
+        /** The angle's id. An OPEN string on the wire: a stored run can name one this build retired. */
+        readonly phaseId: v.StringSchema<undefined>;
+        /** The angle's label as it stood when this expedition planned it. */
+        readonly title: v.StringSchema<undefined>;
+        /** What this pass was told to hunt, as it stood when this expedition planned it. */
+        readonly goal: v.StringSchema<undefined>;
+        readonly status: v.PicklistSchema<["pending", "fishing", "completed", "failed"], undefined>;
+        /** The agent's account of what it covered; null until the pass settles. */
+        readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Why the pass failed, on a `failed` phase. Null otherwise. */
+        readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The territory this pass fished, or null for a whole-codebase pass. */
+        readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The territory's label as it stood when this pass ran. */
+        readonly territoryLabel: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Epoch ms the pass settled; null while pending or fishing. */
+        readonly settledAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        /**
+         * How many manifest files the pass reported reading, against how many the territory held.
+         * SELF-REPORTED by the agent, which the field names say: a low share is what tells a reader
+         * that "found nothing here" may mean "did not look". Null when the pass reported none, which is
+         * a different fact from a share of zero.
+         */
+        readonly filesRead: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly manifestFiles: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * Index into `phases` of the pass being fished. Equal to `phases.length` once every angle has
+     * settled, which is the same fact `status: "awaiting_triage"` states.
+     */
+    readonly currentPhaseIndex: v.NumberSchema<undefined>;
+    /** Every finding caught so far, oldest angle first and severity-ordered within an angle. */
+    readonly findings: v.ArraySchema<v.ObjectSchema<{
+        readonly findingId: v.StringSchema<undefined>;
+        /** The angle that surfaced it. */
+        readonly phaseId: v.StringSchema<undefined>;
+        /** The territory that angle was fishing, or null for a whole-codebase pass. */
+        readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Repo-relative path; EMPTY when the finding is not anchored to one file. */
+        readonly path: v.StringSchema<undefined>;
+        readonly line: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        readonly severity: v.PicklistSchema<["critical", "high", "medium", "low"], undefined>;
+        readonly kind: v.PicklistSchema<["bug", "logic-gap", "edge-case", "footgun", "requirement-gap", "other"], undefined>;
+        /** The agent's own judgement of how sure it is. Never platform-derived. */
+        readonly confidence: v.PicklistSchema<["high", "medium", "low"], undefined>;
+        readonly title: v.StringSchema<undefined>;
+        readonly detail: v.StringSchema<undefined>;
+        /** The concrete inputs / interleaving / state that triggers the defect, when it named one. */
+        readonly failureScenario: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** What the agent actually read that supports the claim. */
+        readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        readonly suggestedFix: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** The bug-fix task marking this finding spawned; null when nobody has marked it. */
+        readonly spawn: v.NullableSchema<v.ObjectSchema<{
+            readonly status: v.PicklistSchema<["pending", "spawned", "failed"], undefined>;
+            /** The spawned task's id, addressable through `GET /api/v1/tasks/{taskId}`. */
+            readonly taskId: v.StringSchema<undefined>;
+            /** The run started on that task; null while the claim is pending. */
+            readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The pipeline the spawned task runs (the expedition's default, or the marking's override). */
+            readonly pipelineId: v.StringSchema<undefined>;
+            /** Epoch ms the claim was taken. */
+            readonly requestedAt: v.NumberSchema<undefined>;
+            /** Why the spawn failed, on a `failed` record. Null otherwise. */
+            readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /** True when a human waved it off. It stays on the record and is not markable. */
+        readonly dismissed: v.BooleanSchema<undefined>;
+    }, undefined>, undefined>;
+    /**
+     * What the expedition planned and what the budget cut; null on an expedition that recorded no
+     * plan. See {@link publicBugFishingPlanSchema} for why the cut cells are published.
+     */
+    readonly plan: v.NullableSchema<v.ObjectSchema<{
+        /** The most container dispatches this expedition may make. */
+        readonly passBudget: v.NumberSchema<undefined>;
+        /** How many cells the full matrix held before the budget trimmed it. */
+        readonly plannedCells: v.NumberSchema<undefined>;
+        /** The cells the budget cut. Empty when the whole matrix fitted. */
+        readonly unfished: v.ArraySchema<v.ObjectSchema<{
+            readonly territoryId: v.StringSchema<undefined>;
+            readonly territoryLabel: v.StringSchema<undefined>;
+            readonly phaseId: v.StringSchema<undefined>;
+            readonly phaseTitle: v.StringSchema<undefined>;
+        }, undefined>, undefined>;
+        /**
+         * True when the tree the survey partitioned was TRUNCATED by the provider. The coverage numbers
+         * are then a share of what was read rather than of the repository, which are opposite readings.
+         */
+        readonly treeTruncated: v.BooleanSchema<undefined>;
+        /**
+         * Why the codebase survey could not run at all (no repository bound to the run, or a client that
+         * cannot enumerate a tree). Non-null means the single territory the expedition fished is a
+         * FALLBACK rather than a small repository, and the two look identical without it.
+         */
+        readonly surveyUnavailableReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    }, undefined>, undefined>;
+    /**
+     * The pipeline a marked finding's spawned task runs when the marking names none. Null when the
+     * expedition resolved none, in which case a marking must name one.
+     */
+    readonly defaultFixPipelineId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    /** Identifier of the model that fished, for transparency. Null when the run recorded none. */
+    readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
 }, undefined>, v.ObjectSchema<{
     readonly kind: v.LiteralSchema<"human-test", undefined>;
     /** Only `awaiting_human` accepts an answer; the others report work in flight. */
@@ -1462,14 +1847,15 @@ export type PublicDecision = v.InferOutput<typeof publicDecisionSchema>;
  * - `unwired_interview_gate` — an interviewer this deployment REGISTERED as an agent kind but
  *   never wired a controller for. The run is genuinely parked on its questions and no surface,
  *   here or in the app, can read them; the fix belongs to the operator, not the caller.
- * - `curation_gate`: a step that CURATES (a `curation-gate` kind: the bug-fishing expedition, a
- *   deployment's own) parked so a person can mark which of the things it found are worth acting
- *   on, and this API has no route that marks one. The PR deep review carries the same trait and
- *   is NOT reported here, because its curation IS answerable (`kind: 'pr-review'`), which is the
- *   whole distinction: what a caller must be able to do differs per curating kind, so one shared
- *   label would promise an answer path for whichever one it did not mean. The step's approval
- *   gate can still be resolved to END the run, and that is worth knowing rather than a
- *   contradiction: ending an expedition discards what it caught, so it is an exit, not an answer.
+ * - `curation_gate`: a step that CURATES (a `curation-gate` kind a DEPLOYMENT registered) parked
+ *   so a person can mark which of the things it found are worth acting on, and this API has no
+ *   route that marks one. Both SHIPPED curating kinds are answerable here and so are never
+ *   reported: the PR deep review as `kind: 'pr-review'`, the bug-fishing expedition as
+ *   `kind: 'bug-fishing'`. That is the whole distinction rather than a detail: what a caller must
+ *   be able to do differs per curating kind, so one shared label would promise an answer path for
+ *   whichever one it did not mean. The step's approval gate can still be resolved to END such a
+ *   run, and that is worth knowing rather than a contradiction: ending a curation discards what it
+ *   caught, so it is an exit, not an answer.
  *
  * Every member is a wait that is BOTH live and beyond this surface, and both halves are load-
  * bearing. A run that has finished (`done` / `failed`, the stop included) lists nothing at all: its
@@ -1902,6 +2288,119 @@ export declare const publicDecisionListSchema: v.ObjectSchema<{
          * poller resuming on a bare timer, which kills a container that may be seconds from returning.
          */
         readonly lastActivityAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+    }, undefined>, v.ObjectSchema<{
+        readonly kind: v.LiteralSchema<"bug-fishing", undefined>;
+        /** `fishing` while angles are still in flight, `awaiting_triage` once every one has settled. */
+        readonly status: v.PicklistSchema<["fishing", "awaiting_triage", "done"], undefined>;
+        /** The step this expedition rides, lined up against `publicRun.steps`. */
+        readonly stepKind: v.StringSchema<undefined>;
+        readonly stepIndex: v.NumberSchema<undefined>;
+        /** The planned angles, in the order they are fished. */
+        readonly phases: v.ArraySchema<v.ObjectSchema<{
+            /** The angle's id. An OPEN string on the wire: a stored run can name one this build retired. */
+            readonly phaseId: v.StringSchema<undefined>;
+            /** The angle's label as it stood when this expedition planned it. */
+            readonly title: v.StringSchema<undefined>;
+            /** What this pass was told to hunt, as it stood when this expedition planned it. */
+            readonly goal: v.StringSchema<undefined>;
+            readonly status: v.PicklistSchema<["pending", "fishing", "completed", "failed"], undefined>;
+            /** The agent's account of what it covered; null until the pass settles. */
+            readonly summary: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** Why the pass failed, on a `failed` phase. Null otherwise. */
+            readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The territory this pass fished, or null for a whole-codebase pass. */
+            readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The territory's label as it stood when this pass ran. */
+            readonly territoryLabel: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** Epoch ms the pass settled; null while pending or fishing. */
+            readonly settledAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            /**
+             * How many manifest files the pass reported reading, against how many the territory held.
+             * SELF-REPORTED by the agent, which the field names say: a low share is what tells a reader
+             * that "found nothing here" may mean "did not look". Null when the pass reported none, which is
+             * a different fact from a share of zero.
+             */
+            readonly filesRead: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly manifestFiles: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /**
+         * Index into `phases` of the pass being fished. Equal to `phases.length` once every angle has
+         * settled, which is the same fact `status: "awaiting_triage"` states.
+         */
+        readonly currentPhaseIndex: v.NumberSchema<undefined>;
+        /** Every finding caught so far, oldest angle first and severity-ordered within an angle. */
+        readonly findings: v.ArraySchema<v.ObjectSchema<{
+            readonly findingId: v.StringSchema<undefined>;
+            /** The angle that surfaced it. */
+            readonly phaseId: v.StringSchema<undefined>;
+            /** The territory that angle was fishing, or null for a whole-codebase pass. */
+            readonly territoryId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** Repo-relative path; EMPTY when the finding is not anchored to one file. */
+            readonly path: v.StringSchema<undefined>;
+            readonly line: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly severity: v.PicklistSchema<["critical", "high", "medium", "low"], undefined>;
+            readonly kind: v.PicklistSchema<["bug", "logic-gap", "edge-case", "footgun", "requirement-gap", "other"], undefined>;
+            /** The agent's own judgement of how sure it is. Never platform-derived. */
+            readonly confidence: v.PicklistSchema<["high", "medium", "low"], undefined>;
+            readonly title: v.StringSchema<undefined>;
+            readonly detail: v.StringSchema<undefined>;
+            /** The concrete inputs / interleaving / state that triggers the defect, when it named one. */
+            readonly failureScenario: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** What the agent actually read that supports the claim. */
+            readonly evidence: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly suggestedFix: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            /** The bug-fix task marking this finding spawned; null when nobody has marked it. */
+            readonly spawn: v.NullableSchema<v.ObjectSchema<{
+                readonly status: v.PicklistSchema<["pending", "spawned", "failed"], undefined>;
+                /** The spawned task's id, addressable through `GET /api/v1/tasks/{taskId}`. */
+                readonly taskId: v.StringSchema<undefined>;
+                /** The run started on that task; null while the claim is pending. */
+                readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+                /** The pipeline the spawned task runs (the expedition's default, or the marking's override). */
+                readonly pipelineId: v.StringSchema<undefined>;
+                /** Epoch ms the claim was taken. */
+                readonly requestedAt: v.NumberSchema<undefined>;
+                /** Why the spawn failed, on a `failed` record. Null otherwise. */
+                readonly failureReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            }, undefined>, undefined>;
+            /** True when a human waved it off. It stays on the record and is not markable. */
+            readonly dismissed: v.BooleanSchema<undefined>;
+        }, undefined>, undefined>;
+        /**
+         * What the expedition planned and what the budget cut; null on an expedition that recorded no
+         * plan. See {@link publicBugFishingPlanSchema} for why the cut cells are published.
+         */
+        readonly plan: v.NullableSchema<v.ObjectSchema<{
+            /** The most container dispatches this expedition may make. */
+            readonly passBudget: v.NumberSchema<undefined>;
+            /** How many cells the full matrix held before the budget trimmed it. */
+            readonly plannedCells: v.NumberSchema<undefined>;
+            /** The cells the budget cut. Empty when the whole matrix fitted. */
+            readonly unfished: v.ArraySchema<v.ObjectSchema<{
+                readonly territoryId: v.StringSchema<undefined>;
+                readonly territoryLabel: v.StringSchema<undefined>;
+                readonly phaseId: v.StringSchema<undefined>;
+                readonly phaseTitle: v.StringSchema<undefined>;
+            }, undefined>, undefined>;
+            /**
+             * True when the tree the survey partitioned was TRUNCATED by the provider. The coverage numbers
+             * are then a share of what was read rather than of the repository, which are opposite readings.
+             */
+            readonly treeTruncated: v.BooleanSchema<undefined>;
+            /**
+             * Why the codebase survey could not run at all (no repository bound to the run, or a client that
+             * cannot enumerate a tree). Non-null means the single territory the expedition fished is a
+             * FALLBACK rather than a small repository, and the two look identical without it.
+             */
+            readonly surveyUnavailableReason: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>;
+        /**
+         * The pipeline a marked finding's spawned task runs when the marking names none. Null when the
+         * expedition resolved none, in which case a marking must name one.
+         */
+        readonly defaultFixPipelineId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+        /** Identifier of the model that fished, for transparency. Null when the run recorded none. */
+        readonly model: v.NullableSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, v.ObjectSchema<{
         readonly kind: v.LiteralSchema<"human-test", undefined>;
         /** Only `awaiting_human` accepts an answer; the others report work in flight. */
@@ -2023,6 +2522,23 @@ export declare const publicDecisionListSchema: v.ObjectSchema<{
         /** Where the answer actually lives, in prose, for a human reading a log or an alert. */
         readonly detail: v.StringSchema<undefined>;
     }, undefined>, undefined>;
+    /**
+     * Whether model-authored TEXT in this payload was clipped to a preview.
+     *
+     * Always `false` from `GET /api/v1/runs/{runId}/decisions`, which serves every field whole. The
+     * SSE decision channel re-sends the whole list on every change, and what the list carries is
+     * model-authored prose in quantity (a deep review parks with a finding per issue, each with its
+     * own detail, evidence and suggested fix), so an unreduced frame repeats all of it for as long
+     * as the run keeps moving. The stream clips the long strings and says so here; the point read is
+     * where a caller goes for the whole thing.
+     *
+     * A flag rather than a per-field marker, because the reduction is kind-AGNOSTIC (it clips by
+     * length, wherever the text sits) and so covers a decision kind that grows a field with no edit.
+     * What it must never mean is that a DECISION was left out: the list itself is always complete,
+     * since an empty `decisions` that means "narrowed" and one that means "nothing is being asked"
+     * are opposite facts.
+     */
+    readonly truncated: v.BooleanSchema<undefined>;
 }, undefined>;
 export type PublicDecisionList = v.InferOutput<typeof publicDecisionListSchema>;
 /** Answer one reviewer finding. Mirrors the SPA's `replyReviewItemSchema` bounds. */
@@ -2179,6 +2695,24 @@ export declare const publicChallengePrReviewFindingSchema: v.ObjectSchema<{
     readonly question: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MaxLengthAction<string, 4000, undefined>]>, undefined>;
 }, undefined>;
 export type PublicChallengePrReviewFindingInput = v.InferOutput<typeof publicChallengePrReviewFindingSchema>;
+/**
+ * Mark bug-fishing findings to be addressed: each one spawns its OWN bug-fix task, linked back to
+ * the expedition.
+ *
+ * Accepted while the expedition is still fishing later angles as well as once it has parked, which
+ * is the flow's whole point: a completed angle's findings are actionable the moment they land.
+ *
+ * `pipelineId` overrides, FOR THIS REQUEST ONLY, the pipeline the spawned tasks run. Omitted, the
+ * expedition's own resolved default applies (the decision publishes it as `defaultFixPipelineId`,
+ * so a caller can see what it is about to get rather than infer it).
+ */
+export declare const publicAddressBugFishingFindingsSchema: v.ObjectSchema<{
+    /** The findings to act on. At least one; an unknown or already-spawned id is refused. */
+    readonly findingIds: v.SchemaWithPipe<readonly [v.ArraySchema<v.StringSchema<undefined>, undefined>, v.MinLengthAction<string[], 1, undefined>]>;
+    /** Pipeline the spawned tasks run; omitted ⇒ the expedition's default. */
+    readonly pipelineId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+}, undefined>;
+export type PublicAddressBugFishingFindingsInput = v.InferOutput<typeof publicAddressBugFishingFindingsSchema>;
 /**
  * Submit findings against a human-verdict gate (human-test or visual-confirmation) and request a
  * fix. The findings ARE the prompt the fixer works from, so unlike the SPA's textarea there is no