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

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

@@ -1,4 +1,4 @@
-import { ApplicationInterviewDepth, MetaWorkflow_ClarificationAction, MetaWorkflow_EvaluationVerdict } from '@wildo-ai/saas-models/meta-workflows';
+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 { initZodDecorators, StringEditMode } from '@wildo-ai/zod-decorators';
@@ -173,18 +173,13 @@ export var WorkbenchBuildPlanTaskStatus;
  */
 export var Workbench_BuildTaskStuckReason;
 (function (Workbench_BuildTaskStuckReason) {
-    /** It already ran, and its declared product is absent even from the working tree: fix the declaration or the work. */
-    Workbench_BuildTaskStuckReason["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.
      */
-    Workbench_BuildTaskStuckReason["COMPLETED_AWAITING_COMMIT"] = "completed_awaiting_commit";
+    Workbench_BuildTaskStuckReason["COMPLETED_UNLANDED"] = "completed_unlanded";
     /** Its run suspended on a question nobody has answered; re-dispatching would abandon that session. */
     Workbench_BuildTaskStuckReason["PARKED_AWAITING_ANSWER"] = "parked_awaiting_answer";
     /** It produces a governed document the engine catalog does not define, so no run can author it. */
@@ -202,7 +197,55 @@ export var Workbench_BuildTaskStuckReason;
      * or two agents would build the same task. Nobody's move: it clears when that run settles.
      */
     Workbench_BuildTaskStuckReason["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.
+     */
+    Workbench_BuildTaskStuckReason["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.
+     */
+    Workbench_BuildTaskStuckReason["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.
+     */
+    Workbench_BuildTaskStuckReason["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.
+     */
+    Workbench_BuildTaskStuckReason["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.
+     */
+    Workbench_BuildTaskStuckReason["STALE_EXPERT_CHARTERS"] = "stale_expert_charters";
 })(Workbench_BuildTaskStuckReason || (Workbench_BuildTaskStuckReason = {}));
+/**
+ * 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 const WORKBENCH_BUILD_TASK_STUCK_REASONS_WAITING_ON_A_LIVE_RUN = new Set([
+    Workbench_BuildTaskStuckReason.IN_FLIGHT,
+    Workbench_BuildTaskStuckReason.CONTENDED,
+]);
 /**
  * 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.
@@ -210,9 +253,9 @@ export var Workbench_BuildTaskStuckReason;
  * - `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: `completed_awaiting_commit` (the product exists and wants
- * accepting, and a re-arm would build it again), `parked_awaiting_answer` (a question waits), `in_flight` (a run is
- * live), `no_document_blueprint` (no run can produce it).
+ * 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 const WORKBENCH_REARMABLE_STUCK_REASONS = [
     Workbench_BuildTaskStuckReason.COMPLETED_UNLANDED,
@@ -250,6 +293,12 @@ export var BuildTaskRearmReason;
     BuildTaskRearmReason["BLOCKING_DEFECT_FIXED"] = "blocking-defect-fixed";
     /** Neither of the above: an operator judged the work should run again. The note says why. */
     BuildTaskRearmReason["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.
+     */
+    BuildTaskRearmReason["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
@@ -262,6 +311,22 @@ export var BuildTaskRearmReason;
      */
     BuildTaskRearmReason["INTERFERED_BY_CONCURRENT_RUN"] = "interfered-by-concurrent-run";
 })(BuildTaskRearmReason || (BuildTaskRearmReason = {}));
+/**
+ * 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 var BuildTaskClosureKind;
+(function (BuildTaskClosureKind) {
+    /** Another task of the plan built what this one was for. It counts as landed while that task is landed. */
+    BuildTaskClosureKind["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. */
+    BuildTaskClosureKind["SATISFIED_BY_COMMIT"] = "satisfied_by_commit";
+    /** A host-derived follow-up the creator declines: the gap it answers is not worked. Follow-ups only. */
+    BuildTaskClosureKind["DECLINED"] = "declined";
+})(BuildTaskClosureKind || (BuildTaskClosureKind = {}));
 /**
  * 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)
@@ -271,6 +336,7 @@ export const OPERATOR_BUILD_TASK_REARM_REASONS = [
     BuildTaskRearmReason.PROBE_CORRECTED,
     BuildTaskRearmReason.BLOCKING_DEFECT_FIXED,
     BuildTaskRearmReason.OPERATOR_JUDGEMENT,
+    BuildTaskRearmReason.ENVIRONMENT,
 ];
 /**
  * How far one BUILD DISPATCH got — the whole of what `GET /build/dispatches` can honestly say.
@@ -495,6 +561,17 @@ export const Workbench_RunWriteRecord_Schema = z.object({
     fileCount: z.number().int().isSummaryField(),
     /** The commit the workbench's `accept` made of these writes (#1454, Step 7); NULL until one has. */
     acceptedCommitSha: z.string().min(1).isSummaryField().nullable(),
+    /**
+     * The run FAILED after writing these files (#3265): a half-applied composition the autonomy posture never commits and no
+     * coding door takes. Not a landing, and shown as failed wherever the record is listed, with its accept and revert doors,
+     * because nothing else prompts a person to settle it. `false` on every completed landing.
+     */
+    landingFailed: z.boolean().isSummaryField(),
+    /**
+     * For a failed landing, the two commands that settle it (`wildo creation accept <runId>` / `revert <runId>`), as the
+     * companion names them on every surface that lists the run (#3265). NULL on a completed landing.
+     */
+    failedLandingRemedies: z.object({ accept: z.string().min(1), revert: z.string().min(1) }).isSummaryField().nullable(),
 });
 /** One execution-trace session — the queryable index the board links from. */
 export const Workbench_TraceSession_Schema = z.object({
@@ -570,6 +647,17 @@ export var WorkbenchDossierEntryStanding;
      * Changing it records the creator's own answer in its place.
      */
     WorkbenchDossierEntryStanding["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.
+     */
+    WorkbenchDossierEntryStanding["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.
+     */
+    WorkbenchDossierEntryStanding["DEFERRED"] = "deferred";
 })(WorkbenchDossierEntryStanding || (WorkbenchDossierEntryStanding = {}));
 /**
  * Whether a CHOICE question's options can be offered right now — for a question whose options are
@@ -645,9 +733,12 @@ export const Workbench_GovernanceQuestion_Schema = z.object({
         /** What choosing this option MEANS, in the creator's language rather than the schema's. */
         creatorMeaning: z.string().min(1),
     })).isSummaryField(),
-    /** Answered in the authored facts (from you) or not (still needed) — the same standing vocabulary the interview dossier uses. */
+    /**
+     * Answered in the authored facts (from you), deferred in the dossier (not decided yet, #3437), or neither (still
+     * needed) — the same standing vocabulary the interview dossier uses.
+     */
     standing: z.enum(WorkbenchDossierEntryStanding).systemEnum('WorkbenchDossierEntryStanding').isSummaryField(),
-    /** The answer as a person reads it — the text, the chosen options, or the "does not apply" reason. `null` when still needed. */
+    /** The answer as a person reads it — the text, the chosen options, the "does not apply" reason, or why it was deferred. `null` when still needed. */
     answerSummary: z.string().nullable().isSummaryField(),
     /** When the answer was decided (the declaration's own instant). `null` when still needed. */
     answeredAt: z.date().nullable().isSummaryField(),
@@ -906,6 +997,11 @@ export const Workbench_RunWriteRevertOutcome_Schema = z.looseObject({
      * would destroy that run's work. Each names the run to revert first (#1666).
      */
     refusedLaterRun: z.array(z.object({ path: z.string(), runId: z.string() })).optional(),
+    /**
+     * Binary files the run replaced while their earlier version was uncommitted (#3264): the record holds their hash, not
+     * their bytes, so nothing can restore them. Refused even under force.
+     */
+    refusedWithoutPreImage: z.array(z.string()).optional(),
     note: z.string().optional(),
 });
 /**
@@ -978,8 +1074,15 @@ export const Workbench_BuildDispatchPlan_Schema = z.object({
      * counted as landed on pages that listed none. Named so "92 of 92 landed" can never hide it. Empty is healthy.
      */
     landedBeforeAnyRunTaskRefs: z.array(z.string().min(1)).isSummaryField(),
-    /** TRUE when there is no next task because every one has landed. */
+    /** TRUE when there is no next task because every one has landed, and no specifications module is failing. */
     exhausted: z.boolean().isSummaryField(),
+    /**
+     * The specifications modules failing while the plan has no next task (#3258). Such a plan is not `exhausted`: what landed
+     * may only have run, and no check of the package can answer. Empty otherwise.
+     */
+    failingSpecificationModules: z.array(z.string().min(1)).isSummaryField(),
+    /** TRUE when that plan's next dispatch repairs the failing module (#3258), so nothing is asked of a person yet. */
+    specificationRepairOwed: z.boolean(),
     /**
      * Every READY task dispatch passed over because it cannot make progress, and why (#1451).
      *
@@ -996,8 +1099,6 @@ export const Workbench_BuildDispatchPlan_Schema = z.object({
         reason: z.enum(Workbench_BuildTaskStuckReason).systemEnum('Workbench_BuildTaskStuckReason'),
         /** The run that proves it is stuck; NULL for a task that is unbuildable before any run. */
         priorTaskId: z.string().min(1).nullable(),
-        /** `completed_awaiting_commit` only: the probed paths present in the working tree and not committed. */
-        uncommittedPaths: z.array(z.string().min(1)),
         /** `parked_awaiting_answer` (and a parked `no_document_blueprint`): the question the run is waiting on. */
         question: z.string().min(1).nullable(),
         /** `no_document_blueprint` only: the governed document the catalog does not define. */
@@ -1217,24 +1318,24 @@ export var BrandDesignState;
     /** The brand's visual tone could not be read, so currency cannot be decided either way. */
     BrandDesignState["UNANSWERABLE"] = "unanswerable";
 })(BrandDesignState || (BrandDesignState = {}));
