@wildo-ai/platform-core-shared 1.1.4 → 1.1.6

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

@@ -1,4 +1,7 @@
+import { MetaWorkflow_ClarificationAction, MetaWorkflow_EvaluationVerdict } from '@wildo-ai/saas-models/meta-workflows';
+import { EngineCapability } from '@wildo-ai/saas-models';
 import { z } from 'zod';
+import { WorkbenchSpecificationArtifactConcern } from './workbench-resources.custom.shared.schemas';
 /**
  * The CREATION PLANE's shared vocabulary — schemas for the four companion-runtime resource
  * families, and the behavior ids their bindings name.
@@ -40,7 +43,27 @@ export declare enum WorkbenchCreationPlaneBehavior {
     /** The write register's records, pre-image bytes stripped. */
     RUN_WRITE_RECORDS = "creation-plane.run-write-records",
     /** The execution-trace session index. */
-    TRACE_SESSIONS = "creation-plane.trace-sessions"
+    TRACE_SESSIONS = "creation-plane.trace-sessions",
+    /** The governance questionnaires' unanswered prompts, flattened one row per question. */
+    GOVERNANCE_DOCUMENTS = "creation-plane.governance-documents",
+    GOVERNANCE_QUESTIONS = "creation-plane.governance-questions",
+    /** The build lane's dispatch history, one row per attempt. */
+    BUILD_DISPATCH_PLAN = "creation-plane.build-dispatch-plan",
+    BUILD_DISPATCHES = "creation-plane.build-dispatches",
+    /** The playbook runs suspended waiting on a person. */
+    PLAYBOOK_RUNS = "creation-plane.playbook-runs",
+    WAITING_PLAYBOOK_RUNS = "creation-plane.waiting-playbook-runs",
+    /** The coding runs parked on a question. */
+    CODING_LANE_STATUS = "creation-plane.coding-lane-status",
+    PARKED_CODING_QUESTIONS = "creation-plane.parked-coding-questions",
+    /** The dossier: every declared interview question × the creator's answer from `creator-inputs`. */
+    DOSSIER_ENTRIES = "creation-plane.dossier-entries",
+    /** HOME's lines (#1454): what happened, what is asked of the creator, what they could do next — one derivation. */
+    HOME_LINES = "creation-plane.home-lines",
+    /** The four creation OUTCOMES with their standing, derived from the landed families and the build plan. */
+    CREATION_OUTCOMES = "creation-plane.creation-outcomes",
+    /** The application's provider secrets per environment — what it needs and what is set, never a value (#1637). */
+    APPLICATION_SECRETS = "creation-plane.application-secrets"
 }
 /** Membership test the companion's source routes by. */
 export declare const WORKBENCH_CREATION_PLANE_BEHAVIOR_IDS: readonly string[];
@@ -57,6 +80,52 @@ export declare const WORKBENCH_CREATION_PLANE_BEHAVIOR_IDS: readonly string[];
  * two rows under one id, and why server-side lookups match sanitized forms instead of reversing.
  */
 export declare function sanitizeWorkbenchCreationPlaneIdentity(value: string): string;
