@wildo-ai/platform-core-shared 1.1.10 → 1.1.12

package/dist/esm/workbench/workbench-creation-plane.custom.shared.schemas.d.ts

@@ -1,5 +1,5 @@
-import { ApplicationInterviewDepth, MetaWorkflow_ClarificationAction, MetaWorkflow_EvaluationVerdict } from '@wildo-ai/saas-models/meta-workflows';
-import { EngineCapability, HumanDecision_FieldKind } from '@wildo-ai/saas-models';
+import { ApplicationInterviewDepth, MetaWorkflow_ClarificationAction, MetaWorkflow_ElicitationNonAnswer, MetaWorkflow_EvaluationVerdict } from '@wildo-ai/saas-models/meta-workflows';
+import { AgentWorkShortfallKind, EngineCapability, FlowsActors_Status, HumanDecision_FieldKind } from '@wildo-ai/saas-models';
 import { z } from 'zod';
 import { WorkbenchSpecificationArtifactConcern } from './workbench-resources.custom.shared.schemas';
 /**
@@ -50,6 +50,8 @@ export declare enum WorkbenchCreationPlaneBehavior {
     /** The build lane's dispatch history, one row per attempt. */
     BUILD_DISPATCH_PLAN = "creation-plane.build-dispatch-plan",
     BUILD_DISPATCHES = "creation-plane.build-dispatches",
+    /** Everything the build knows about each task (#2530): its attempts, whose failures they were, what they cost, why it has not landed. */
+    BUILD_TASK_RECORDS = "creation-plane.build-task-records",
     /** The playbook runs suspended waiting on a person. */
     PLAYBOOK_RUNS = "creation-plane.playbook-runs",
     WAITING_PLAYBOOK_RUNS = "creation-plane.waiting-playbook-runs",