-/** A landing probe HEAD does not satisfy (#2530): what landing searched for, and whether the working tree has it. */
+/** A landing probe the working tree does not satisfy (#2530, #3204): what landing searched for there, and what is missing. */
 export const Workbench_BuildTaskUnmetProbe_Schema = z.object({
     /**
-     * The files the probe reads, and how they are read: ONE path is that file, committed (and declaring `declarations`
+     * The files the probe reads, and how they are read: ONE path is that file, present (and declaring `declarations`
      * when it names any); SEVERAL paths with `declarations` are candidates, any one of which may declare them; several with
-     * `keyPrefix` are the language packs, every committed one of which must carry a key under it. Empty for a shell probe,
+     * `keyPrefix` are the language packs, every present one of which must carry a key under it. Empty for a shell probe,
      * which reads the resolved shell rather than a fixed file (`shellSurface`, `shell`). The probe's KIND is the
      * companion's (`BuildPlanTaskLandedProbeKind`): these fields are what it looks for, and between them say which kind.
      */
     paths: z.array(z.string().min(1)),
     /**
-     * The symbols the probe looks for in those files; empty for a probe that asks only that a file be committed. WHERE in
+     * The symbols the probe looks for in those files; empty for a probe that asks only that a file be present. WHERE in
      * the file they must sit (a set, one call's arguments, a key at an object path, a list's entry) is the companion's
      * probe relation and is not carried: its parameters are code locations the companion derives only when it probes, and
      * no surface shows them, a run's included (#2531 review L4). A reader learns WHAT is missing here, not where it goes.
      */
     declarations: z.array(z.string().min(1)),
-    /** The key every committed label pack must carry one under (a website section's words); null for other probes. */
+    /** The key every present label pack must carry one under (a website section's words); null for other probes. */
     keyPrefix: z.string().min(1).nullable(),
     /**
      * The shell surface a placement probe reads — a `PlacementSurface` value of the specifications. A string declaring that
@@ -1251,8 +1352,8 @@ export const Workbench_BuildTaskUnmetProbe_Schema = z.object({
         missing: z.array(z.string().min(1)),
         /** Subjects the plan declined that the surface still carries. */
         declinedButPresent: z.array(z.string().min(1)),
-        /** Files contributing the surface that are not committed as they are. */
-        uncommittedPaths: z.array(z.string().min(1)),
+        /** Files contributing the surface that the working tree does not hold (#3514). */
+        absentPaths: z.array(z.string().min(1)),
     }).nullable(),
     /**
      * A REGISTRY probe's explanation (#2966): an agent, an approval gate, a work unit, a metered usage recording (#2305
@@ -1274,14 +1375,9 @@ export const Workbench_BuildTaskUnmetProbe_Schema = z.object({
             planned: z.string().min(1).nullable(),
             registered: z.string().min(1).nullable(),
         })),
-        /** Files where the product is written that are not committed as they are. */
-        uncommittedPaths: z.array(z.string().min(1)),
+        /** Registration files, or files the agent index imports, that the working tree does not hold (#3514). */
+        absentPaths: z.array(z.string().min(1)),
     }).nullable(),