+/**
+ * A dossier row's id — `sanitize(playbookRef)--sanitize(questionRef)` for the step itself, and
+ * `sanitize(playbookRef)--<instanceKey>--sanitize(questionRef)` for one of its INSTANCES (#1609).
+ *
+ * Shared for the same reason the sanitizer is: the companion's projection EMITS the id and the
+ * conversation's answer tool ADDRESSES a row by it, and two copies would let the two drift apart the
+ * first time the shape changed — which is exactly what adding an instance did. An instance key is a
+ * kebab slug, so it needs no sanitizing and cannot contain the `--` separator's ambiguity in a way the
+ * question ref does not already (both are refused as duplicates by the projection, never guessed at).
+ */
+export declare function workbenchDossierEntryIdentity(input: {
+    readonly playbookRef: string;
+    readonly questionRef: string;
+    readonly instanceKey?: string | null;
+}): string;
+/**
+ * The creation plane's CORRELATION VOCABULARY on the engine's actor task — the one named source for
+ * the `context.correlation` envelope's domain and ref keys (#1348, #1330).
+ *
+ * The engine owns the envelope and validates only that keys and values are non-empty strings; this
+ * domain owns the keys. Both ends read them: the companion's coding-agent dispatch WRITES the
+ * envelope when it admits a run for a build-plan task, and the workbench READS it to draw the run's
+ * build-plan task as a resolved link. Two spellings of one key would be a join that silently stops
+ * matching, so neither end spells it.
+ *
+ * The value under {@link WorkbenchTaskCorrelationRef.BUILD_PLAN_TASK} is the build-plan ROW's
+ * identity — `sanitizeWorkbenchCreationPlaneIdentity(taskRef)` — so a reader holding the envelope
+ * addresses the row with no lookup.
+ */
+export declare const WORKBENCH_TASK_CORRELATION_DOMAIN = "application-creation";
+export declare enum WorkbenchTaskCorrelationRef {
+    /** The `workbenchBuildPlanTaskId` of the build-plan task this coding run was dispatched for. */
+    BUILD_PLAN_TASK = "buildPlanTaskRef",
+    /**
+     * The creation CONVERSATION (the engine conversational execution's `executionId`) a run was
+     * started from, when it was (#1454). The conversation page joins a thread to its runs on this
+     * key; a run started from the board or the CLI carries none.
+     */
+    CONVERSATION = "conversationId"
+}
+/**
+ * The build-plan row a task's correlation envelope names, or `undefined` when the task was not
+ * dispatched for one — a task with no build-plan task is the normal case for anything the creation
+ * plane did not admit, and it must read as ABSENT rather than as loading.
+ */
+export declare function readBuildPlanTaskCorrelation(context: unknown): string | undefined;
 /**
  * The dispatch status of one build-plan task — computed, never stored.
  *
@@ -69,6 +138,84 @@ export declare enum WorkbenchBuildPlanTaskStatus {
     LANDED = "landed",
     BLOCKED = "blocked"
 }
+/**
+ * Why a READY build-plan task cannot make progress, so dispatch passes over it.
+ *
+ * Each member carries a DIFFERENT remedy, and the remedy is the only thing the operator gets. The
+ * companion's dispatch service is the only producer; the workbench board renders it. Declared here
+ * rather than beside the producer for the reason `Workbench_BuildDispatchPhase` gives: a browser
+ * bundle cannot import the companion, and re-spelling the members board-side would be a second
+ * source (#1451).
+ *
+ * None of them refuses the queue. A stuck task is skipped so every unrelated branch proceeds, and a
+ * dispatch refuses only when NOTHING ready can move. The READ door never refuses: it answers with the
+ * 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.
+     *
+     * 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.
+     */
+    COMPLETED_AWAITING_COMMIT = "completed_awaiting_commit",
+    /** 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. */
+    NO_DOCUMENT_BLUEPRINT = "no_document_blueprint",
+    /**
+     * Its coding runs FAILED as many times as the attempt budget allows (#1536), so another identical
+     * dispatch is not offered. Only failures the task caused count: a run failing on a check that was
+     * already red completes instead (`carriedVerificationFailures`), so this cannot be reached on the
+     * tree's account. Read the last failure, fix its cause, and re-arm the task.
+     */
+    ATTEMPTS_EXHAUSTED = "attempts_exhausted",
+    /**
+     * A run of it is LIVE right now — selected, admitted or running (#1528). Under a parallel build
+     * 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"
+}
+/**
+ * How far one BUILD DISPATCH got — the whole of what `GET /build/dispatches` can honestly say.
+ *
+ * ## Why it lives in the SHARED package rather than beside the service that sets it
+ *
+ * Both ends of this vocabulary are real consumers. The companion's dispatch service is the only
+ * PRODUCER — since #1359 by PROJECTION: every dispatch is an actor-system execution from the moment
+ * its task is selected, and the phase is a pure function of that execution's row
+ * (`projectBuildDispatchPhase`), not a record the companion keeps. Until then it was an in-memory
+ * list of five that a companion restart emptied. The workbench's build lane reads it to decide
+ * whether a dispatch reads as working, done or broken, and a browser bundle cannot import the
+ * companion. Declared companion-side, the board
+ * would have had to re-spell the four members — the second-source defect the creation board's own
+ * client docstring refuses by name. So it is declared ONCE here, where the workbench vocabulary
+ * already lives and which the companion already imports.
+ *
+ * ## The two executors resolve at DIFFERENT moments, and that is the whole reason for four members
+ *
+ * A companion generation step's dispatch resolves when the step has FINISHED. A coding task's
+ * resolves when the run is ADMITTED, with the agent still working — its outcome is the durable
+ * actor-task row the record names. Measured 2026-09-13 on Wonder CRM: the record said `ok: true`
+ * for `build-task-company-schema` at the instant its run started, and the route told the caller to
+ * poll that record "for the outcome", so a script following it read an admitted run as a success.
+ */
+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`. */
+    ADMITTED = "admitted",
+    /** A companion generation step ran to completion. */
+    FINISHED = "finished",
+    /** The dispatch threw — before a coding run was admitted, or while a generation step ran. */
+    FAILED = "failed"
+}
 /**
  * One playbook's row on the eligibility board.
  *
@@ -87,13 +234,25 @@ export declare const Workbench_Playbook_Schema: z.ZodObject<{
     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<{
+        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<{
         family: z.ZodString;
         changedInputs: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>>;
-    computedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodString>;
+    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<{
+        instanceKey: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strip>>>>;
+    computedAt: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
 }, z.core.$strip>;
 export type Workbench_Playbook = z.infer<typeof Workbench_Playbook_Schema>;
 /**
@@ -110,7 +269,7 @@ export declare const Workbench_BuildPlanTask_Schema: z.ZodObject<{
     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<z.ZodEnum<typeof WorkbenchBuildPlanTaskStatus>>;
+    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>>;
 }, z.core.$strip>;
 export type Workbench_BuildPlanTask = z.infer<typeof Workbench_BuildPlanTask_Schema>;
@@ -127,30 +286,126 @@ export declare const Workbench_RunWriteRecord_Schema: z.ZodObject<{
     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.ZodString>;
+    at: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodDate>;
     files: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<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>;
 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.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>;
 }, z.core.$strip>;
 export type Workbench_TraceSession = z.infer<typeof Workbench_TraceSession_Schema>;
+/**
+ * One governance QUESTION a creator still owes an answer to.
+ *
+ * ## Why one row per question rather than per questionnaire
+ *
+ * The companion answers questionnaires — a document definition and the prompts it asks. The thing a
+ * creator ACTS on is one question, and the thing a board queues is one question, so the row is the
+ * question and the document it belongs to travels on it. That is the same flattening
+ * `Workbench_RunWriteRecord` does to a run's files, and for the same reason: a resource's row is
+ * whatever a reader selects.
+ *
+ * ## What it deliberately does NOT carry
+ *
+ * The ANSWER. Landing answers is a dispatch against the `document-facts-authored` family and goes
+ * through the companion's own service; a row here is the question as asked. Giving the row an answer
+ * field would make this the second place an answer lives, which is the ledger
+ * `one-source-of-truth.md` rule 5 refuses.
+ */
+/**
+ * One GOVERNED DOCUMENT whose questionnaire a person must answer — the document half of governance.
+ *
+ * ## Why this is its own resource rather than fields on the question row
+ *
+ * `derivedFactRefs` and the ask count are facts about the DOCUMENT, not about any one question, and
+ * a document-level fact repeated on every question row is a value with no owner: nothing says which
+ * copy is authoritative, and eight rows of one document can disagree.
+ *
+ * It is also what the board's document selector is a list OF. Before this it grouped question rows
+ * by `definitionRef` and had nowhere to read the derived facts from — so a panel showing only the
+ * human half presented four questions for a document declaring eight, and a reader had no way to
+ * tell a short questionnaire from a broken one.
+ */
+/**
+ * Where a dossier entry STANDS — the two states a question a playbook asks can be in from the
+ * creator's side (#1454). "Read from the product" (a typed config key) is a third source the
+ * dossier gains with the governed-document join (Step 6); it is not a standing of an interview
+ * question, so it is not here.
+ */
+export declare enum WorkbenchDossierEntryStanding {
+    /** The creator answered; the value is in the committed dossier. */
+    FROM_YOU = "from-you",
+    /** The playbook asks it and nobody has answered. */
+    STILL_NEEDED = "still-needed",
+    /**
+     * An opened INSTANCE of the step asks it and has no answer of its own, so it runs on the step's own
+     * answer (#1609). Answered, not needed: nothing is blocked, and an answer given here replaces the
+     * step's for this instance only.
+     */
+    FROM_THE_STEP = "from-the-step",
+    /**
+     * The PRODUCT answers it: a governed-document fact the application's own declarations establish,
+     * read rather than asked (#1454, gap 4; `compliance-is-derived-from-the-product.md`). Never
+     * "needed" and never editable here — its answer changes when what the product declares changes.
+     */
+    READ_FROM_PRODUCT = "read-from-product"
+}
+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>;
+}, 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<{
+        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>;
+export type Workbench_GovernanceQuestion = z.infer<typeof Workbench_GovernanceQuestion_Schema>;
 /** The playbook resource's dispatch verbs. */
 export declare enum WorkbenchPlaybooks_Operations {
     /** Fire one playbook run (the row is the playbook; the body carries brief/answers/dryRun). */
     RUN = "run",
     /** Answer a run that stopped at a clarification — accept with answers, decline, or cancel. */
-    RESUME = "resume_run"
+    RESUME = "resume_run",
+    /**
+     * The questions this playbook still needs answered, as a decision payload — the declared interview
+     * minus what the dossier already answers (shared decisions included), and `null` when nothing is left
+     * to ask: the step declares none, or the dossier answers them all (#1454 review). Read
+     * ON DEMAND, at the moment somebody chooses to run it, and deliberately not a field of the row: one
+     * playbook alone declares fifteen questions, so carrying them on every row would pay for all of
+     * them on every poll in order to show none of them.
+     */
+    READ_INTERVIEW = "read_interview"
 }
 /** The build-plan resource's dispatch verb. */
 export declare enum WorkbenchBuildPlanTasks_Operations {
@@ -159,12 +414,46 @@ export declare enum WorkbenchBuildPlanTasks_Operations {
      * the order its author intended, and a per-row dispatch would be a second scheduler disagreeing
      * with the first (the dispatch service's own doctrine).
      */
-    DISPATCH_NEXT = "dispatch_next"
+    DISPATCH_NEXT = "dispatch_next",
+    /**
+     * Append ONE task the creator asked for, beside the plan that exists (#1454, Step 7). Collection-
+     * level: the row does not exist until the append answers. Deterministic — no model runs; the
+     * companion validates the task against the plan's own graph rules and re-renders the plan file.
+     */
+    ADD_TASK = "add_task",
+    /**
+     * Run THIS task, by row. Admitted only when the task is READY — the graph still decides what may
+     * run, and this verb only lets the creator pick among the ready ones instead of taking the next.
+     * A non-ready task answers 409 naming what it waits on. Costs a coding run.
+     */
+    DISPATCH_TASK = "dispatch_task",
+    /**
+     * 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
+     * lane's hunks (dirty at the run's baseline) and paths edited since the run are refused by name
+     * unless `force`. Acceptance is a commit (`one-source-of-truth.md`), and under the YOLO posture the
+     * system may make it on the creator's word — this verb IS that word.
+     */
+    ACCEPT = "accept"
 }
-/** The write-record resource's dispatch verb. */
+/** The write-record resource's dispatch verbs. */
 export declare enum WorkbenchRunWriteRecords_Operations {
     /** Revert this run's writes. Files edited since are refused by name unless `force`. */
-    REVERT = "revert_writes"
+    REVERT = "revert_writes",
+    /**
+     * ACCEPT this run's writes: commit exactly the register's paths. A file that no longer holds the
+     * bytes the run wrote is refused by name unless `force` — the same divergence test `revert` applies,
+     * because in both directions a human edit is never silently swept into the run's account.
+     */
+    ACCEPT = "accept",
+    /**
+     * WHAT this run changed, per file — read on demand, one run at a time (#1274). Deliberately not a
+     * field of the LIST row: pre-image bytes "belong to the revert mechanism, and a list row carrying
+     * every pre-image would ship the working tree's history through every LIST". Computed from the
+     * register's own pre/post content, never from `git diff`, so it is the RUN's change and not
+     * everything uncommitted at those paths.
+     */
+    READ_DIFF = "read_diff"
 }
 export declare const Workbench_PlaybookRunRequest_Schema: z.ZodObject<{
     creatorBrief: z.ZodOptional<z.ZodString>;
@@ -173,11 +462,13 @@ export declare const Workbench_PlaybookRunRequest_Schema: z.ZodObject<{
         answer: z.ZodString;
     }, z.core.$strip>>>;
     dryRun: z.ZodOptional<z.ZodBoolean>;
+    instanceKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type Workbench_PlaybookRunRequest = z.infer<typeof Workbench_PlaybookRunRequest_Schema>;
 export declare const Workbench_PlaybookResumeRequest_Schema: z.ZodObject<{
     runId: z.ZodString;
-    action: z.ZodString;
+    round: z.ZodNumber;
+    action: z.ZodEnum<typeof MetaWorkflow_ClarificationAction>;
     answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
         ref: z.ZodString;
         answer: z.ZodString;
@@ -186,10 +477,49 @@ export declare const Workbench_PlaybookResumeRequest_Schema: z.ZodObject<{
 export type Workbench_PlaybookResumeRequest = z.infer<typeof Workbench_PlaybookResumeRequest_Schema>;
 export declare const Workbench_BuildPlanDispatchNextRequest_Schema: z.ZodObject<{}, z.core.$strip>;
 export type Workbench_BuildPlanDispatchNextRequest = z.infer<typeof Workbench_BuildPlanDispatchNextRequest_Schema>;
+/**
+ * One task to append (#1454, Step 7). The `target` and `produces` shapes are owned by
+ * `@wildo-ai/saas-specifications` (`BuildPlanTaskSchema`), which this package deliberately does not
+ * depend on, so they cross here as records and the companion parses them against the real schema
+ * before anything is written. `taskRef` is derived from the objective when absent.
+ */
+export declare const Workbench_BuildPlanAddTaskRequest_Schema: z.ZodObject<{
+    taskRef: z.ZodOptional<z.ZodString>;
+    objective: z.ZodString;
+    target: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    produces: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    functionalTopic: z.ZodString;
+    skillRefs: z.ZodArray<z.ZodString>;
+    prerequisiteTaskRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    servesRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type Workbench_BuildPlanAddTaskRequest = z.infer<typeof Workbench_BuildPlanAddTaskRequest_Schema>;
+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>;
+export declare const Workbench_AcceptChangesRequest_Schema: z.ZodObject<{
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Workbench_AcceptChangesRequest = z.infer<typeof Workbench_AcceptChangesRequest_Schema>;
 export declare const Workbench_RunWriteRevertRequest_Schema: z.ZodObject<{
     force: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type Workbench_RunWriteRevertRequest = z.infer<typeof Workbench_RunWriteRevertRequest_Schema>;
+/**
+ * What a playbook run's answer says about the run, when it says anything (#1781). Absent on a run that
+ * concluded, or on a detached submission that is still going.
+ *
+ * One named home for a vocabulary the companion writes and several readers compare — the run record,
+ * the clarification lifecycle, the resume route, and the workbench's summary of a RESUME, which used
+ * to read every answer carrying a `runId` as "Started", a cancelled clarification included.
+ */
+export declare enum Workbench_PlaybookRunOutcomeStatus {
+    /** Healthy, and waiting at a clarification: the run asked the creator something and holds until answered. */
+    AWAITING_CREATOR_INPUT = "awaiting_creator_input",
+    /** The creator cancelled a clarification: the run was abandoned and does not continue. */
+    CANCELLED = "cancelled"
+}
 /**
  * Dispatch RESPONSES are LOOSE objects, deliberately: each names the fields the board branches on
  * and forwards the rest verbatim. The companion routes already spread the whole service result, and
@@ -198,8 +528,7 @@ export type Workbench_RunWriteRevertRequest = z.infer<typeof Workbench_RunWriteR
  */
 export declare const Workbench_PlaybookRunOutcome_Schema: z.ZodObject<{
     runId: z.ZodOptional<z.ZodString>;
-    /** Present exactly when the run is HEALTHY and waiting at a clarification. */
-    status: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<typeof Workbench_PlaybookRunOutcomeStatus>>;
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_PlaybookRunOutcome = z.infer<typeof Workbench_PlaybookRunOutcome_Schema>;
@@ -208,12 +537,773 @@ export declare const Workbench_BuildPlanDispatchOutcome_Schema: z.ZodObject<{
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_BuildPlanDispatchOutcome = z.infer<typeof Workbench_BuildPlanDispatchOutcome_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;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+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<{
+    commitSha: z.ZodOptional<z.ZodString>;
+    committedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    refusedPaths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+    message: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type Workbench_AcceptChangesOutcome = z.infer<typeof Workbench_AcceptChangesOutcome_Schema>;
 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>>>;
     note: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type Workbench_RunWriteRevertOutcome = z.infer<typeof Workbench_RunWriteRevertOutcome_Schema>;
+/**
+ * One BUILD DISPATCH — an attempt to run one build-plan task.
+ *
+ * The lane's own history: what was selected, when, and how it ended. A task may be dispatched more
+ * than once (a failure is re-dispatchable), so the row is the ATTEMPT and `taskRef` is what groups
+ * them — the same relationship a run write record has to its playbook.
+ */
+/**
+ * The NEXT build task — what a dispatch would do, with nothing started. At most one row.
+ *
+ * ## Why a proposal is a row
+ *
+ * It looks like a computed answer rather than a record, and that is why it stayed a bespoke read
+ * longest. But everything a person asks of it is what they ask of a row: what is it, what may it
+ * touch, what must it pass, and how far through the plan are we. It has an identity (`taskRef`), it
+ * is polled, it is rendered as a card, and a dispatch acts on it.
+ *
+ * ## Distinct from the build-plan TASK, deliberately
+ *
+ * `workbenchBuildPlanTasks` is every task and its status. This is the SELECTION — which one is next,
+ * plus the guard rails a dispatch of it would carry (allowed paths, prohibited paths, required
+ * checks, installed skills), which belong to the dispatch rather than to the task. Two resources
+ * because they answer different questions; the task list never changes because a selection did.
+ *
+ * ## Zero rows means the build is FINISHED, not that the read failed
+ *
+ * The companion answers `plan: null` with an `exhausted` count for a completed build, and it is a
+ * 200. That used to be a non-2xx, so the end of the journey rendered as "could not look" — the board
+ * telling an operator something went wrong at the moment everything had gone right. The counts live
+ * 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>>;
+    exhausted: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodBoolean>;
+    stuckTasks: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodArray<z.ZodObject<{
+        taskRef: z.ZodString;
+        reason: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<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>;
+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>>;
+}, z.core.$strip>;
+export type Workbench_BuildDispatch = z.infer<typeof Workbench_BuildDispatch_Schema>;
+/**
+ * One playbook run SUSPENDED waiting on a person.
+ *
+ * The run stopped mid-way and asked something. The row carries where it stopped and what it asked,
+ * because both are what a creator needs to answer it — a question with no run context is a question
+ * nobody can answer.
+ */
+/**
+ * WHERE a playbook run is in its life — the one field that decides how its row reads.
+ *
+ * ## Why one vocabulary and not four collections
+ *
+ * The companion answers `{ running, runningDetached, interrupted, lastCompleted }`, and a board
+ * reading that shape has to know which array means what before it can render anything. They are not
+ * four kinds of thing: they are one thing — a run of a playbook — in four states, and the fields that
+ * differ between them (a finish time, a verdict, a checkpoint) are exactly the fields a state decides
+ * the presence of. Naming the state makes that explicit and makes the row renderable by one layout.
+ *
+ * The distinction that matters most is RUNNING vs RUNNING_DETACHED, and it is not cosmetic: the
+ * first is a composite holding its instance's single-flight subject and never an ordinary run, so a board
+ * that read it alone reported "nothing is running" while a fifteen-minute run was in flight.
+ */
+export declare enum Workbench_PlaybookRunState {
+    /** A composite holding its instance's single-flight subject (#1610): one per running instance, several at once, never an ordinary run. */
+    RUNNING = "running",
+    /** An ordinary run this companion process is executing right now. */
+    RUNNING_DETACHED = "running_detached",
+    /** A run that stopped without finishing and left a checkpoint that can be re-run. */
+    INTERRUPTED = "interrupted",
+    /** The most recent outcome for a playbook ref — settled, with a verdict. */
+    COMPLETED = "completed",
+    /**
+     * A run that STOPPED TO ASK and is waiting on a person — not running, not finished, no verdict.
+     *
+     * It borrowed COMPLETED until 2026-09-24, flagged by `awaitingFamily`, so every reader had to remember that one
+     * "completed" row was not complete. The outcome reader remembered; Home did not, and told the creator a dry run
+     * waiting on their answer had "ran and landed its result" (#1271). A state that has to be un-said by another field
+     * is a missing member of its vocabulary.
+     */
+    AWAITING_ANSWER = "awaiting_answer"
+}
+/**
+ * One playbook run, in whatever state it is in.
+ *
+ * Kept ONE-PER-REF for the completed state by the companion, so a COMPLETED row is the last run of
+ * 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>>>>;
+    judgeCriteria: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        criterionRef: z.ZodString;
+        verdict: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof MetaWorkflow_EvaluationVerdict>>;
+        rationale: z.ZodString;
+    }, z.core.$strip>>>;
+    judgeSkipped: z.ZodNullable<z.ZodString>;
+}, 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<{
+        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>;
+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 own posture — ONE row, always present.
+ *
+ * ## Why a singleton resource rather than the read it replaced
+ *
+ * It was a companion read answering a status object, and that read ALSO carried the parked
+ * questions — a queue keyed by task id — inside it. Two different things in one payload: a queue of
+ * work waiting on a person, and a statement about the lane. The queue is
+ * `workbenchParkedCodingQuestions`; this is what remains, and it is genuinely one row.
+ *
+ * ## What each field is careful about
+ *
+ * `codingAgentRegistered` reports exactly what the dispatch service can ESTABLISH — that every
+ * declared agent resolves in the registry — and deliberately does not claim the transport is usable,
+ * because that depends on the provider configuration and on a process it has not started. Anything
+ * reading this must not upgrade it to "ready".
+ *
+ * `activeRunTaskId` being NULL does not mean idle. A run that parks on a question clears it while
+ * staying very much alive, so a badge derived from this field alone read "idle" with a question
+ * 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>>;
+    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>>;
+    defaultTimeoutMs: z.ZodNumber;
+    hardMaxTimeoutMs: z.ZodNumber;
+    defaultMaxCapturedBytes: z.ZodNumber;
+    hardMaxCapturedBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type Workbench_CodingLaneStatus = z.infer<typeof Workbench_CodingLaneStatus_Schema>;
+/**
+ * The option refs a parked coding run offers. Closed, because the caller BRANCHES on which came back.
+ *
+ * Both are real decisions here, unlike a playbook interview — which offers only "run with these
+ * answers", because declining an interview settles nothing that is waiting. A parked run IS waiting:
+ * answering resumes the same session, and cancelling ends the run.
+ *
+ * ## Why it lives HERE rather than in the companion that mints it
+ *
+ * Both ends need it and neither can import the other: the companion projects a parked run as a
+ * decision, and the workbench reconstructs that decision from the ROW to render the answer form. It
+ * was declared in the companion alone until 2026-09-19, which meant a browser wanting to branch on
+ * an option had to re-spell the two values — a second copy of a closed vocabulary, compiling
+ * perfectly and free to drift.
+ */
+export declare enum Workbench_ParkedCodingQuestionOptionRef {
+    ANSWER = "answer",
+    CANCEL = "cancel"
+}
+/** The single field a parked run asks: the agent's own question, verbatim. */
+export declare const WORKBENCH_PARKED_CODING_QUESTION_FIELD_REF = "answer";
+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>;
+    suspensionRef: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_ParkedCodingQuestion = z.infer<typeof Workbench_ParkedCodingQuestion_Schema>;
+/**
+ * One dossier entry: a question a playbook declares, and what the creator said to it, if anything.
+ *
+ * The identity is the pair (`playbookRef`, `questionRef`), sanitized — the key the `creator-inputs`
+ * family stores answers under, so the page addresses an answer the way the file does. The
+ * question's own text, kind and options are carried on the row (from the compiled catalog) so a
+ * 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>>;
+    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>>>;
+    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>>;
+    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>>;
+}, z.core.$strip>;
+export type Workbench_DossierEntry = z.infer<typeof Workbench_DossierEntry_Schema>;
+/** The dossier resource's one write verb. */
+export declare enum WorkbenchDossierEntries_Operations {
+    /** Record (or change) the creator's answer to this question. Lands `creator-inputs`; a commit accepts it. */
+    ANSWER = "answer"
+}
+export declare const Workbench_DossierAnswerRequest_Schema: z.ZodObject<{
+    value: 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;
+    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>;
+/**
+ * The SECTIONS of Home, the conversation page's opening surface (#1454, Step 3) — and the LIST filter
+ * a reader of `workbenchCreationHomeLines` narrows by.
+ *
+ * Three questions, three sections: what happened since I was here, what is asked of me now, what
+ * could I do next. Where the application stands is a resource of its own
+ * (`workbenchCreationOutcomes`), because an outcome is a measured STATE, not a line that opens
+ * something.
+ */
+export declare enum WorkbenchCreationHomeSection {
+    /** A run completed or cut short, a build dispatch settled — newest first. */
+    SINCE = "since",
+    /** What blocks something NOW and waits on the creator: a run stopped on a question, a coding run parked on one, a drafted document missing a fact. */
+    ASKED = "asked",
+    /** What the creator could do next, outcome-first: the plan's next task, a step producing a missing family, a step refreshing a stale one. */
+    SUGGESTION = "suggestion"
+}
+/**
+ * The KIND of a Home line — one closed vocabulary across the three sections, because a line's words
+ * and its tone are decided by its kind wherever it is rendered, and a section is only where it sits.
+ *
+ * ## Why the companion decides these and the page does not
+ *
+ * Until 2026-09-22 the page read SEVEN resources on their own cadences and derived every line itself
+ * — 900 lines of client arithmetic over rows a projection had already computed, re-run on every
+ * poll, invisible to the assistant's tools and to every other reader. A line is a FACT about the
+ * application ("this run was refused", "this task's writes wait to be committed"); facts are
+ * derived where the rows are, once, and served as rows themselves (`derive-before-you-ask.md`).
+ */
+export declare enum WorkbenchCreationHomeLineKind {
+    /** A playbook run completed — landed or refused; `failed` says which. */
+    RUN_COMPLETED = "run-completed",
+    /** A playbook run the companion's restart cut short; re-running resumes it. Shown whatever its date. */
+    RUN_INTERRUPTED = "run-interrupted",
+    /** A build dispatch finished or failed; `acceptable` says whether its writes wait to be committed. */
+    DISPATCH_SETTLED = "dispatch-settled",
+    /** 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",
+    /** 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. */
+    CONTINUE_THE_PLAN = "continue-the-plan",
+    /**
+     * 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.
+     * 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",
+    /** 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. */
+    REFRESH_STALE = "refresh-stale"
+}
+/**
+ * One line of Home. Every line OPENS an element beside the page — `targetResourceType` +
+ * `targetResourceId` are the address the engine's hosted pane resolves — and carries the one or two
+ * facts the words need: the subject, in the creator's terms, and the flags that change the sentence.
+ *
+ * `targetResourceType` is a STRING, not `z.enum(WorkbenchShared_ResourceType)`: it is an address, not
+ * a vocabulary anyone words, and binding it here would make a line pointing at a resource a newer
+ * 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>;
+}, z.core.$strip>;
+export type Workbench_CreationHomeLine = z.infer<typeof Workbench_CreationHomeLine_Schema>;
+/**
+ * The four OUTCOMES an application's creation is measured by — the journey in the creator's words
+ * (Paul, 2026-09-21: "we do not have a real journey; top-down and bottom-up are internal
+ * considerations"). The playbook phases stay machinery underneath; this is what a person sees.
+ *
+ * Which specification family counts toward which outcome is the companion projection's business
+ * (`creation-home-projection.companion.ts`, total over `ApplicationSpecificationFamily`); this
+ * package deliberately does not import that vocabulary.
+ */
+export declare enum WorkbenchCreationOutcome {
+    /** Vision, market, requirements, features, business model, roadmap, brand. */
+    KNOW_WHAT_WE_BUILD = "know-what-we-build",
+    /** The compliance programme, the processor register, the facts and policies behind every governed document, the risks. */
+    KNOW_THE_RULES = "know-the-rules",
+    /** The domain plan, the placement plan, the build plan — and the build tasks landed. */
+    APPLICATION_WORKS = "application-works",
+    /** Governed documents released and published — and every other outcome done. */
+    READY_FOR_A_REAL_USER = "ready-for-a-real-user"
+}
+/** The order a person reads the outcomes in: what, rules, works, ready. Also the rows' `position`. */
+export declare const WORKBENCH_CREATION_OUTCOMES_IN_ORDER: readonly WorkbenchCreationOutcome[];
+export declare enum WorkbenchCreationOutcomeStatus {
+    NOT_STARTED = "not-started",
+    IN_PROGRESS = "in-progress",
+    DONE = "done"
+}
+/**
+ * Where the application stands on one outcome — ALWAYS four rows, one per outcome, in reading
+ * order. "Done" is strict: every family of the outcome landed, valid and not stale; for the
+ * application working, every build task landed too; for readiness, every other outcome done as
+ * 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>>>;
+}, z.core.$strip>;
+export type Workbench_CreationOutcome = z.infer<typeof Workbench_CreationOutcome_Schema>;
+/** An operation that takes nothing. */
+export declare const Workbench_EmptyRequest_Schema: z.ZodObject<{}, z.core.$strip>;
+/** `read_interview` on a playbook: the `HumanDecision_Request` it declares, or null. Carried opaquely — the engine owns that vocabulary. */
+export declare const Workbench_PlaybookInterview_Schema: z.ZodObject<{
+    decision: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>;
+export type Workbench_PlaybookInterview = z.infer<typeof Workbench_PlaybookInterview_Schema>;
+/** One file's change within a run — see `read_diff`. */
+export declare const Workbench_RunWriteFileDiff_Schema: z.ZodObject<{
+    path: z.ZodString;
+    existedBefore: z.ZodBoolean;
+    diverged: z.ZodBoolean;
+    diff: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_RunWriteFileDiff = z.infer<typeof Workbench_RunWriteFileDiff_Schema>;
+export declare const Workbench_RunWriteDiff_Schema: z.ZodObject<{
+    runId: z.ZodString;
+    playbookRef: z.ZodString;
+    at: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        existedBefore: z.ZodBoolean;
+        diverged: z.ZodBoolean;
+        diff: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workbench_RunWriteDiff = z.infer<typeof Workbench_RunWriteDiff_Schema>;
+/** The trace-session resource's READ-shaped verbs — what a session RECORDED, beyond the summary its row carries. */
+export declare enum WorkbenchTraceSessions_Operations {
+    /** ONE session: every event in order, and its step artifacts by name (#1328) — what the Conversation tab reads. */
+    READ_RECORD = "read_record",
+    /** What one session SPENT, in tokens — summed from the agent-call usage already in its events (#1274). Never a currency. */
+    READ_USAGE = "read_usage",
+    /** One step ARTIFACT, as text — the brief the model saw, the answer it gave, a coding task's input (#1329). */
+    READ_ARTIFACT = "read_artifact",
+    /**
+     * The trace sessions one ACTOR TASK ran in, latest first — the alias the coding lane writes for
+     * every run (#1328). Collection-level: the task is the input, not a session. Empty for a task the
+     * lane never ran, which is the ordinary case and not an error.
+     */
+    LIST_FOR_TASK = "list_for_task"
+}
+/** One traced event, as the companion records it — the conversation's unit (#1328). */
+export declare const Workbench_TraceSessionEvent_Schema: z.ZodObject<{
+    timestamp: z.ZodString;
+    type: z.ZodString;
+    summary: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type Workbench_TraceSessionEvent = z.infer<typeof Workbench_TraceSessionEvent_Schema>;
+/** One step directory of a session: the artifacts it holds, by file name. Bodies are read one at a time. */
+export declare const Workbench_TraceSessionStep_Schema: z.ZodObject<{
+    stepDirName: z.ZodString;
+    artifacts: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_TraceSessionStep = z.infer<typeof Workbench_TraceSessionStep_Schema>;
+export declare const Workbench_TraceSessionRecord_Schema: z.ZodObject<{
+    sessionId: z.ZodString;
+    startedAt: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+    eventCount: z.ZodNumber;
+    stepCount: z.ZodNumber;
+    events: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        type: z.ZodString;
+        summary: z.ZodString;
+        stepId: z.ZodOptional<z.ZodString>;
+        payload: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+    steps: z.ZodArray<z.ZodObject<{
+        stepDirName: z.ZodString;
+        artifacts: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Workbench_TraceSessionRecord = z.infer<typeof Workbench_TraceSessionRecord_Schema>;
+/** What one trace session spent, in TOKENS. `callsWithoutUsage` non-zero means the totals are a FLOOR, not the figure. */
+export declare const Workbench_TraceSessionUsage_Schema: z.ZodObject<{
+    sessionId: z.ZodString;
+    agentCalls: z.ZodNumber;
+    callsWithoutUsage: z.ZodNumber;
+    promptTokens: z.ZodNumber;
+    completionTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type Workbench_TraceSessionUsage = z.infer<typeof Workbench_TraceSessionUsage_Schema>;
+export declare const Workbench_TraceArtifactRequest_Schema: z.ZodObject<{
+    stepDirName: z.ZodString;
+    fileName: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_TraceArtifactRequest = z.infer<typeof Workbench_TraceArtifactRequest_Schema>;
+/** The artifact body, verbatim. A big brief renders by its OUTLINE, computed by the reader — the text is what it is owed. */
+export declare const Workbench_TraceArtifact_Schema: z.ZodObject<{
+    body: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_TraceArtifact = z.infer<typeof Workbench_TraceArtifact_Schema>;
+export declare const Workbench_TraceSessionsForTaskRequest_Schema: z.ZodObject<{
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const Workbench_TraceSessionsForTask_Schema: z.ZodObject<{
+    sessionIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_TraceSessionsForTask = z.infer<typeof Workbench_TraceSessionsForTask_Schema>;
+/**
+ * The parked coding question's two verbs — the decision the row IS (see
+ * {@link Workbench_ParkedCodingQuestionOptionRef}): answer it and resume the same session, or end
+ * the run. Both were bespoke companion routes with a browser exemption on the token floor until
+ * 2026-09-22; the row's own operations are where a reader meets them.
+ */
+export declare enum WorkbenchParkedCodingQuestions_Operations {
+    /** Answer THIS parked run and resume the same agent session. A WRITE: it re-enters a workspace-mutating run behind the worktree lock. */
+    ANSWER = "answer",
+    /**
+     * End THIS parked run. Per row since #1581 (seventh review): with waves (#1528) several runs may be
+     * live, and a collection-level cancel ended whatever this process drove — doing nothing for a park
+     * no chain held, and stopping other runs while this one stayed parked.
+     */
+    CANCEL = "cancel"
+}
+export declare const Workbench_ParkedQuestionAnswerRequest_Schema: z.ZodObject<{
+    answer: z.ZodString;
+    suspensionRef: z.ZodString;
+}, z.core.$strip>;
+export type Workbench_ParkedQuestionAnswerRequest = z.infer<typeof Workbench_ParkedQuestionAnswerRequest_Schema>;
+/** The lane's admission of the resumed run — its own shape, carried loosely. */
+export declare const Workbench_ParkedQuestionAnswerOutcome_Schema: z.ZodObject<{}, z.core.$loose>;
+export type Workbench_ParkedQuestionAnswerOutcome = z.infer<typeof Workbench_ParkedQuestionAnswerOutcome_Schema>;
+/**
+ * The row's `cancel` answers ONLY a run it ended or signalled: a run that moved on meanwhile is a 409 the
+ * gate shows, never a `cancelled: false` read as success (#1581, eleventh and twelfth reviews).
+ */
+export declare const Workbench_CodingRunCancelOutcome_Schema: z.ZodObject<{
+    cancelled: z.ZodLiteral<true>;
+}, z.core.$loose>;
+export type Workbench_CodingRunCancelOutcome = z.infer<typeof Workbench_CodingRunCancelOutcome_Schema>;
+/**
+ * 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.
+ */
+export declare enum WorkbenchGovernanceDocuments_Operations {
+    LAND_FACTS = "land_facts"
+}
+/**
+ * The landing request's ENVELOPE. The answer SEMANTICS stay with the companion service that owns the
+ * question catalog (it refuses an unknown question, a review with no reviewer, "does not apply" on a
+ * question that does not offer it — each with its own sentence); this refuses a body that is not a
+ * landing request at all.
+ */
+export declare const Workbench_GovernanceFactsLandingRequest_Schema: z.ZodObject<{
+    definitionRef: z.ZodString;
+    decidedByRef: z.ZodString;
+    decidedAt: z.ZodString;
+    governanceScope: z.ZodObject<{
+        subjectKind: z.ZodString;
+        subjectRef: z.ZodString;
+        scopeRef: z.ZodString;
+        scopeVersion: z.ZodNumber;
+        participantRefs: z.ZodArray<z.ZodString>;
+        precedenceRuleRefs: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    answers: z.ZodArray<z.ZodUnknown>;
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Workbench_GovernanceFactsLandingRequest = z.infer<typeof Workbench_GovernanceFactsLandingRequest_Schema>;
+export declare const Workbench_GovernanceFactsLandingOutcome_Schema: z.ZodObject<{
+    family: z.ZodString;
+    packageRelativePath: z.ZodString;
+    exportedConstantName: z.ZodString;
+    renderedSource: z.ZodString;
+    existedBefore: z.ZodBoolean;
+    wiringAlreadyInPlace: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_GovernanceFactsLandingOutcome = z.infer<typeof Workbench_GovernanceFactsLandingOutcome_Schema>;
+/**
+ * Where one secret stands for an application in one environment (#1637).
+ *
+ * The ONE vocabulary for `wildo secrets list`, the creation essentials of `wildo init`/`setup` and
+ * the workbench's secrets section, so the three cannot disagree about what "needed" means. Derived
+ * from what the application declares (the providers it scopes, the capabilities it enables, its systems
+ * of record and inbound endpoints), never from the provider catalogue.
+ */
+export declare enum ApplicationSecretStanding {
+    /**
+     * Required by something the application uses, unset, and nothing else covers what it is for: a
+     * capability, a provider the application scoped on purpose, a system of record or an inbound endpoint
+     * cannot work until it is provided.
+     */
+    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. */
+    AVAILABLE = "available",
+    /**
+     * It has a value, and nothing CONSUMES it: a provider key no provider declares, a system-of-record key
+     * naming no declared instance or no slot its credential has, an inbound key naming no endpoint. It is
+     * listed to be REMOVED — the one verb it offers. Usually the remains of something renamed or retired
+     * (Odoo was a provider before it was a system of record).
+     *
+     * Unconsumed is not undelivered: the dev companion's `.env` carries EVERY provider key, and the backend
+     * receives a well-formed inbound name or a slot of a declared instance. So a row says which runtimes still
+     * receive it, and removing it regenerates their `.env` files like any other change — otherwise the value
+     * would stay on disk and in the running process after the person was told it was gone.
+     */
+    UNUSED = "unused"
+}
+/**
+ * What a secret belongs to, and so which section of `secrets.json` holds it and how its name is formed.
+ * Three kinds because they are three different things, not three spellings of a provider key: a system of
+ * record is deliberately NOT a provider (#1049 D10) and an inbound endpoint secret proves a delivery rather
+ * than authenticating a call.
+ */
+export declare enum ApplicationSecretKind {
+    /** A provider's secret, declared by its secrets contract; `secrets.json` → `providerEnv`. */
+    PROVIDER = "provider",
+    /**
+     * A credential slot of a declared system of record (#1055), named `WILDO_SOR_<NAME>__<SLOT>`;
+     * `secrets.json` → `systemsOfRecordEnv`. Read by the application backend only.
+     */
+    SYSTEM_OF_RECORD = "system_of_record",
+    /**
+     * The verification secret of an application inbound endpoint (#1596), named
+     * `WILDO_INBOUND_<ENDPOINT_KEY>__SECRET`; `secrets.json` → `inboundEndpointEnv`. Read by the backend only.
+     */
+    INBOUND_ENDPOINT = "inbound_endpoint"
+}
+/**
+ * Which GitHub level holds a REMOTE environment's provider secret. Remote secrets are GitHub Actions
+ * secrets; the generated deploy job declares `environment: <env>`, so an environment secret applies to
+ * that environment alone and overrides a repository secret of the same name, which is the fallback.
+ * spec-cite: https://docs.github.com/en/actions/reference/security/secrets — "If an organization, repository, and environment all have a secret with the same name, the environment-level secret takes precedence."
+ */
+export declare enum ApplicationSecretRemoteLevel {
+    ENVIRONMENT = "environment",
+    REPOSITORY = "repository"
+}
+/**
+ * The `id` of one secret row: environment, kind and name (`local--provider--OPENAI_API_KEY`). The same name is
+ * a different secret per environment, and per KIND too — each kind is its own `secrets.json` section, so a
+ * key left in the wrong section during a migration (an Odoo credential still in `providerEnv`) is a second
+ * secret beside the one that belongs, and must be addressable on its own rather than colliding with it.
+ *
+ * The id travels in the URL of the row's page and of its `set` / `unset` operations, and the engine checks
+ * it before any handler runs (`ExecutionContextCreator.validateParameterFormat`). It was
+ * `<environment>::<NAME>` until 2026-09-26: the list rendered, but the row's page and both operations
+ * answered `400 api_call_initiator_parameter_unsupported`, because that check then held every id to
+ * `^[a-zA-Z0-9_-]+$`. Since #2048 it holds an introspected row's id to the introspection format, which admits
+ * more; this id stays inside the narrower alphabet anyway, so it is valid under both, and
+ * `workbench-application-secret-row-id.test.ts` pins that.
+ */
+export declare function applicationSecretRowId(envName: string, kind: ApplicationSecretKind, envVarName: string): string;
+/**
+ * Splits a secret row's id back into environment, kind and name, or `null` when it cannot be a row id. It
+ * splits on the first two separators — neither the environment nor the kind can contain one — and the name
+ * keeps any it has. A well-formed id naming nothing real is refused later by `wildo secrets`, which states
+ * the reason itself.
+ */
+export declare function splitApplicationSecretRowId(rowId: string): {
+    envName: string;
+    kind: ApplicationSecretKind;
+    envVarName: string;
+} | null;
+/**
+ * One secret an application declares a use for (or still holds), in one environment — the workbench's
+ * 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>>;
+    description: z.ZodNullable<z.ZodString>;
+    capabilities: z.ZodArray<import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<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>>>;
+}, 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. */
+export declare enum WorkbenchApplicationSecrets_Operations {
+    /**
+     * Provide THIS secret's value. Locally the runtimes that read it restart to pick it up; remotely it
+     * becomes the GitHub Environment secret the deploy reads.
+     */
+    SET = "set",
+    /** Remove THIS secret from its environment. */
+    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>>;
+}, z.core.$strip>;
+export type Workbench_ApplicationSecretSetRequest = z.infer<typeof Workbench_ApplicationSecretSetRequest_Schema>;
+/**
+ * What a change did — the shape `wildo secrets set/unset --json` prints (#1637). The local fields are
+ * inert for a remote environment, whose change is the GitHub secret itself.
+ */
+export declare const Workbench_ApplicationSecretChangeOutcome_Schema: z.ZodObject<{
+    envVarName: z.ZodString;
+    kind: import("@wildo-ai/zod-decorators").DecoratedPrimitiveZodType<z.ZodEnum<typeof ApplicationSecretKind>>;
+    envName: z.ZodString;
+    restartSignalledRuntimes: z.ZodArray<z.ZodString>;
+    envFilesRegenerated: z.ZodBoolean;
+    envFilesRegenerationFailure: z.ZodNullable<z.ZodString>;
+    companionAppliesChange: z.ZodBoolean;
+    companionApplyFailure: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Workbench_ApplicationSecretChangeOutcome = z.infer<typeof Workbench_ApplicationSecretChangeOutcome_Schema>;
 //# sourceMappingURL=workbench-creation-plane.custom.shared.schemas.d.ts.map