@@ -152,18 +154,13 @@ export declare enum WorkbenchBuildPlanTaskStatus {
  * stuck tasks, because "nothing can run, and here is why" is an answer.
  */
 export declare enum Workbench_BuildTaskStuckReason {
-    /** It already ran, and its declared product is absent even from the working tree: fix the declaration or the work. */
-    COMPLETED_UNLANDED = "completed_unlanded",
     /**
-     * It already ran, and its declared product IS in the working tree but not committed. Landing means
-     * committed because acceptance is a commit.
+     * It already ran, and its declared product is absent from the working tree: fix the declaration or the work.
      *
-     * Under GUIDED that is the whole story, and the remedy is to review and commit what the run wrote.
-     * Under the autonomy posture the loop has ALREADY tried to commit it (#1534), so reaching this state
-     * means its accept REFUSED a path — carried changes from before the run, edited since, or not this
-     * run's — and the companion's warning names which. The remedy is that refusal's, not a blind commit.
+     * There is no "written, awaiting a commit" reason (#3514): a task lands when its product is in the working tree and
+     * something checked it (#3204), and a commit is a build checkpoint that records, never a condition of landing.
      */
-    COMPLETED_AWAITING_COMMIT = "completed_awaiting_commit",
+    COMPLETED_UNLANDED = "completed_unlanded",
     /** Its run suspended on a question nobody has answered; re-dispatching would abandon that session. */
     PARKED_AWAITING_ANSWER = "parked_awaiting_answer",
     /** It produces a governed document the engine catalog does not define, so no run can author it. */
@@ -180,8 +177,136 @@ export declare enum Workbench_BuildTaskStuckReason {
      * wave several tasks run at once, and the next selection must pass over one already being built,
      * or two agents would build the same task. Nobody's move: it clears when that run settles.
      */
-    IN_FLIGHT = "in_flight"
+    IN_FLIGHT = "in_flight",
+    /**
+     * A live run of ANOTHER task may write one of the files this task's declared products are written to (#3204). Two runs
+     * writing one file in the shared worktree interfere: one overwrites the other, and the wave repairs it after the fact
+     * with a re-check or a re-run. So the wave's own selection passes over it for a ready task whose declared products
+     * meet nothing in flight. Only DECLARED products are compared; a shared file no product names (a module barrel, a
+     * registry) is still left to the after-the-fact repair. Nobody's move: it clears when that run settles.
+     */
+    CONTENDED = "contended",
+    /**
+     * Its latest run failed its checks while other runs of the wave were writing beside it, so the failure may be theirs
+     * (#3204): a sibling's half-written file turned a shared typecheck red, or left a package's compiled output stale so the
+     * check could not be asked at all. It is not dispatched again in the same wave, where it would meet the same tree: the
+     * wave's end re-runs its checks ALONE, a pass lands it and a failure offers it to the next wave. Measured on reference run
+     * 42621319676: two schema tasks re-dispatched five times in nine minutes, each failing on a sibling's red build, spent their
+     * attempt budget while their checks passed alone. Nobody's move: it clears when the wave ends.
+     */
+    AWAITING_ISOLATED_RECHECK = "awaiting_isolated_recheck",
+    /**
+     * A generation step whose landing check could not be ANSWERED right now (#3223): a schema-plan check that neither passed
+     * nor reported drift, a design-token block the CLI could not validate, a brand nobody could read. Not "not landed": it
+     * is UNKNOWN, so it is never dispatched — running it would either fail the same way or redo work that may well have
+     * landed (a companion restart re-ran a landed `design-system-brand` step this way). It clears on its own once the check
+     * answers; when it does not, the dispatch refusal names the check and the command that shows why.
+     */
+    LANDING_UNKNOWN = "landing_unknown",
+    /**
+     * A FOLLOW-UP the host derived from a reported gap (#3227), waiting for the creator's review before it runs: the
+     * autonomy posture (`one-source-of-truth.md` D5) keeps approving a result a person's act, and a follow-up is work the
+     * accepted plan never listed. `wildo build approve <ref>` lets it run; `wildo build close <ref> --declined` closes it.
+     * Never reached under the automatic posture, where follow-ups run as they are derived.
+     */
+    FOLLOW_UP_AWAITING_REVIEW = "follow_up_awaiting_review",
+    /**
+     * A generation step whose panel refused to seat expert charters older than their inputs (#3244): a build task changed
+     * what they read (the design system, say). Passed over so the rest of the plan proceeds, and offered again once the
+     * staffing step, `top_down.expert-personas`, has derived them again, which the build-dispatch step runs on its own
+     * (reference run 42218788356, where the refusal ended the build lane at 32 of 98 tasks). A charter a person edited is
+     * never derived again: its remedy is the hand edit.
+     */
+    STALE_EXPERT_CHARTERS = "stale_expert_charters"
 }
+/**
+ * The stuck reasons that only WAIT for a live run to settle (#1528, #3204): progress, never a finding, and proof that a
+ * run is live. One set, so the dispatch's warning and the Home projection cannot disagree about which reasons mean it.
+ */
+export declare const WORKBENCH_BUILD_TASK_STUCK_REASONS_WAITING_ON_A_LIVE_RUN: ReadonlySet<Workbench_BuildTaskStuckReason>;
+/**
+ * The stuck reasons a RE-ARM releases (#2530): the task is held by its own runs, and the remedy is to fix why and put it
+ * back — `WorkbenchBuildPlanTasks_Operations.REARM` is offered for these and no other.
+ *
+ * - `completed_unlanded`: a completed run holds it through the loop guard, and a re-arm releases that run.
+ * - `attempts_exhausted`: its failed runs hold it through the attempt budget, and a re-arm releases them.
+ *
+ * Left out, each because a re-arm would be the wrong remedy: `parked_awaiting_answer` (a question waits), `in_flight` (a run is
+ * live), `no_document_blueprint` (no run can produce it), `landing_unknown` (nothing holds it but a check that has not
+ * answered yet).
+ */
+export declare const WORKBENCH_REARMABLE_STUCK_REASONS: readonly Workbench_BuildTaskStuckReason[];
+/**
+ * Whose failure a failed coding run was (#1581), as the run's output records it.
+ *
+ * TASK runs are counted against the task's attempt budget; HOST runs (the run could not be recorded, or the turn was
+ * taken away: a mid-turn kill, a provider's 529/429, an exhausted quota, an expired login, an operator's cancel) are
+ * forgiven up to a bound. Declared here rather than beside its producer (the companion's coding dispatch) for the reason
+ * `Workbench_BuildTaskStuckReason` gives: the workbench shows it per attempt (#2530), and a browser bundle cannot import
+ * the companion.
+ */
+export declare enum CodingRunFailureAttribution {
+    /** The task's own failure: its checks went red, or its agent ran and failed at the work. Counted. */
+    TASK = "task",
+    /** The host's: it could not record the run, or the turn was taken away. Forgiven, up to a bound. */
+    HOST = "host"
+}
+/**
+ * WHY a build task was put back in the queue (#1535) — the one question a later reader of a re-arm asks.
+ *
+ * A re-arm keeps a task's run history and adds one fact to it, on the runs it releases: they no longer hold the task,
+ * and here is why. Declared here rather than beside its producer (the companion's build dispatch) because the workbench
+ * both offers the re-arm (`WorkbenchBuildPlanTasks_Operations.REARM`) and shows each attempt's reason (#2530), and a
+ * browser bundle cannot import the companion.
+ */
+export declare enum BuildTaskRearmReason {
+    /** The landing check was wrong about this task, and has been corrected. */
+    PROBE_CORRECTED = "probe-corrected",
+    /** A defect outside the task made its product impossible to produce, and has been fixed. */
+    BLOCKING_DEFECT_FIXED = "blocking-defect-fixed",
+    /** Neither of the above: an operator judged the work should run again. The note says why. */
+    OPERATOR_JUDGEMENT = "operator-judgement",
+    /**
+     * The ENVIRONMENT failed the runs, not the task (#3236): the network or the machine went away (DNS lost, a connection
+     * cut, a sleep) and the runs the outage took are released. Distinct from `operator-judgement` so a later reader of the
+     * task's history sees that its failed attempts said nothing about the work.
+     */
+    ENVIRONMENT = "environment",
+    /**
+     * Set by the BUILD WAVE, never by a person (#2210): the run completed while other runs edited the same tree, and its
+     * declared product is missing from a file one of them also changed, so the loss is theirs rather than the task's. The
+     * wave re-arms the task and re-runs it alone, a bounded number of times (`MAXIMUM_INTERFERENCE_REARMS`).
+     * The run also carries the interference the wave found (`BuildTaskInterference`, companion-side).
+     *
+     * Like every re-arm it also releases the task's FAILED runs not yet re-armed, so the attempt budget starts afresh.
+     * Deliberate: the task did complete, so its earlier failures say nothing about whether the work can be done, and the
+     * interference bound still stops a task that keeps losing its product.
+     */
+    INTERFERED_BY_CONCURRENT_RUN = "interfered-by-concurrent-run"
+}
+/**
+ * How a build task a PERSON closed is accounted for (`wildo build close`, #3224, #3225, #3227) — the one question a reader
+ * of a closed task asks: what made it done, if anything did. A closure never makes a task's product true; it records that
+ * a person said it is done another way, or that a derived follow-up is not wanted. Declared here rather than beside its
+ * producer (the companion's build dispatch) because the workbench shows it on the task's record, and a browser bundle
+ * cannot import the companion.
+ */
+export declare enum BuildTaskClosureKind {
+    /** Another task of the plan built what this one was for. It counts as landed while that task is landed. */
+    SATISFIED_BY_TASK = "satisfied_by_task",
+    /** A commit HEAD contains built it (a person's, a reconciliation's). It counts as landed while the closure is committed. */
+    SATISFIED_BY_COMMIT = "satisfied_by_commit",
+    /** A host-derived follow-up the creator declines: the gap it answers is not worked. Follow-ups only. */
+    DECLINED = "declined"
+}
+/**
+ * The reasons a PERSON may give (`wildo build rearm`, the companion's re-arm route, the workbench's `rearm` operation).
+ * The wave's own reason is left out: it asserts a measurement (a sibling changed the product's file during the run)
+ * that only the wave makes, and an operator choosing it would record a detection that never happened.
+ */
+export declare const OPERATOR_BUILD_TASK_REARM_REASONS: readonly [BuildTaskRearmReason.PROBE_CORRECTED, BuildTaskRearmReason.BLOCKING_DEFECT_FIXED, BuildTaskRearmReason.OPERATOR_JUDGEMENT, BuildTaskRearmReason.ENVIRONMENT];
+/** One of the reasons a person may give a re-arm. */
+export type OperatorBuildTaskRearmReason = (typeof OPERATOR_BUILD_TASK_REARM_REASONS)[number];
 /**
  * How far one BUILD DISPATCH got — the whole of what `GET /build/dispatches` can honestly say.
  *
@@ -209,7 +334,10 @@ export declare enum Workbench_BuildTaskStuckReason {
 export declare enum Workbench_BuildDispatchPhase {
     /** Selected and handed to its executor; nothing has resolved yet. */
     SUBMITTED = "submitted",
-    /** A coding run was admitted and is running. Its outcome is the durable actor-task row `codingTaskId`. */
+    /**
+     * A coding run was admitted. The phase names the HAND-OFF and stays ADMITTED however the run ends: how
+     * the run stands is `Workbench_BuildDispatch.runStatus`, read off the same execution row (#2523).
+     */
     ADMITTED = "admitted",
     /** A companion generation step ran to completion. */
     FINISHED = "finished",
@@ -225,34 +353,38 @@ export declare enum Workbench_BuildDispatchPhase {
  * row (`phase`, `computedAt`) because a resource row must be complete on its own.
  */
 export declare const Workbench_Playbook_Schema: z.ZodObject<{
-    workbenchPlaybookId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    playbookRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    playbookVersion: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    phase: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    intent: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    eligible: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    unmet: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    blockedOnlyBySequencing: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    requiresElicitation: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    unansweredQuestionRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    wouldReplace: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    outputOwners: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    workbenchPlaybookId: z.ZodString;
+    playbookRef: z.ZodString;
+    playbookVersion: z.ZodString;
+    phase: z.ZodString;
+    intent: z.ZodString;
+    eligible: z.ZodBoolean;
+    unmet: z.ZodArray<z.ZodString>;
+    blockedOnlyBySequencing: z.ZodBoolean;
+    requiresElicitation: z.ZodBoolean;
+    unansweredQuestionRefs: z.ZodArray<z.ZodString>;
+    wouldReplace: z.ZodArray<z.ZodString>;
+    outputOwners: z.ZodArray<z.ZodObject<{
         family: z.ZodString;
         playbookRefs: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-    unresolvedPlaybookRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    unlandableFamilies: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    staleOutputs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    }, z.core.$strip>>;
+    unresolvedPlaybookRefs: z.ZodArray<z.ZodString>;
+    unlandableFamilies: z.ZodArray<z.ZodString>;
+    staleOutputs: z.ZodArray<z.ZodObject<{
         family: z.ZodString;
         changedInputs: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-    activeInLine: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodBoolean>>;
-    activationDetail: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodString>>;
-    openInstances: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    }, z.core.$strip>>;
+    activeInLine: z.ZodOptional<z.ZodBoolean>;
+    activationDetail: z.ZodOptional<z.ZodString>;
+    openInstances: z.ZodOptional<z.ZodArray<z.ZodObject<{
         instanceKey: z.ZodString;
         purpose: z.ZodString;
-    }, z.core.$strip>>>>;
-    computedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
+    }, z.core.$strip>>>;
+    inputFamilyIds: z.ZodArray<z.ZodString>;
+    preconditionFamilyIds: z.ZodArray<z.ZodString>;
+    conditionFamilyIds: z.ZodArray<z.ZodString>;
+    admittedPlaybookIds: z.ZodArray<z.ZodString>;
+    computedAt: z.ZodDate;
 }, z.core.$strip>;
 export type Workbench_Playbook = z.infer<typeof Workbench_Playbook_Schema>;
 /**
@@ -264,15 +396,33 @@ export type Workbench_Playbook = z.infer<typeof Workbench_Playbook_Schema>;
  * stays on the aspect row sharing the same `taskRef`.
  */
 export declare const Workbench_BuildPlanTask_Schema: z.ZodObject<{
-    workbenchBuildPlanTaskId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    taskRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    objective: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    targetKind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    functionalTopic: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchBuildPlanTaskStatus>>>;
-    prerequisiteTaskRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
+    workbenchBuildPlanTaskId: z.ZodString;
+    taskRef: z.ZodString;
+    objective: z.ZodString;
+    targetKind: z.ZodString;
+    functionalTopic: z.ZodString;
+    status: z.ZodEnum<typeof WorkbenchBuildPlanTaskStatus>;
+    prerequisiteTaskRefs: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export type Workbench_BuildPlanTask = z.infer<typeof Workbench_BuildPlanTask_Schema>;
+/**
+ * The BUILD PLAN view's `ref` (#2531): the plan drawn as a graph, a menubar destination beside the domain model. Its
+ * nodes are the build-plan tasks and its edges their prerequisites; a node opens the task's own page.
+ *
+ * It must not contain a dot, for the reason `WORKBENCH_DOMAIN_MODEL_VIEW_REF` records: the label lookup splits the
+ * whole `composite_views.<translationRef>.<key>` path on `.`.
+ */
+export declare const WORKBENCH_BUILD_PLAN_VIEW_REF = "build-plan";
+/** The label key the view's title and description hang off: the engine's `app.<ref>` derivation, restated. */
+export declare const WORKBENCH_BUILD_PLAN_TRANSLATION_REF = "app.build-plan";
+/**
+ * The PLAYBOOK MAP view's `ref` (#2531): the playbook catalog drawn as what unlocks what, a menubar destination beside
+ * the build plan. Its nodes are the playbooks and the families they name; its edges what each writes, reads, waits for
+ * and, as a composite, runs (the playbook row's declared edges, #2530). No dot, for the domain model's reason.
+ */
+export declare const WORKBENCH_PLAYBOOK_MAP_VIEW_REF = "playbook-map";
+/** The label key the view's title and description hang off: the engine's `app.<ref>` derivation, restated. */
+export declare const WORKBENCH_PLAYBOOK_MAP_TRANSLATION_REF = "app.playbook-map";
 /**
  * One run's write record — the evidence lane behind every dispatch.
  *
@@ -281,28 +431,33 @@ export type Workbench_BuildPlanTask = z.infer<typeof Workbench_BuildPlanTask_Sch
  * every LIST.
  */
 export declare const Workbench_RunWriteRecord_Schema: z.ZodObject<{
-    workbenchRunWriteRecordId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    runId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    playbookRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    workbenchPlaybookId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    workbenchTraceSessionId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
-    at: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
-    files: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    workbenchRunWriteRecordId: z.ZodString;
+    runId: z.ZodString;
+    playbookRef: z.ZodString;
+    workbenchPlaybookId: z.ZodString;
+    workbenchTraceSessionId: z.ZodNullable<z.ZodString>;
+    at: z.ZodDate;
+    files: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         existedBefore: z.ZodBoolean;
-    }, z.core.$strip>>>;
-    fileCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    acceptedCommitSha: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    }, z.core.$strip>>;
+    fileCount: z.ZodNumber;
+    acceptedCommitSha: z.ZodNullable<z.ZodString>;
+    landingFailed: z.ZodBoolean;
+    failedLandingRemedies: z.ZodNullable<z.ZodObject<{
+        accept: z.ZodString;
+        revert: z.ZodString;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Workbench_RunWriteRecord = z.infer<typeof Workbench_RunWriteRecord_Schema>;
 /** One execution-trace session — the queryable index the board links from. */
 export declare const Workbench_TraceSession_Schema: z.ZodObject<{
-    workbenchTraceSessionId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    sessionId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    startedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
-    label: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    eventCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    stepCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
+    workbenchTraceSessionId: z.ZodString;
+    sessionId: z.ZodString;
+    startedAt: z.ZodDate;
+    label: z.ZodNullable<z.ZodString>;
+    eventCount: z.ZodNumber;
+    stepCount: z.ZodNumber;
 }, z.core.$strip>;
 export type Workbench_TraceSession = z.infer<typeof Workbench_TraceSession_Schema>;
 /**
@@ -366,7 +521,18 @@ export declare enum WorkbenchDossierEntryStanding {
      * decided: the run treats it as a working hypothesis, and this standing is how the dossier lists it to revisit.
      * Changing it records the creator's own answer in its place.
      */
-    ASSUMED = "assumed"
+    ASSUMED = "assumed",
+    /**
+     * The creator said the question does not concern this application, and why (#3437). Answered — nothing is
+     * blocked — and never filled in by a run. Changing it records an answer, or the other non-answer, in its place.
+     */
+    NOT_APPLICABLE = "not-applicable",
+    /**
+     * The creator said the question concerns this application and is not decided yet, and why (#3437). Nothing waits
+     * on it: the step runs and marks what rests on it as owed; a governed document shows the clause as owed. Listed
+     * to revisit, like an assumption.
+     */
+    DEFERRED = "deferred"
 }
 /**
  * Whether a CHOICE question's options can be offered right now — for a question whose options are
@@ -385,33 +551,33 @@ export declare enum WorkbenchDossierEntryOptionsState {
     ANSWER_NO_LONGER_OFFERED = "answer-no-longer-offered"
 }
 export declare const Workbench_GovernanceDocument_Schema: z.ZodObject<{
-    workbenchGovernanceDocumentId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    definitionRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    askCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    derivedFactRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    openCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    drafted: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
+    workbenchGovernanceDocumentId: z.ZodString;
+    definitionRef: z.ZodString;
+    askCount: z.ZodNumber;
+    derivedFactRefs: z.ZodArray<z.ZodString>;
+    openCount: z.ZodNumber;
+    drafted: z.ZodBoolean;
 }, z.core.$strip>;
 export type Workbench_GovernanceDocument = z.infer<typeof Workbench_GovernanceDocument_Schema>;
 export declare const Workbench_GovernanceQuestion_Schema: z.ZodObject<{
-    workbenchGovernanceQuestionId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    definitionRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    questionRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    factRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    creatorPrompt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    decisionPurpose: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    answerKind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    factAuthorityKind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    allowsNotApplicable: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    sensitivityRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    semanticOptions: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    workbenchGovernanceQuestionId: z.ZodString;
+    definitionRef: z.ZodString;
+    questionRef: z.ZodString;
+    factRef: z.ZodString;
+    creatorPrompt: z.ZodString;
+    decisionPurpose: z.ZodString;
+    answerKind: z.ZodString;
+    factAuthorityKind: z.ZodString;
+    allowsNotApplicable: z.ZodBoolean;
+    sensitivityRef: z.ZodString;
+    semanticOptions: z.ZodArray<z.ZodObject<{
         optionRef: z.ZodString;
         creatorMeaning: z.ZodString;
-    }, z.core.$strip>>>;
-    standing: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchDossierEntryStanding>>>;
-    answerSummary: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    answeredAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodDate>>;
-    askedNow: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    standing: z.ZodEnum<typeof WorkbenchDossierEntryStanding>;
+    answerSummary: z.ZodNullable<z.ZodString>;
+    answeredAt: z.ZodNullable<z.ZodDate>;
+    askedNow: z.ZodBoolean;
 }, z.core.$strip>;
 export type Workbench_GovernanceQuestion = z.infer<typeof Workbench_GovernanceQuestion_Schema>;
 /** The playbook resource's dispatch verbs. */
@@ -450,6 +616,13 @@ export declare enum WorkbenchBuildPlanTasks_Operations {
      * A non-ready task answers 409 naming what it waits on. Costs a coding run.
      */
     DISPATCH_TASK = "dispatch_task",
+    /**
+     * Put THIS task back in the queue once the reason it did not land is fixed (#1535, #2530): its completed runs that
+     * still hold it, and its failed runs not yet re-armed, stop counting, each recording why. Offered for a task held by
+     * either guard (`completed_unlanded`, `attempts_exhausted`); a task with no such run answers 409, since there is
+     * nothing to release. Runs nothing itself: the next dispatch offers the task again.
+     */
+    REARM = "rearm",
     /**
      * ACCEPT what this task's latest completed coding run wrote: commit exactly those paths, from the
      * coding-run write register, in one commit whose message names the task. Paths carrying another
@@ -523,6 +696,17 @@ export declare const Workbench_BuildPlanDispatchTaskRequest_Schema: z.ZodObject<
     conversationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type Workbench_BuildPlanDispatchTaskRequest = z.infer<typeof Workbench_BuildPlanDispatchTaskRequest_Schema>;
+/** Why a build task goes back in the queue (#2530): a person's reason, and what was fixed. */
+export declare const Workbench_BuildTaskRearmRequest_Schema: z.ZodObject<{
+    reason: z.ZodEnum<{
+        "probe-corrected": BuildTaskRearmReason.PROBE_CORRECTED;
+        "blocking-defect-fixed": BuildTaskRearmReason.BLOCKING_DEFECT_FIXED;
+        "operator-judgement": BuildTaskRearmReason.OPERATOR_JUDGEMENT;
+        environment: BuildTaskRearmReason.ENVIRONMENT;
+    }>;
+    note: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_BuildTaskRearmRequest = z.infer<typeof Workbench_BuildTaskRearmRequest_Schema>;
 export declare const Workbench_AcceptChangesRequest_Schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
@@ -557,16 +741,38 @@ export declare const Workbench_PlaybookRunOutcome_Schema: z.ZodObject<{
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_PlaybookRunOutcome = z.infer<typeof Workbench_PlaybookRunOutcome_Schema>;
+/**
+ * How a build dispatch answers (#2531 review M1): the companion forwards its dispatch result as it is. One task run
+ * answers the task it dispatched (`plan`) and what started for it, a coding run's `admission` or the result of a
+ * `generationStep` the companion ran itself, exactly one of the two. A parallel `dispatch_next` answers the `wave` it
+ * started, with a `note`.
+ *
+ * There is no top-level `taskRef`. This schema declared one, which no answer ever carried, so the line saying what a run
+ * started was never shown and the raw answer opened in its place.
+ */
 export declare const Workbench_BuildPlanDispatchOutcome_Schema: z.ZodObject<{
-    taskRef: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodObject<{
+        taskRef: z.ZodString;
+    }, z.core.$loose>>;
+    admission: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    generationStep: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    wave: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_BuildPlanDispatchOutcome = z.infer<typeof Workbench_BuildPlanDispatchOutcome_Schema>;
+/** How a re-arm answers: the runs it released, and the reason it recorded on them. */
+export declare const Workbench_BuildTaskRearmOutcome_Schema: z.ZodObject<{
+    rearmedRunTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    rearm: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodEnum<typeof BuildTaskRearmReason>;
+        note: z.ZodString;
+        rearmedAt: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type Workbench_BuildTaskRearmOutcome = z.infer<typeof Workbench_BuildTaskRearmOutcome_Schema>;
 export declare const Workbench_BuildPlanAddTaskOutcome_Schema: z.ZodObject<{
     taskRef: z.ZodOptional<z.ZodString>;
-    /** TRUE when no plan existed and this task is its first. */
     createdPlan: z.ZodOptional<z.ZodBoolean>;
-    /** Validator findings below the hard floor — worth telling the creator, never a refusal. */
     advisoryFindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
         code: z.ZodString;
         taskRef: z.ZodString;
@@ -577,6 +783,7 @@ export declare const Workbench_BuildPlanAddTaskOutcome_Schema: z.ZodObject<{
 export type Workbench_BuildPlanAddTaskOutcome = z.infer<typeof Workbench_BuildPlanAddTaskOutcome_Schema>;
 /** How ACCEPT answers, for a task's coding run or a playbook run alike: what was committed, what was refused and why. */
 export declare const Workbench_AcceptChangesOutcome_Schema: z.ZodObject<{
+    alreadyCommitted: z.ZodOptional<z.ZodBoolean>;
     commitSha: z.ZodOptional<z.ZodString>;
     committedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     refusedPaths: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -590,16 +797,12 @@ export type Workbench_AcceptChangesOutcome = z.infer<typeof Workbench_AcceptChan
 export declare const Workbench_RunWriteRevertOutcome_Schema: z.ZodObject<{
     runId: z.ZodOptional<z.ZodString>;
     reverted: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    /** Files whose current bytes differ from what the run wrote — refused by name, revertable with force. */
     refusedDiverged: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    /**
-     * Files a LATER recorded run landed on (#1614): refused even under force, because the earlier bytes
-     * would destroy that run's work. Each names the run to revert first (#1666).
-     */
     refusedLaterRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         runId: z.ZodString;
     }, z.core.$strip>>>;
+    refusedWithoutPreImage: z.ZodOptional<z.ZodArray<z.ZodString>>;
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_RunWriteRevertOutcome = z.infer<typeof Workbench_RunWriteRevertOutcome_Schema>;
@@ -635,45 +838,253 @@ export type Workbench_RunWriteRevertOutcome = z.infer<typeof Workbench_RunWriteR
  * on this row so the finished state can say how far it got.
  */
 export declare const Workbench_BuildDispatchPlan_Schema: z.ZodObject<{
-    workbenchBuildDispatchPlanId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    taskRef: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    objective: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    targetKind: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    generationStepRef: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    allowedPathPrefixes: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    prohibitedPathPrefixes: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    requiredChecks: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    installedSkillRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    readyTaskRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    landedTaskRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    unverifiableLandedTaskRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    landedBeforeAnyRunTaskRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    exhausted: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    stuckTasks: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    workbenchBuildDispatchPlanId: z.ZodString;
+    taskRef: z.ZodNullable<z.ZodString>;
+    objective: z.ZodNullable<z.ZodString>;
+    targetKind: z.ZodNullable<z.ZodString>;
+    generationStepRef: z.ZodNullable<z.ZodString>;
+    allowedPathPrefixes: z.ZodArray<z.ZodString>;
+    prohibitedPathPrefixes: z.ZodArray<z.ZodString>;
+    requiredChecks: z.ZodArray<z.ZodString>;
+    installedSkillRefs: z.ZodArray<z.ZodString>;
+    readyTaskRefs: z.ZodArray<z.ZodString>;
+    landedTaskRefs: z.ZodArray<z.ZodString>;
+    unverifiableLandedTaskRefs: z.ZodArray<z.ZodString>;
+    landedBeforeAnyRunTaskRefs: z.ZodArray<z.ZodString>;
+    exhausted: z.ZodBoolean;
+    failingSpecificationModules: z.ZodArray<z.ZodString>;
+    specificationRepairOwed: z.ZodBoolean;
+    stuckTasks: z.ZodArray<z.ZodObject<{
         taskRef: z.ZodString;
-        reason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof Workbench_BuildTaskStuckReason>>;
+        reason: z.ZodEnum<typeof Workbench_BuildTaskStuckReason>;
         priorTaskId: z.ZodNullable<z.ZodString>;
-        uncommittedPaths: z.ZodArray<z.ZodString>;
         question: z.ZodNullable<z.ZodString>;
         documentRef: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>>;
-    taskCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    landedCount: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
+    }, z.core.$strip>>;
+    taskCount: z.ZodNumber;
+    landedCount: z.ZodNumber;
 }, z.core.$strip>;
 export type Workbench_BuildDispatchPlan = z.infer<typeof Workbench_BuildDispatchPlan_Schema>;
 export declare const Workbench_BuildDispatch_Schema: z.ZodObject<{
-    workbenchBuildDispatchId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    taskRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    objective: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    phase: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof Workbench_BuildDispatchPhase>>>;
-    startedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
-    settledAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    codingTaskId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
-    error: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    conversationId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    accepted: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>>;
+    workbenchBuildDispatchId: z.ZodString;
+    taskRef: z.ZodString;
+    objective: z.ZodNullable<z.ZodString>;
+    phase: z.ZodEnum<typeof Workbench_BuildDispatchPhase>;
+    startedAt: z.ZodDate;
+    settledAt: z.ZodNullable<z.ZodDate>;
+    codingTaskId: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    failureAttribution: z.ZodNullable<z.ZodEnum<typeof CodingRunFailureAttribution>>;
+    conversationId: z.ZodNullable<z.ZodString>;
+    runStatus: z.ZodEnum<typeof FlowsActors_Status>;
+    runFinishedAt: z.ZodNullable<z.ZodDate>;
+    accepted: z.ZodNullable<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Workbench_BuildDispatch = z.infer<typeof Workbench_BuildDispatch_Schema>;
+/**
+ * One ATTEMPT at a build task (#2530): one actor execution, as the build's record reads it. A coding run, or a companion
+ * generation step (labels, migrations, translations).
+ */
+export declare const Workbench_BuildTaskAttempt_Schema: z.ZodObject<{
+    runTaskId: z.ZodString;
+    startedAt: z.ZodDate;
+    settledAt: z.ZodNullable<z.ZodDate>;
+    status: z.ZodEnum<typeof FlowsActors_Status>;
+    generationStep: z.ZodBoolean;
+    refusedBeforeStart: z.ZodBoolean;
+    ranNothing: z.ZodBoolean;
+    failureAttribution: z.ZodNullable<z.ZodEnum<typeof CodingRunFailureAttribution>>;
+    interferenceSuspected: z.ZodBoolean;
+    rearmReason: z.ZodNullable<z.ZodEnum<typeof BuildTaskRearmReason>>;
+    rearmNote: z.ZodNullable<z.ZodString>;
+    error: z.ZodNullable<z.ZodString>;
+    costAmount: z.ZodNullable<z.ZodNumber>;
+    costCurrency: z.ZodNullable<z.ZodString>;
+    spendIsFloor: z.ZodBoolean;
+    totalTokens: z.ZodNullable<z.ZodNumber>;
+    filesChanged: z.ZodNullable<z.ZodNumber>;
+    failedCheckRefs: z.ZodArray<z.ZodString>;
+    outOfScopePaths: z.ZodArray<z.ZodString>;
+    interference: z.ZodNullable<z.ZodObject<{
+        overlappingTaskRefs: z.ZodArray<z.ZodString>;
+        contendedProductPaths: z.ZodArray<z.ZodString>;
+        requeued: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workbench_BuildTaskAttempt = z.infer<typeof Workbench_BuildTaskAttempt_Schema>;
+/**
+ * What `wildo db diff --check` could tell the host about the resource model versus the accepted schema plan.
+ *
+ * THREE answers, not two. A boolean merged the two failures that lead to opposite places (found in review,
+ * 2026-09-13): DRIFTED means the migration step has work and must run first; UNANSWERABLE means the check did not
+ * report drift and did not pass — no accepted plan and an undeterminable store declaration, no built backend registry, a compiled model older than its
+ * sources (`assessCompiledModelCurrency`, #403: before it, a dead watcher's stale dist answered IN_SYNC and landed
+ * this step with drift on disk), a CLI that could not import
+ * it or could not be spawned, a timeout, a lockfile that fails strict parsing, or an ENGINE planner-contract
+ * mismatch (whose remedy is `wildo db generate --accept-planner-contract`, not a rebuild) — and
+ * running the step then only throws. Read as one "not in sync", an unanswerable check put a step that can
+ * only fail at the head of the build queue on every dispatch, so no other task could run.
+ *
+ * Only IN_SYNC ever lands the step: an unanswered question must not land a migration step either.
+ *
+ * Declared here rather than beside its producer (the companion's generation steps) because the workbench shows it on a
+ * step's record (#2530).
+ */
+export declare enum SchemaPlanSyncState {
+    /** The model and the accepted plan agree: the migration step has landed. */
+    IN_SYNC = "in_sync",
+    /** The check ran and reported ungenerated changes: the migration step has work to do. */
+    DRIFTED = "drifted",
+    /** The check neither passed nor reported drift (see above for the causes); running the step now would refuse or fail. */
+    UNANSWERABLE = "unanswerable"
+}
+/**
+ * What `wildo design-tokens validate` could tell the host about the stylesheet's generated block.
+ *
+ * Three answers, for the reason {@link SchemaPlanSyncState} has three: the command exits non-zero for a
+ * stale block AND for every could-not-ask failure (a config that does not load, a stylesheet with no
+ * markers, a CLI that cannot start or times out), and the two lead to opposite places. STALE means the
+ * `design-tokens` step has work; UNANSWERABLE means running it would refuse or fail the same way, so the
+ * dispatch host passes over it while other work is ready.
+ *
+ * Declared here for the reason {@link SchemaPlanSyncState} is (#2530).
+ */
+export declare enum DesignTokenBlockState {
+    /** The block is exactly what `generate` would write from the config. */
+    CURRENT = "current",
+    /** The block differs from what `generate` would write: the step has work. */
+    STALE = "stale",
+    /** The command neither confirmed nor refuted the block; running the step now would fail the same way. */
+    UNANSWERABLE = "unanswerable"
+}
+/**
+ * Does every module the brand step writes (the frontend's brand design, and the website's colours when a website is
+ * declared) say what the brand's visual tone now renders?
+ *
+ * Three answers, for the reason {@link DesignTokenBlockState} has three: STALE means the step has work and runs,
+ * UNANSWERABLE means the brand could not be read (the specifications do not evaluate, or this host has no
+ * introspection), and running the step then only throws, so the selector passes it over while other work is ready.
+ *
+ * Declared here for the reason {@link SchemaPlanSyncState} is (#2530).
+ */
+export declare enum BrandDesignState {
+    /** Every module exists and equals the render of the brand's current visual tone. */
+    CURRENT = "current",
+    /** A module is absent or says something the brand no longer does. */
+    STALE = "stale",
+    /** The brand's visual tone could not be read, so currency cannot be decided either way. */
+    UNANSWERABLE = "unanswerable"
+}
+/** A landing probe the working tree does not satisfy (#2530, #3204): what landing searched for there, and what is missing. */
+export declare const Workbench_BuildTaskUnmetProbe_Schema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString>;
+    declarations: z.ZodArray<z.ZodString>;
+    keyPrefix: z.ZodNullable<z.ZodString>;
+    shellSurface: z.ZodNullable<z.ZodString>;
+    shell: z.ZodNullable<z.ZodObject<{
+        unanswerable: z.ZodNullable<z.ZodString>;
+        missing: z.ZodArray<z.ZodString>;
+        declinedButPresent: z.ZodArray<z.ZodString>;
+        absentPaths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    registered: z.ZodNullable<z.ZodObject<{
+        unanswerable: z.ZodNullable<z.ZodString>;
+        missing: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<typeof AgentWorkShortfallKind>;
+            ref: z.ZodString;
+            planned: z.ZodNullable<z.ZodString>;
+            registered: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        absentPaths: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workbench_BuildTaskUnmetProbe = z.infer<typeof Workbench_BuildTaskUnmetProbe_Schema>;
+/**
+ * Everything the build knows about ONE task, in one row (#2530, from the companion's per-task record, #1521).
+ *
+ * The case it exists for: "not landed" hid three facts — never dispatched, dispatched and FAILED, dispatched,
+ * SUCCEEDED and unprovable — and they are three shapes here: no attempts; a failed attempt; a completed attempt with
+ * unmet probes. Its id IS the build-plan task row's id, so a task's detail reads its record by the id it already has;
+ * it is its own resource because reading attempts, classifying a stuck task and probing the tree is too much to pay on
+ * every row of the task list.
+ *
+ * The attempts are read from the actor plane by ONE listing per coding system, bounded far above a whole build's runs;
+ * `attemptsTruncated` says when that bound was met, so an early task's oldest runs may be missing and "never run" is not
+ * claimed.
+ */
+export declare const Workbench_BuildTaskRecord_Schema: z.ZodObject<{
+    workbenchBuildTaskRecordId: z.ZodString;
+    workbenchBuildPlanTaskId: z.ZodString;
+    taskRef: z.ZodString;
+    status: z.ZodEnum<typeof WorkbenchBuildPlanTaskStatus>;
+    attemptCount: z.ZodNumber;
+    attempts: z.ZodArray<z.ZodObject<{
+        runTaskId: z.ZodString;
+        startedAt: z.ZodDate;
+        settledAt: z.ZodNullable<z.ZodDate>;
+        status: z.ZodEnum<typeof FlowsActors_Status>;
+        generationStep: z.ZodBoolean;
+        refusedBeforeStart: z.ZodBoolean;
+        ranNothing: z.ZodBoolean;
+        failureAttribution: z.ZodNullable<z.ZodEnum<typeof CodingRunFailureAttribution>>;
+        interferenceSuspected: z.ZodBoolean;
+        rearmReason: z.ZodNullable<z.ZodEnum<typeof BuildTaskRearmReason>>;
+        rearmNote: z.ZodNullable<z.ZodString>;
+        error: z.ZodNullable<z.ZodString>;
+        costAmount: z.ZodNullable<z.ZodNumber>;
+        costCurrency: z.ZodNullable<z.ZodString>;
+        spendIsFloor: z.ZodBoolean;
+        totalTokens: z.ZodNullable<z.ZodNumber>;
+        filesChanged: z.ZodNullable<z.ZodNumber>;
+        failedCheckRefs: z.ZodArray<z.ZodString>;
+        outOfScopePaths: z.ZodArray<z.ZodString>;
+        interference: z.ZodNullable<z.ZodObject<{
+            overlappingTaskRefs: z.ZodArray<z.ZodString>;
+            contendedProductPaths: z.ZodArray<z.ZodString>;
+            requeued: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    attemptsTruncated: z.ZodBoolean;
+    stuckReason: z.ZodNullable<z.ZodEnum<typeof Workbench_BuildTaskStuckReason>>;
+    stuckQuestion: z.ZodNullable<z.ZodString>;
+    stuckDocumentRef: z.ZodNullable<z.ZodString>;
+    waitingOnTaskRefs: z.ZodArray<z.ZodString>;
+    unmetProbes: z.ZodArray<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+        declarations: z.ZodArray<z.ZodString>;
+        keyPrefix: z.ZodNullable<z.ZodString>;
+        shellSurface: z.ZodNullable<z.ZodString>;
+        shell: z.ZodNullable<z.ZodObject<{
+            unanswerable: z.ZodNullable<z.ZodString>;
+            missing: z.ZodArray<z.ZodString>;
+            declinedButPresent: z.ZodArray<z.ZodString>;
+            absentPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        registered: z.ZodNullable<z.ZodObject<{
+            unanswerable: z.ZodNullable<z.ZodString>;
+            missing: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<typeof AgentWorkShortfallKind>;
+                ref: z.ZodString;
+                planned: z.ZodNullable<z.ZodString>;
+                registered: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+            absentPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    schemaPlanSyncState: z.ZodNullable<z.ZodEnum<typeof SchemaPlanSyncState>>;
+    designTokenBlockState: z.ZodNullable<z.ZodEnum<typeof DesignTokenBlockState>>;
+    brandDesignState: z.ZodNullable<z.ZodEnum<typeof BrandDesignState>>;
+    landingBlockedBy: z.ZodNullable<z.ZodString>;
+    followUpTaskIds: z.ZodArray<z.ZodString>;
+    followUpOfTaskId: z.ZodNullable<z.ZodString>;
+    closureKind: z.ZodNullable<z.ZodEnum<typeof BuildTaskClosureKind>>;
+    closureSatisfiedBy: z.ZodNullable<z.ZodString>;
+    closureReason: z.ZodNullable<z.ZodString>;
+    unverifiable: z.ZodBoolean;
+    landedBeforeAnyRun: z.ZodBoolean;
+    landedBeforeAnyRunPaths: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_BuildTaskRecord = z.infer<typeof Workbench_BuildTaskRecord_Schema>;
 /**
  * One playbook run SUSPENDED waiting on a person.
  *
@@ -715,6 +1126,44 @@ export declare enum Workbench_PlaybookRunState {
      */
     AWAITING_ANSWER = "awaiting_answer"
 }
+/**
+ * One child of a composite run's round (#2530): the playbook that ran in it, why it was on the table, what it landed and
+ * whether it failed — the record's own summary (`PlaybookRunChoreographyChildSummary`), with its measurement left on the
+ * run's record. A child that was itself a LANE is known by the rounds that name it as their lane.
+ */
+export declare const Workbench_PlaybookRunRoundChild_Schema: z.ZodObject<{
+    playbookRef: z.ZodString;
+    ranBecause: z.ZodNullable<z.ZodString>;
+    reranOverLanding: z.ZodNullable<z.ZodBoolean>;
+    landed: z.ZodArray<z.ZodString>;
+    failure: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_PlaybookRunRoundChild = z.infer<typeof Workbench_PlaybookRunRoundChild_Schema>;
+/**
+ * One round of a composite run (#2530): the root's, or a nested lane's. FLAT rather than nested: a lane's rounds follow
+ * the round whose child ran the lane and name it (`parentRoundKey`, `lanePlaybookRef`), so a process map nests them as
+ * groups without a recursive contract, and every depth the record keeps reaches the row.
+ *
+ * The choreography's own stop reason (`PlaybookChoreographyStopReason`) is NOT here: it is a closed vocabulary of the
+ * runtime, which this package does not depend on, and a raw code would render as words nobody authored. Each round's
+ * `stopRationale` is the selector's own sentence for why that round ended the run; the reason code stays on the record.
+ */
+export declare const Workbench_PlaybookRunRound_Schema: z.ZodObject<{
+    roundKey: z.ZodString;
+    parentRoundKey: z.ZodNullable<z.ZodString>;
+    lanePlaybookRef: z.ZodNullable<z.ZodString>;
+    iteration: z.ZodNumber;
+    sameInputStateAsIteration: z.ZodNullable<z.ZodNumber>;
+    stopRationale: z.ZodNullable<z.ZodString>;
+    children: z.ZodArray<z.ZodObject<{
+        playbookRef: z.ZodString;
+        ranBecause: z.ZodNullable<z.ZodString>;
+        reranOverLanding: z.ZodNullable<z.ZodBoolean>;
+        landed: z.ZodArray<z.ZodString>;
+        failure: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workbench_PlaybookRunRound = z.infer<typeof Workbench_PlaybookRunRound_Schema>;
 /**
  * One playbook run, in whatever state it is in.
  *
@@ -722,57 +1171,69 @@ export declare enum Workbench_PlaybookRunState {
  * that playbook and never a history of it.
  */
 export declare const Workbench_PlaybookRun_Schema: z.ZodObject<{
-    workbenchPlaybookRunId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    runId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    playbookRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    instanceKey: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    traceSessionId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    conversationId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    state: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof Workbench_PlaybookRunState>>>;
-    startedAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    finishedAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    ok: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>>;
-    error: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    completedIterations: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>;
-    checkpointedAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    awaitingFamily: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    awaitingRound: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>;
-    judgeOverall: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>>>>;
+    workbenchPlaybookRunId: z.ZodString;
+    runId: z.ZodNullable<z.ZodString>;
+    playbookRef: z.ZodString;
+    instanceKey: z.ZodNullable<z.ZodString>;
+    traceSessionId: z.ZodNullable<z.ZodString>;
+    conversationId: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<typeof Workbench_PlaybookRunState>;
+    startedAt: z.ZodNullable<z.ZodDate>;
+    finishedAt: z.ZodNullable<z.ZodDate>;
+    ok: z.ZodNullable<z.ZodBoolean>;
+    error: z.ZodNullable<z.ZodString>;
+    completedIterations: z.ZodNullable<z.ZodNumber>;
+    checkpointedAt: z.ZodNullable<z.ZodDate>;
+    awaitingFamily: z.ZodNullable<z.ZodString>;
+    awaitingRound: z.ZodNullable<z.ZodNumber>;
+    judgeOverall: z.ZodNullable<z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>>;
     judgeCriteria: z.ZodNullable<z.ZodArray<z.ZodObject<{
         criterionRef: z.ZodString;
-        verdict: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>>;
+        verdict: z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>;
         rationale: z.ZodString;
     }, z.core.$strip>>>;
     judgeSkipped: z.ZodNullable<z.ZodString>;
+    choreographyRounds: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        roundKey: z.ZodString;
+        parentRoundKey: z.ZodNullable<z.ZodString>;
+        lanePlaybookRef: z.ZodNullable<z.ZodString>;
+        iteration: z.ZodNumber;
+        sameInputStateAsIteration: z.ZodNullable<z.ZodNumber>;
+        stopRationale: z.ZodNullable<z.ZodString>;
+        children: z.ZodArray<z.ZodObject<{
+            playbookRef: z.ZodString;
+            ranBecause: z.ZodNullable<z.ZodString>;
+            reranOverLanding: z.ZodNullable<z.ZodBoolean>;
+            landed: z.ZodArray<z.ZodString>;
+            failure: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type Workbench_PlaybookRun = z.infer<typeof Workbench_PlaybookRun_Schema>;
 export declare const Workbench_WaitingPlaybookRun_Schema: z.ZodObject<{
-    workbenchWaitingPlaybookRunId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    runId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    readable: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    playbookRef: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    family: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    suspendedAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    round: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>>;
-    dryRun: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>>;
-    requests: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+    workbenchWaitingPlaybookRunId: z.ZodString;
+    runId: z.ZodString;
+    readable: z.ZodBoolean;
+    playbookRef: z.ZodNullable<z.ZodString>;
+    family: z.ZodNullable<z.ZodString>;
+    suspendedAt: z.ZodNullable<z.ZodDate>;
+    round: z.ZodNullable<z.ZodNumber>;
+    dryRun: z.ZodNullable<z.ZodBoolean>;
+    requests: z.ZodArray<z.ZodObject<{
         ref: z.ZodString;
         question: z.ZodString;
         why: z.ZodString;
         kind: z.ZodString;
         options: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>>;
-    routedToUserId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    }, z.core.$strip>>;
+    routedToUserId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type Workbench_WaitingPlaybookRun = z.infer<typeof Workbench_WaitingPlaybookRun_Schema>;
 /**
- * One coding run PARKED on a question.
- *
- * It arrives inside the coding-agent status payload, which is a singleton and stays a companion
- * read. These do not: a parked question is identified by the task that parked on it, it persists
- * until somebody answers, and a queue of work waiting on a person is the last thing that should be
- * reachable only by reading a status blob.
+ * The coding lane's one row id. Named, because the workbench links to the row from where the lane's trouble shows (an
+ * attempt, a dispatch or a dispatch card the host failed, #2530) and the companion stamps it: two copies of the literal would be two ids.
  */
+export declare const WORKBENCH_CODING_LANE_STATUS_ROW_ID = "coding-lane";
 /**
  * The coding lane's own posture — ONE row, always present.
  *
@@ -795,15 +1256,15 @@ export type Workbench_WaitingPlaybookRun = z.infer<typeof Workbench_WaitingPlayb
  * outstanding — which is why the parked queue has to be read beside it.
  */
 export declare const Workbench_CodingLaneStatus_Schema: z.ZodObject<{
-    workbenchCodingLaneStatusId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    codingAgentRegistered: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    codingAgentProviderRef: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    codingAgentSignedIn: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>>;
+    workbenchCodingLaneStatusId: z.ZodString;
+    codingAgentRegistered: z.ZodBoolean;
+    codingAgentProviderRef: z.ZodNullable<z.ZodString>;
+    codingAgentSignedIn: z.ZodNullable<z.ZodBoolean>;
     codingAgentLoginDetail: z.ZodNullable<z.ZodString>;
     codingAgentLoginRemedy: z.ZodNullable<z.ZodString>;
-    activeRunTaskId: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>>;
-    activeRunStartedAt: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>>;
-    lockFilePath: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    activeRunTaskId: z.ZodNullable<z.ZodString>;
+    activeRunStartedAt: z.ZodNullable<z.ZodDate>;
+    lockFilePath: z.ZodNullable<z.ZodString>;
     defaultTimeoutMs: z.ZodNumber;
     hardMaxTimeoutMs: z.ZodNumber;
     defaultMaxCapturedBytes: z.ZodNumber;
@@ -831,13 +1292,21 @@ export declare enum Workbench_ParkedCodingQuestionOptionRef {
 }
 /** The single field a parked run asks: the agent's own question, verbatim. */
 export declare const WORKBENCH_PARKED_CODING_QUESTION_FIELD_REF = "answer";
+/**
+ * One coding run PARKED on a question.
+ *
+ * It arrives inside the coding-agent status payload, which is a singleton and stays a companion
+ * read. These do not: a parked question is identified by the task that parked on it, it persists
+ * until somebody answers, and a queue of work waiting on a person is the last thing that should be
+ * reachable only by reading a status blob.
+ */
 export declare const Workbench_ParkedCodingQuestion_Schema: z.ZodObject<{
-    workbenchParkedCodingQuestionId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    taskId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    taskRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    question: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    parkedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
-    resumable: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
+    workbenchParkedCodingQuestionId: z.ZodString;
+    taskId: z.ZodString;
+    taskRef: z.ZodString;
+    question: z.ZodString;
+    parkedAt: z.ZodDate;
+    resumable: z.ZodBoolean;
     suspensionRef: z.ZodString;
 }, z.core.$strip>;
 export type Workbench_ParkedCodingQuestion = z.infer<typeof Workbench_ParkedCodingQuestion_Schema>;
@@ -850,34 +1319,36 @@ export type Workbench_ParkedCodingQuestion = z.infer<typeof Workbench_ParkedCodi
  * surface can ASK it without a second read.
  */
 export declare const Workbench_DossierEntry_Schema: z.ZodObject<{
-    workbenchDossierEntryId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    playbookRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    questionRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    instanceKey: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    instancePurpose: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    question: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    options: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    optionDetails: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    position: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    standing: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchDossierEntryStanding>>>;
-    optionsState: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchDossierEntryOptionsState>>>;
-    value: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    answeredAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodDate>>;
-    answeredByRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    shownOptionDetail: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    playbookEligible: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    askedNow: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    affectsFamilies: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    subject: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchSpecificationArtifactConcern>>>;
-    outOfDate: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    outOfDateStepRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    sharedWithPlaybookRefs: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodString>>;
-    askedInSimpleInterview: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    proposable: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    regulatedDomain: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    assumptionRationale: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    interviewDepth: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationInterviewDepth>>>>;
+    workbenchDossierEntryId: z.ZodString;
+    playbookRef: z.ZodString;
+    questionRef: z.ZodString;
+    instanceKey: z.ZodNullable<z.ZodString>;
+    instancePurpose: z.ZodNullable<z.ZodString>;
+    question: z.ZodString;
+    kind: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+    optionDetails: z.ZodArray<z.ZodString>;
+    position: z.ZodNumber;
+    standing: z.ZodEnum<typeof WorkbenchDossierEntryStanding>;
+    optionsState: z.ZodEnum<typeof WorkbenchDossierEntryOptionsState>;
+    value: z.ZodNullable<z.ZodString>;
+    nonAnswerReason: z.ZodNullable<z.ZodString>;
+    admittedNonAnswers: z.ZodArray<z.ZodEnum<typeof MetaWorkflow_ElicitationNonAnswer>>;
+    answeredAt: z.ZodNullable<z.ZodDate>;
+    answeredByRef: z.ZodNullable<z.ZodString>;
+    shownOptionDetail: z.ZodNullable<z.ZodString>;
+    playbookEligible: z.ZodBoolean;
+    askedNow: z.ZodBoolean;
+    affectsFamilies: z.ZodArray<z.ZodString>;
+    subject: z.ZodEnum<typeof WorkbenchSpecificationArtifactConcern>;
+    outOfDate: z.ZodBoolean;
+    outOfDateStepRefs: z.ZodArray<z.ZodString>;
+    sharedWithPlaybookRefs: z.ZodArray<z.ZodString>;
+    askedInSimpleInterview: z.ZodBoolean;
+    proposable: z.ZodBoolean;
+    regulatedDomain: z.ZodBoolean;
+    assumptionRationale: z.ZodNullable<z.ZodString>;
+    interviewDepth: z.ZodNullable<z.ZodEnum<typeof ApplicationInterviewDepth>>;
 }, z.core.$strip>;
 export type Workbench_DossierEntry = z.infer<typeof Workbench_DossierEntry_Schema>;
 /** The dossier resource's one write verb. */
@@ -927,7 +1398,6 @@ export declare const Workbench_DossierProposeOutcome_Schema: z.ZodObject<{
         rationale: z.ZodString;
         regulatedDomain: z.ZodBoolean;
     }, z.core.$strip>>;
-    /** Asked for, and nothing admissible came back — each with the last refusal. Ask these of the person. */
     unproposed: z.ZodArray<z.ZodObject<{
         questionRef: z.ZodString;
         reason: z.ZodString;
@@ -943,19 +1413,24 @@ export declare const Workbench_DossierInterviewDepthOutcome_Schema: z.ZodObject<
     packageRelativePath: z.ZodString;
 }, z.core.$loose>;
 export type Workbench_DossierInterviewDepthOutcome = z.infer<typeof Workbench_DossierInterviewDepthOutcome_Schema>;
+/**
+ * An answer to a dossier question: a VALUE, or (#3439) a NON-ANSWER with its reason — never both, and one of the two.
+ * The exclusivity and the admission are decided by the operation against the ROW (`admittedNonAnswers`), not here: a
+ * cross-field refinement would hide the one sentence that says what to change behind a generic schema error.
+ */
 export declare const Workbench_DossierAnswerRequest_Schema: z.ZodObject<{
-    value: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+    nonAnswer: z.ZodOptional<z.ZodEnum<typeof MetaWorkflow_ElicitationNonAnswer>>;
+    reason: z.ZodOptional<z.ZodString>;
     assumed: z.ZodOptional<z.ZodBoolean>;
     assumptionRationale: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type Workbench_DossierAnswerRequest = z.infer<typeof Workbench_DossierAnswerRequest_Schema>;
 export declare const Workbench_DossierAnswerOutcome_Schema: z.ZodObject<{
-    /** The answer as STORED (canonical for a `confirm`). */
-    value: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+    nonAnswer: z.ZodNullable<z.ZodEnum<typeof MetaWorkflow_ElicitationNonAnswer>>;
     answeredAt: z.ZodString;
-    /** The dossier file this landed in, package-relative. */
     packageRelativePath: z.ZodString;
-    /** The asking playbook's questions still unanswered after this one — empty means it can run. */
     unansweredQuestionRefs: z.ZodArray<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_DossierAnswerOutcome = z.infer<typeof Workbench_DossierAnswerOutcome_Schema>;
@@ -995,16 +1470,62 @@ export declare enum WorkbenchCreationHomeLineKind {
     RUN_INTERRUPTED = "run-interrupted",
     /** A build dispatch finished or failed; `acceptable` says whether its writes wait to be committed. */
     DISPATCH_SETTLED = "dispatch-settled",
+    /**
+     * A re-run inside a lane — a repair of a GAP, a refresh — FAILED while the family's earlier landing still stands
+     * (#3213): a NON-FATAL repair failure, whether the re-run was refused or the environment failed it. The landing it would have replaced is what its consumers read, and the lane
+     * went on with them (e.g. a refused build-decompose repair: the plan on disk still dispatches). `playbookRef` is the
+     * re-run's playbook, `subject` its failure; the target is the lane's run. `failed` stays false, because nothing the
+     * creation built is lost; the refusal is shown so it can be repaired when it matters.
+     */
+    REPAIR_FAILED_LANDING_STANDS = "repair-failed-landing-stands",
     /**
      * The coding agent's account hit its usage limit, and the build dispatches nothing until it resets
      * (#2388). `subject` is when the build resumes (`08:11 Europe/Paris`); the target is the dispatch that met
      * the limit. Shown only while the limit holds, so it disappears once the build has resumed.
      */
     CODING_AGENT_USAGE_LIMITED = "coding-agent-usage-limited",
+    /**
+     * The coding agent's provider ACCOUNT refused its turn: no credits left, a spend or usage limit, billing (#3204).
+     * Distinct from {@link CODING_AGENT_USAGE_LIMITED}: nothing resets on its own, a PERSON adds credits or raises the
+     * limit. The build holds and asks again every thirty minutes, charging no attempt, so a person who fixes the account
+     * while a drive waits loses nothing; an unattended drive stops on it. `subject` is the refusal in the providers'
+     * sentence (`describeModelProviderAccountRefusal`); the target is the dispatch that met it. Shown while the hold lasts.
+     */
+    CODING_AGENT_ACCOUNT_REFUSED = "coding-agent-account-refused",
+    /**
+     * A coding run lost the network, and no coding turn is admitted until a probe of the agent's API answers along the
+     * agent's own route (#3236, #3262). `at` is when the loss was met, `taskRef` the task whose run met it, `subject` the
+     * route the probe takes (`api.anthropic.com via proxy proxy.corp:3128`), absent when no route is known. Shown only
+     * while the hold lasts; what ends it is the probe answering, a turn started after the loss succeeding, or
+     * `wildo build rearm <task> --reason environment`.
+     */
+    CODING_AGENT_CONNECTIVITY_LOST = "coding-agent-connectivity-lost",
+    /**
+     * A verification check's command cannot be executed (#3423): `wildo`, say, is not on the companion's PATH, so every
+     * task's check would fail the same way, and no coding turn is admitted. `subject` is the command, `taskRef` the task
+     * whose run met it, `at` when. Nothing lifts it on its own: a person puts the command on PATH, and the next admission
+     * looks it up first (or `wildo build rearm <task> --reason environment` ends it). Shown while the hold lasts; an
+     * unattended drive stops on it.
+     */
+    VERIFICATION_TOOL_UNAVAILABLE = "verification-tool-unavailable",
+    /**
+     * A person CLOSED a build task (`wildo build close`, #3224, #3227): done another way, or a derived follow-up declined.
+     * `at` is when, `taskRef` the task, `subject` the reason they gave. Shown so a reader of the build's history sees that a
+     * person, not a probe, said the task is done.
+     */
+    BUILD_TASK_CLOSED = "build-task-closed",
     /** A playbook run suspended on questions only the creator can answer. */
     CLARIFICATION = "clarification",
     /** A coding run parked on a question the agent could not answer alone. */
     PARKED_QUESTION = "parked-question",
+    /**
+     * An interview still waiting on the creator whose answer would date work the next unattended round could run
+     * (#3361): a step reading the creator's stated facts, which an answer given later re-derives. The round withholds
+     * that work (`findReadersDatedByWaitingInterviews`), so this line is what moves it, and an unattended drive stops on
+     * it. `playbookRef` is the interview's playbook, `subject` the steps it holds (refs, comma-separated); the target is
+     * the interview's playbook. Not shown for a quick interview's questions an unattended round assumes (#2129).
+     */
+    INTERVIEW_DATES_NEXT_WORK = "interview-dates-next-work",
     /** A governed document the creator asked for (a draft exists) still needing a fact only they can give. */
     GOVERNANCE_DOCUMENT = "governance-document",
     /** The next READY build task of the dispatch plan. */
@@ -1012,13 +1533,42 @@ export declare enum WorkbenchCreationHomeLineKind {
     /**
      * The plan can run NOTHING: every ready task is stuck, and `stuckReason` says what unblocks it.
      *
-     * ASKED rather than SUGGESTION, because every reason is the creator's move — committing what a
-     * finished run wrote under GUIDED, or, under the autonomy posture where the loop commits (#1534),
-     * resolving the path its accept refused or correcting a declaration no run can satisfy.
+     * ASKED rather than SUGGESTION, because every reason it is shown for is the creator's move — correcting a
+     * declaration no run can satisfy, re-arming a task that spent its attempts, approving a follow-up. (A run's work
+     * awaiting a commit was one until #3514: a task lands from the working tree since #3204.)
      * Without it the plan simply falls silent: `CONTINUE_THE_PLAN` is derived from the next ready task,
      * and a stuck queue has none (#1451, #1463).
      */
     UNBLOCK_THE_PLAN = "unblock-the-plan",
+    /**
+     * Nothing in the plan can run and it is not finished, because a specifications module fails (#3258). `subject` names the
+     * modules. ASKED because the remedy is fixing the module, and without this line such a plan reads as nothing at all: no
+     * next task, not finished, and no stuck task to explain it.
+     */
+    SPECIFICATION_FAULT_HOLDS_THE_PLAN = "specification-fault-holds-the-plan",
+    /**
+     * A FOLLOW-UP task landed while its latest completed run still reports a requirement unmet (#2583): advisory, never a
+     * reason the loop stops. `taskRef` is the follow-up, `subject` names each requirement and what the run said is
+     * missing. The door is running it again on purpose: `wildo build run <ref> --despite-landed --reason operator-judgement`.
+     */
+    FOLLOW_UP_LANDED_WITH_GAP = "follow-up-landed-with-gap",
+    /**
+     * Files a build task's coding runs left UNCOMMITTED that no automatic door will commit (#3267): a failed run's file a
+     * retry refused, or a file dirty at a retry's baseline with what earlier failed runs left, and no run of the task live.
+     * ASKED, because only a person can settle it: `taskRef` is the task, `subject` names each file and the runs whose
+     * record holds it. The doors are `wildo build accept <ref> --leftovers` (commit, under those runs) and the discard
+     * command `wildo build tasks` prints per file. Derived from the write register and the tree, so it disappears once
+     * each file is committed or discarded.
+     */
+    RUN_LEFTOVER_UNCOMMITTED = "run-leftover-uncommitted",
+    /**
+     * A build task LANDED and something its landing does not cover is unfinished (#3285): a billing catalogue committed
+     * while the backend does not enable billing, so nothing serves it. Advisory, a mark beside the landing and never a
+     * reason anything stops. `taskRef` is the task, `subject` names each setting still to set and the file that holds it;
+     * `wildo build tasks` prints what each needs first. Derived from the committed tree, so it disappears once the setting
+     * is committed.
+     */
+    LANDED_WITH_ADVISORY = "landed-with-advisory",
     /** An eligible playbook whose output family is missing. */
     PRODUCE_MISSING = "produce-missing",
     /** An eligible playbook whose output is stale — derived before one of its inputs last changed. */
@@ -1034,19 +1584,19 @@ export declare enum WorkbenchCreationHomeLineKind {
  * companion serves unparseable by an older workbench.
  */
 export declare const Workbench_CreationHomeLine_Schema: z.ZodObject<{
-    workbenchCreationHomeLineId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    section: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchCreationHomeSection>>>;
-    kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchCreationHomeLineKind>>>;
-    at: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodDate>>;
-    playbookRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    taskRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    subject: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
-    failed: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    acceptable: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    needsAnswers: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
-    stuckReason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof Workbench_BuildTaskStuckReason>>>>;
-    targetResourceType: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    targetResourceId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    workbenchCreationHomeLineId: z.ZodString;
+    section: z.ZodEnum<typeof WorkbenchCreationHomeSection>;
+    kind: z.ZodEnum<typeof WorkbenchCreationHomeLineKind>;
+    at: z.ZodNullable<z.ZodDate>;
+    playbookRef: z.ZodNullable<z.ZodString>;
+    taskRef: z.ZodNullable<z.ZodString>;
+    subject: z.ZodNullable<z.ZodString>;
+    failed: z.ZodBoolean;
+    acceptable: z.ZodBoolean;
+    needsAnswers: z.ZodBoolean;
+    stuckReason: z.ZodNullable<z.ZodEnum<typeof Workbench_BuildTaskStuckReason>>;
+    targetResourceType: z.ZodString;
+    targetResourceId: z.ZodString;
 }, z.core.$strip>;
 export type Workbench_CreationHomeLine = z.infer<typeof Workbench_CreationHomeLine_Schema>;
 /**
@@ -1082,18 +1632,18 @@ export declare enum WorkbenchCreationOutcomeStatus {
  * well.
  */
 export declare const Workbench_CreationOutcome_Schema: z.ZodObject<{
-    workbenchCreationOutcomeId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    outcome: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchCreationOutcome>>>;
-    status: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof WorkbenchCreationOutcomeStatus>>>;
-    position: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    familiesTotal: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    familiesLanded: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    familiesInvalid: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    familiesMissing: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    familiesStale: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNumber>;
-    tasksTotal: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodNumber>>;
-    tasksLanded: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodNumber>>;
-    unavailableRuntimes: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    workbenchCreationOutcomeId: z.ZodString;
+    outcome: z.ZodEnum<typeof WorkbenchCreationOutcome>;
+    status: z.ZodEnum<typeof WorkbenchCreationOutcomeStatus>;
+    position: z.ZodNumber;
+    familiesTotal: z.ZodNumber;
+    familiesLanded: z.ZodNumber;
+    familiesInvalid: z.ZodNumber;
+    familiesMissing: z.ZodNumber;
+    familiesStale: z.ZodNumber;
+    tasksTotal: z.ZodNullable<z.ZodNumber>;
+    tasksLanded: z.ZodNullable<z.ZodNumber>;
+    unavailableRuntimes: z.ZodNullable<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type Workbench_CreationOutcome = z.infer<typeof Workbench_CreationOutcome_Schema>;
 /** An operation that takes nothing. */
@@ -1109,6 +1659,7 @@ export declare const Workbench_RunWriteFileDiff_Schema: z.ZodObject<{
     existedBefore: z.ZodBoolean;
     diverged: z.ZodBoolean;
     diff: z.ZodString;
+    binary: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 export type Workbench_RunWriteFileDiff = z.infer<typeof Workbench_RunWriteFileDiff_Schema>;
 export declare const Workbench_RunWriteDiff_Schema: z.ZodObject<{
@@ -1120,6 +1671,7 @@ export declare const Workbench_RunWriteDiff_Schema: z.ZodObject<{
         existedBefore: z.ZodBoolean;
         diverged: z.ZodBoolean;
         diff: z.ZodString;
+        binary: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Workbench_RunWriteDiff = z.infer<typeof Workbench_RunWriteDiff_Schema>;
@@ -1235,7 +1787,8 @@ export type Workbench_CodingRunCancelOutcome = z.infer<typeof Workbench_CodingRu
  * The governed document's one verb: LAND the facts a person established for it as the
  * `document-facts-authored` family. The row is the document; the body carries the governance scope,
  * the answers and, for a reviewed fact, the review — a per-question verb with a bare value could
- * carry none of that, which is why the question resource has no write verb of its own.
+ * carry none of that, which is why ANSWERING stays on the document. Deferring one question carries
+ * only a reason and asserts nothing, so it is the question's own verb (`WorkbenchGovernanceQuestions_Operations`).
  */
 export declare enum WorkbenchGovernanceDocuments_Operations {
     LAND_FACTS = "land_facts"
@@ -1262,6 +1815,31 @@ export declare const Workbench_GovernanceFactsLandingRequest_Schema: z.ZodObject
     dryRun: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Workbench_GovernanceFactsLandingRequest = z.infer<typeof Workbench_GovernanceFactsLandingRequest_Schema>;
+/**
+ * The governance question's one verb (#3439): DEFER it — the person says the fact concerns this application and is not
+ * decided yet, and why. A dossier write (`deferredDocumentFacts`), never a fact declaration, so the fact stays absent
+ * and every clause resting on it stays owed. It names no governance scope and records no review, which is why it can be
+ * a per-question verb while answering cannot (see {@link WorkbenchGovernanceDocuments_Operations}).
+ */
+export declare enum WorkbenchGovernanceQuestions_Operations {
+    DEFER = "defer"
+}
+/**
+ * Whether a governance question in this standing may be DEFERRED (#3439): one still needed, and one already deferred
+ * (re-deferring rewords the reason). A fact the product establishes is read, never deferred; and an ANSWERED fact is
+ * not either, because a landed declaration wins over a deferral of the same fact (`deriveOpenGovernanceQuestions`), so
+ * the deferral would change nothing anyone sees. The ONE predicate the operation refuses by and the workbench offers by.
+ */
+export declare function governanceQuestionAdmitsDeferral(standing: WorkbenchDossierEntryStanding): boolean;
+export declare const Workbench_GovernanceQuestionDeferRequest_Schema: z.ZodObject<{
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_GovernanceQuestionDeferRequest = z.infer<typeof Workbench_GovernanceQuestionDeferRequest_Schema>;
+export declare const Workbench_GovernanceQuestionDeferOutcome_Schema: z.ZodObject<{
+    factRef: z.ZodString;
+    packageRelativePath: z.ZodString;
+}, z.core.$loose>;
+export type Workbench_GovernanceQuestionDeferOutcome = z.infer<typeof Workbench_GovernanceQuestionDeferOutcome_Schema>;
 export declare const Workbench_GovernanceFactsLandingOutcome_Schema: z.ZodObject<{
     family: z.ZodString;
     packageRelativePath: z.ZodString;
@@ -1288,7 +1866,10 @@ export declare enum ApplicationSecretStanding {
     NEEDED = "needed",
     /** It has a value in this environment, and something reads it. */
     SET = "set",
-    /** Unset, and nothing waits for it: an optional key, or a capability another provider already serves. */
+    /**
+     * Unset, and nothing waits for it: an optional key, or a capability another provider already serves, ready, in every
+     * runtime that would use this key for it (a provider ready in the backend serves nothing to the companion, #2985).
+     */
     AVAILABLE = "available",
     /**
      * It has a value, and nothing CONSUMES it: a provider key no provider declares, a system-of-record key
@@ -1364,17 +1945,17 @@ export declare function splitApplicationSecretRowId(rowId: string): {
  * secrets section. Names and standings only: a value never enters this row, in either direction of the wire.
  */
 export declare const Workbench_ApplicationSecret_Schema: z.ZodObject<{
-    workbenchApplicationSecretId: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
-    environmentName: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    envVarName: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
-    standing: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationSecretStanding>>>;
-    kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationSecretKind>>>;
-    ownerRef: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodNullable<z.ZodString>>;
+    workbenchApplicationSecretId: z.ZodString;
+    environmentName: z.ZodString;
+    envVarName: z.ZodString;
+    standing: z.ZodEnum<typeof ApplicationSecretStanding>;
+    kind: z.ZodEnum<typeof ApplicationSecretKind>;
+    ownerRef: z.ZodNullable<z.ZodString>;
     description: z.ZodNullable<z.ZodString>;
-    capabilities: z.ZodArray<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof EngineCapability>>>;
+    capabilities: z.ZodArray<z.ZodEnum<typeof EngineCapability>>;
     runtimes: z.ZodArray<z.ZodString>;
     creationEssential: z.ZodBoolean;
-    remoteLevel: z.ZodNullable<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationSecretRemoteLevel>>>;
+    remoteLevel: z.ZodNullable<z.ZodEnum<typeof ApplicationSecretRemoteLevel>>;
 }, z.core.$strip>;
 export type Workbench_ApplicationSecret = z.infer<typeof Workbench_ApplicationSecret_Schema>;
 /** The secret row's two verbs. Both run `wildo secrets set/unset`, which is the only writer of a secret. */
@@ -1388,7 +1969,7 @@ export declare enum WorkbenchApplicationSecrets_Operations {
     UNSET = "unset"
 }
 export declare const Workbench_ApplicationSecretSetRequest_Schema: z.ZodObject<{
-    value: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>>;
+    value: z.ZodString;
 }, z.core.$strip>;
 export type Workbench_ApplicationSecretSetRequest = z.infer<typeof Workbench_ApplicationSecretSetRequest_Schema>;
 /**
@@ -1402,7 +1983,7 @@ export type Workbench_ApplicationSecretSetRequest = z.infer<typeof Workbench_App
  */
 export declare const Workbench_ApplicationSecretChangeOutcome_Schema: z.ZodObject<{
     envVarName: z.ZodString;
-    kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationSecretKind>>;
+    kind: z.ZodEnum<typeof ApplicationSecretKind>;
     envName: z.ZodString;
     restartSignalledRuntimes: z.ZodArray<z.ZodString>;
     envFilesRegenerated: z.ZodBoolean;