-    /**
-     * The working tree satisfies it: the product is written and not committed — an acceptance question. False: it is
-     * absent — a declaration or a work question. "Not landed" alone cannot tell the two apart.
-     */
-    satisfiedInWorkingTree: z.boolean(),
 });
 /**
  * Everything the build knows about ONE task, in one row (#2530, from the companion's per-task record, #1521).
@@ -1314,15 +1410,13 @@ export const Workbench_BuildTaskRecord_Schema = z.object({
     attemptsTruncated: z.boolean(),
     /** READY and passed over by dispatch: why, from the same classification the selector uses. */
     stuckReason: z.enum(Workbench_BuildTaskStuckReason).systemEnum('Workbench_BuildTaskStuckReason').isSummaryField().nullable(),
-    /** `completed_awaiting_commit`: the files its run wrote that are not committed — what accepting it would commit. */
-    stuckUncommittedPaths: z.array(z.string().min(1)),
     /** `parked_awaiting_answer`: the question its run is waiting on. */
     stuckQuestion: z.string().min(1).nullable(),
     /** `no_document_blueprint`: the governed document no blueprint defines. */
     stuckDocumentRef: z.string().min(1).nullable(),
     /** BLOCKED: the prerequisites that have not landed. */
     waitingOnTaskRefs: z.array(z.string().min(1)),
-    /** Not landed and attempted: the probes HEAD does not satisfy. */
+    /** Not landed and attempted: the probes the working tree, which landing reads (#3204), does not satisfy. */
     unmetProbes: z.array(Workbench_BuildTaskUnmetProbe_Schema),
     /*
      * A GENERATION STEP lands on something other than a file it writes, and when it has not, which of these three it is
@@ -1349,6 +1443,16 @@ export const Workbench_BuildTaskRecord_Schema = z.object({
     followUpTaskIds: z.array(z.string().min(1).isForeignKey()),
     /** On a follow-up task: the task whose reported gap derived it; null on every other task. */
     followUpOfTaskId: z.string().min(1).isForeignKey().nullable(),
+    /*
+     * A person's CLOSURE (`wildo build close`, #3224, #3227): the task counts as landed because a person said it is done
+     * another way, or declined it, never because its own probe found its product. Null on every task nobody closed.
+     */
+    /** How the closure accounts for the task. */
+    closureKind: z.enum(BuildTaskClosureKind).systemEnum('BuildTaskClosureKind').nullable(),
+    /** The task or the commit that built it; null when declined or not closed. */
+    closureSatisfiedBy: z.string().min(1).nullable(),
+    /** Why, in the person's words. */
+    closureReason: z.string().min(1).nullable(),
     /** LANDED with no product to prove: it ran, and nothing can show what it made. */
     unverifiable: z.boolean(),
     /** LANDED before any run of its own started: something else made its product, or the probe reads the wrong thing. */
@@ -1407,6 +1511,13 @@ export const Workbench_PlaybookRunRoundChild_Schema = z.object({
     playbookRef: z.string().min(1),
     /** Why it was on the table, in the runtime's own sentence (a first run, a refresh and what moved, a re-opening). */
     ranBecause: z.string().min(1).nullable(),
+    /**
+     * TRUE when it re-ran over a landing the record already held — the runtime's rerun verdict was a refresh or a current
+     * landing re-opened, never a first run (#3213). A failure of such a child left that earlier landing standing, which is
+     * what makes it a non-fatal repair failure; `ranBecause` is a sentence and is written for a first run too, so it cannot
+     * say this. NULL on a row recorded without a verdict.
+     */
+    reranOverLanding: z.boolean().nullable(),
     /** The specification files it landed, in landing order. Empty is a finding, not a gap. */
     landed: z.array(z.string().min(1)),
     /** Why it failed, bounded as the record keeps it; null when it did not. */
@@ -1745,8 +1856,20 @@ export const Workbench_DossierEntry_Schema = z.object({
     standing: z.enum(WorkbenchDossierEntryStanding).systemEnum('WorkbenchDossierEntryStanding').isSummaryField(),
     /** Whether the options can be offered now — see {@link WorkbenchDossierEntryOptionsState}. */
     optionsState: z.enum(WorkbenchDossierEntryOptionsState).systemEnum('WorkbenchDossierEntryOptionsState').isSummaryField(),
-    /** The answer as stored, when there is one. */
+    /** The answer as stored, when there is one. Null for a question answered without a value (#3437). */
     value: z.string().nullable().isSummaryField(),
+    /**
+     * Why the creator answered WITHOUT a value (#3437): the reason it does not apply, or what it waits on. Null for any
+     * other standing. Kept apart from `value` so nothing reads the reason as an answer.
+     */
+    nonAnswerReason: z.string().nullable().isSummaryField(),
+    /**
+     * The ways this question may be answered WITHOUT a value (#3439): what its playbook declares its output can carry,
+     * and none for a question only the creator may answer — the shared `admittedElicitationNonAnswers`, so the
+     * workbench, the console and the landing agree. Empty offers neither "does not apply" nor "later"; the answer
+     * operation refuses a kind not listed here.
+     */
+    admittedNonAnswers: z.array(z.enum(MetaWorkflow_ElicitationNonAnswer).systemEnum('MetaWorkflow_ElicitationNonAnswer')).isSummaryField(),
     answeredAt: z.date().nullable().isSummaryField(),
     answeredByRef: z.string().nullable().isSummaryField(),
     /** What the person was shown beside the option they chose (#2337), recorded with the answer; null when nothing was. */
@@ -1862,9 +1985,21 @@ export const Workbench_DossierInterviewDepthOutcome_Schema = z.looseObject({
     interviewDepth: z.enum(ApplicationInterviewDepth),
     packageRelativePath: z.string(),
 });
+/**
+ * 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 const Workbench_DossierAnswerRequest_Schema = z.object({
-    /** The answer, in the creator's words — validated against the question's kind before it is stored. */
-    value: z.string().min(1),
+    /** The answer, in the creator's words — validated against the question's kind before it is stored. Absent with `nonAnswer`. */
+    value: z.string().min(1).optional(),
+    /**
+     * Answer WITHOUT a value (#3439): the question does not apply to this application, or it is not decided yet. Refused
+     * where the row's `admittedNonAnswers` does not list it, and alongside a `value` or an assumption.
+     */
+    nonAnswer: z.enum(MetaWorkflow_ElicitationNonAnswer).optional(),
+    /** Required with `nonAnswer`: why it does not apply, or what it waits on — recorded so the person can revisit it. */
+    reason: z.string().min(1).optional(),
     /**
      * TRUE when the value is a PROPOSAL the creator let stand because they did not know (#2129): it is
      * recorded as an assumption, authored by the companion's proposer, and the dossier lists it to revisit.
@@ -1875,8 +2010,10 @@ export const Workbench_DossierAnswerRequest_Schema = z.object({
     assumptionRationale: z.string().min(1).optional(),
 });
 export const Workbench_DossierAnswerOutcome_Schema = z.looseObject({
-    /** The answer as STORED (canonical for a `confirm`). */
-    value: z.string(),
+    /** The answer as STORED (canonical for a `confirm`); null for a question answered without a value (#3439). */
+    value: z.string().nullable(),
+    /** The non-answer recorded instead of a value (#3439); null when a value was. */
+    nonAnswer: z.enum(MetaWorkflow_ElicitationNonAnswer).nullable(),
     answeredAt: z.string(),
     /** The dossier file this landed in, package-relative. */
     packageRelativePath: z.string(),
@@ -1921,16 +2058,62 @@ export var WorkbenchCreationHomeLineKind;
     WorkbenchCreationHomeLineKind["RUN_INTERRUPTED"] = "run-interrupted";
     /** A build dispatch finished or failed; `acceptable` says whether its writes wait to be committed. */
     WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["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.
      */
     WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["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`.
+     */
+    WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["BUILD_TASK_CLOSED"] = "build-task-closed";
     /** A playbook run suspended on questions only the creator can answer. */
     WorkbenchCreationHomeLineKind["CLARIFICATION"] = "clarification";
     /** A coding run parked on a question the agent could not answer alone. */
     WorkbenchCreationHomeLineKind["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).
+     */
+    WorkbenchCreationHomeLineKind["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. */
     WorkbenchCreationHomeLineKind["GOVERNANCE_DOCUMENT"] = "governance-document";
     /** The next READY build task of the dispatch plan. */
@@ -1938,13 +2121,42 @@ export var 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).
      */
     WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["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`.
+     */
+    WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["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.
+     */
+    WorkbenchCreationHomeLineKind["LANDED_WITH_ADVISORY"] = "landed-with-advisory";
     /** An eligible playbook whose output family is missing. */
     WorkbenchCreationHomeLineKind["PRODUCE_MISSING"] = "produce-missing";
     /** An eligible playbook whose output is stale — derived before one of its inputs last changed. */
@@ -2049,7 +2261,8 @@ export const Workbench_CreationOutcome_Schema = z.object({
     tasksLanded: z.number().int().min(0).nullable().isSummaryField(),
     /**
      * APPLICATION_WORKS only: the application's runtimes whose dev-loop supervisor has PAUSED them — it
-     * will not start them until something changes (#1537). While any is listed the outcome is not DONE,
+     * will not start them until something changes (#1537) — or is CRASH-LOOPING them, restarting each at most every five
+     * minutes while it keeps failing to start (#3365). While any is listed the outcome is not DONE,
      * whatever has landed: an application that cannot start does not work. Null on the other three,
      * and null when no supervisor could answer, which is "cannot tell" rather than "all up".
      */
@@ -2076,8 +2289,10 @@ export const Workbench_RunWriteFileDiff_Schema = z.object({
     existedBefore: z.boolean(),
     /** The file on disk no longer holds what the run wrote; the diff still describes what the RUN did. */
     diverged: z.boolean(),
-    /** Unified diff. Empty when the run rewrote a file with identical bytes. */
+    /** Unified diff. Empty when the run rewrote a file with identical bytes. For a binary file, one line naming its hashes. */
     diff: z.string(),
+    /** A binary file (#3264): its record holds a hash, so `diff` is one descriptive line and no lines of text. */
+    binary: z.literal(true).optional(),
 });
 export const Workbench_RunWriteDiff_Schema = z.object({
     runId: z.string().min(1),
@@ -2184,7 +2399,8 @@ export const Workbench_CodingRunCancelOutcome_Schema = z.looseObject({
  * 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 var WorkbenchGovernanceDocuments_Operations;
 (function (WorkbenchGovernanceDocuments_Operations) {
@@ -2212,6 +2428,35 @@ export const Workbench_GovernanceFactsLandingRequest_Schema = z.object({
     /** Run the whole pipe and write nothing — what lets a person see the exact file their answers produce BEFORE anything touches the tree. */
     dryRun: z.boolean().optional(),
 });
+/**
+ * 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 var WorkbenchGovernanceQuestions_Operations;
+(function (WorkbenchGovernanceQuestions_Operations) {
+    WorkbenchGovernanceQuestions_Operations["DEFER"] = "defer";
+})(WorkbenchGovernanceQuestions_Operations || (WorkbenchGovernanceQuestions_Operations = {}));
+/**
+ * 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 function governanceQuestionAdmitsDeferral(standing) {
+    return standing === WorkbenchDossierEntryStanding.STILL_NEEDED || standing === WorkbenchDossierEntryStanding.DEFERRED;
+}
+export const Workbench_GovernanceQuestionDeferRequest_Schema = z.object({
+    /** Why it is not decided yet — what it waits on. Required: a deferral with no reason cannot be revisited. */
+    reason: z.string().min(1),
+});
+export const Workbench_GovernanceQuestionDeferOutcome_Schema = z.looseObject({
+    /** The fact deferred. */
+    factRef: z.string().min(1),
+    /** The dossier file the deferral landed in, package-relative. */
+    packageRelativePath: z.string().min(1),
+});
 export const Workbench_GovernanceFactsLandingOutcome_Schema = z.object({
     family: z.string().min(1),
     packageRelativePath: z.string().min(1),