@kottera/tera-web 0.0.0-stage → 0.1.0-rc.2

package/dist/generated/workorder.d.ts

@@ -0,0 +1,3522 @@
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/acknowledge.params.json
+ */
+export type WorkOrderAcknowledgeParams = {
+    /** The failed Work Order to close permanently. */
+    id: string;
+    /** Why this outcome is accepted; recorded with the authenticated actor. */
+    reason: string;
+};
+/**
+ * `work_order.acknowledge` result (v1).
+ *
+ * What `work_order.acknowledge` answers on success (ADR-143 D4), generated from `workorder.AcknowledgeResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/acknowledge.result.json
+ */
+export type WorkOrderAcknowledgeResult = {
+    from_state: string;
+    id: string;
+    state: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/answer.params.json
+ */
+export type WorkOrderAnswerParams = {
+    /** Files to hand this Work Order, each named by the HANDLE its upload minted — `tera artifacts upload <file> --description "…"` mints one in a single command, or over the API `POST /api/v1/artifacts/uploads/authorize` starts an upload and completing it mints the handle. A DISPATCHED RUN uses neither door — a worker-class caller is refused both — and attaches only a handle it has ALREADY PUBLISHED into this same train, which costs nothing and is not a re-upload. ATTACHMENTS CARRY A HANDLE AND NEVER FILE CONTENT, at any size: there is no inline, base64 or small-file form of this field on any surface, so upload first and pass the reference. You do not describe the file here — its filename, declared content type, size, digest and the uploader's description come from the upload itself, so what a later reader sees is what was actually uploaded rather than what the create said about it. An attach CONSUMES the artifact into this one Work Order's train: it leaves your staged account, the same handle keeps working, and it cannot be attached to a second Work Order — upload the file again for that. A handle you have not attached within 24 hours of uploading it is collected; attaching to a `draft` stops that clock for as long as the draft lives, and discarding the draft hands the file back to you with a fresh 24 hours rather than deleting it. Every unattachable handle answers the same way — never uploaded, already attached, expired, or somebody else's are one refusal, because telling them apart would say whether another principal's handle exists; `tera artifacts list --staged` lists what is actually yours (`GET /api/v1/artifacts/staged` over the API). A run has no staging account to list, and the handle it should be passing is one of its own outputs in this train. Inputs get their own byte allowance (64 MiB per Work Order) and never spend the separate allowance a run uses to publish artifacts about its own work. */
+    attachments?: {
+        /** The artifact handle the upload minted. Opaque: it carries no filename and no path, and nothing about it is constructible. */
+        handle: string;
+    }[];
+    /** Report the ADR-105 D8 classification and DO NOTHING ELSE: no generation is minted and the answer does not happen. The manifest says what a resume under the candidate would do — where it would land, which steps would be passed over with nothing recorded, which recorded results would be re-run, and which would be orphaned — with the verdict derived from it. Only meaningful with `repin`; on its own it is refused, since there is nothing else here to preview. */
+    dry_run?: boolean;
+    /** Work Order to resume. Must be `paused:awaiting-input` or `paused:awaiting-interactive-turn`, and the two are answered differently (ADR-129 D3/D4): a `paused:awaiting-input` Work Order asked a specific question — call work_order.get(id) and read its `question` field to see what — and the answer settles it. A `paused:awaiting-interactive-turn` Work Order is an interactive session waiting at its inbox; it asked NOTHING, and what you send is put in that inbox as a message for its next turn, read together with anything else that arrived while it was parked and in the order it all arrived. `delivery` in the response says which happened. */
+    id: string;
+    /** Interactive answer retry identity, scoped to caller; reuse only for the same text and ordered attachments. */
+    input_key?: string;
+    /** Cross EVERY refusal the re-pin gate raises, including a capability or operation switch, by ending the contract rather than preserving it: every held step binding is settled `superseded` and a FRESH CHAIN GENERATION is opened for the resume, which then selects against the new pin from nothing (ADR-130 D5's "a deliberate new chain gets an explicit new generation"). It is the refusal's own suggested repair — abandon this Work Order and create a new one — WITHOUT losing the Work Order, its train, its workspace, its artifacts or its history. What it does lose is what the run was doing: a `started` binding it supersedes is a dispatch that was running. It does NOT cross a generation/digest inconsistency, which ADR-105 D7 classifies as corruption rather than as a configuration change. A binding at `admitted` or `dispatch_pending` is refused rather than superseded — those states have no edge that settles; let reconciliation republish and cross again. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/new-chain` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_open_new_chain` names every binding that would be superseded and how far each had got. */
+    new_chain?: boolean;
+    /** A structured answer taking precedence over text. For interactive ledger input, a JSON string or sole string-valued answer member becomes its decoded text; every other JSON value becomes one JSON text message with all fields preserved. Other answers retain the verbatim structured envelope. */
+    payload?: unknown;
+    /** Why. REQUIRED whenever `repin` is set, because it is stored on the new pin generation and an empty reason is what a first-dispatch pin carries — it means "nobody chose this". */
+    reason?: string;
+    /** Rebind this Work Order to the configuration its type resolves to NOW, as a new generation, and then answer (ADR-105 D7). DURABLE: every subsequent attempt uses the new generation, so it is not a one-shot override that the next attempt falls back off. ATTRIBUTED: your principal and your `reason` are stored on the generation, and the generation history is the audit trail of every forced upgrade. It is the ONLY door onto a Work Order whose pinned configuration is fatally flawed — including one whose pin this daemon cannot decode, which is the case it exists for. Authorized against `api/v1/workorders/repin` IN ADDITION to this capability's own resource; worker-class callers are refused by class and no grant restores it. Pass `dry_run` with it first to see what the resume would cross. */
+    repin?: boolean;
+    /** Displace an answer this Work Order is ALREADY holding. A Work Order whose answer was accepted and whose re-dispatch was then refused by something waiting can clear keeps that answer on its row and reads `paused:awaiting-input` again — because that is the pause it was put back into, not because it is still asking. Answering it without this flag is refused (answer_already_held); the refusal names who answered, what they said and when the daemon will next try to deliver it, so the ordinary move is to WAIT. Pass this only to correct that answer: it discards the held one and puts yours in its place, and the replacement is recorded on the transition. On a Work Order holding nothing it is a no-op, so it is safe to set on a caller that cannot read the row first — it is an acknowledgement that a held answer may be there, not an assertion that one is. Read `waiting_on.held_answer` on work_order.get to see which Work Orders it applies to. */
+    replace?: boolean;
+    /** Cross ONE refusal: a select site where this Work Order's live step binding is running a candidate the new pin no longer offers (ADR-130 D5, ratified crossable 2026-09-20). The binding row is RETAINED at the same chain generation and the resume RE-SELECTS from the new candidate set, running the candidate loop against live capacity exactly as a first admission would. It does NOT preserve the candidate the run is on — that candidate is gone, which is why the refusal exists. It lifts nothing else: a capability or operation switch at a fixed site has no candidate to re-select, and a withdrawn `yields_turn` offer is frozen for the life of a pinned conversation (ADR-129 D9). Over a site whose candidate IS still offered, or a fixed site, it is a no-op and says so in the manifest rather than refusing. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/reselect` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_reselect` names the site, the candidate being given up and the set the resume will choose from. */
+    reselect?: boolean;
+    /** The operator's exact prose. Interactive answers become one durable ledger message; other answers are wrapped as {"answer": "<text>"}. Ignored when `payload` is supplied. */
+    text?: string;
+};
+/**
+ * `work_order.answer` result (v1).
+ *
+ * What `work_order.answer` answers on success (ADR-143 D4), generated from the arms of its result union; a value is exactly one of them. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/answer.result.json
+ */
+export type WorkOrderAnswerResult = {
+    resume_error?: string;
+    input?: {
+        message: {
+            kind?: string;
+            question_at?: string;
+            input_id?: string;
+            input_sequence?: number;
+            caller?: string;
+            /** Platform-attested provenance as recorded by the dispatching host; its actor schema belongs to that host. */
+            actor?: unknown;
+            issued_at?: string;
+            text: string;
+            attachments?: {
+                handle: string;
+                filename: string;
+                mime_type: string;
+                size: number;
+                description?: string;
+            }[];
+        };
+        state: string;
+        attempt?: {
+            id: string;
+            invocation_id: string;
+            dispatch_id: string;
+            observations?: {
+                observed_at: string;
+                state: string;
+                evidence: string;
+            }[];
+        };
+        resolution?: string;
+    };
+    input_barrier?: {
+        input_id: string;
+        input_sequence: number;
+        attempt_id?: string;
+        state: string;
+        reconciliation: string;
+        behind: number;
+        recovery: string;
+    };
+    id: string;
+    state: string;
+    delivered: boolean;
+    delivery: string;
+    resumed_parked_run: boolean;
+    outcome: string;
+    repin?: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+} | {
+    id: string;
+    state: string;
+    verb: string;
+    applied: boolean;
+    repin: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/cancel.params.json
+ */
+export type WorkOrderCancelParams = {
+    /** Work Order to cancel. Cancellation cascades to its non-terminal descendants. */
+    id: string;
+    /** Short audit note recorded on the cancellation event. */
+    reason?: string;
+};
+/**
+ * `work_order.cancel` result (v1).
+ *
+ * What `work_order.cancel` answers on success (ADR-143 D4), generated from the arms of its result union; a value is exactly one of them. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/cancel.result.json
+ */
+export type WorkOrderCancelResult = {
+    id: string;
+    state: string;
+    action: string;
+    trigger: string;
+    repin?: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+    disposition?: string;
+    runner?: string;
+    detail?: string;
+} | {
+    id: string;
+    state: string;
+    cancel_requested: boolean;
+    cancelled: boolean;
+    requested_at: string;
+    upstream: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/cohort_set.params.json
+ */
+export type WorkOrderCohortSetParams = {
+    /** The cohort to move it into: a UUID read off the cohort_id of a Work Order already in that cohort. It must be borne by at least one Work Order you can read — the same rule as work_order.create's `cohort: <id>` — so a cohort is never created by naming it. */
+    cohort_id: string;
+    /** The ONE Work Order to move. Its descendants are not moved. You need reach on it, exactly as work_order.get would require. */
+    id: string;
+};
+/**
+ * `work_order.cohort_set` result (v1).
+ *
+ * What `work_order.cohort_set` answers on success (ADR-143 D4), generated from `workorder.CohortSetResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/cohort_set.result.json
+ */
+export type WorkOrderCohortSetResult = {
+    id: string;
+    cohort_id: string;
+    previous_cohort_id: string;
+    applied: boolean;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/complete.params.json
+ */
+export type WorkOrderCompleteParams = {
+    /** Work Order id. Optional for the dispatched root recipe — omit it and the id is taken from the dispatch context. When supplied it must equal the Work Order this recipe was dispatched for. */
+    id?: string;
+    outputs?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * `work_order.complete` result (v1).
+ *
+ * What `work_order.complete` answers on success (ADR-143 D4), generated from `workorder.CompleteResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/complete.result.json
+ */
+export type WorkOrderCompleteResult = {
+    id: string;
+    state: string;
+    guard_ok: boolean;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/create.params.json
+ */
+export type WorkOrderCreateParams = {
+    /** Files to hand this Work Order, each named by the HANDLE its upload minted — `tera artifacts upload <file> --description "…"` mints one in a single command, or over the API `POST /api/v1/artifacts/uploads/authorize` starts an upload and completing it mints the handle. A DISPATCHED RUN uses neither door — a worker-class caller is refused both — and attaches only a handle it has ALREADY PUBLISHED into this same train, which costs nothing and is not a re-upload. ATTACHMENTS CARRY A HANDLE AND NEVER FILE CONTENT, at any size: there is no inline, base64 or small-file form of this field on any surface, so upload first and pass the reference. You do not describe the file here — its filename, declared content type, size, digest and the uploader's description come from the upload itself, so what a later reader sees is what was actually uploaded rather than what the create said about it. An attach CONSUMES the artifact into this one Work Order's train: it leaves your staged account, the same handle keeps working, and it cannot be attached to a second Work Order — upload the file again for that. A handle you have not attached within 24 hours of uploading it is collected; attaching to a `draft` stops that clock for as long as the draft lives, and discarding the draft hands the file back to you with a fresh 24 hours rather than deleting it. Every unattachable handle answers the same way — never uploaded, already attached, expired, or somebody else's are one refusal, because telling them apart would say whether another principal's handle exists; `tera artifacts list --staged` lists what is actually yours (`GET /api/v1/artifacts/staged` over the API). A run has no staging account to list, and the handle it should be passing is one of its own outputs in this train. Inputs get their own byte allowance (64 MiB per Work Order) and never spend the separate allowance a run uses to publish artifacts about its own work. */
+    attachments?: {
+        /** The artifact handle the upload minted. Opaque: it carries no filename and no path, and nothing about it is constructible. */
+        handle: string;
+    }[];
+    /** The prose specification handed to the dispatched agent. */
+    body?: string;
+    /** The undertaking this Work Order belongs to — usually OMIT it. Unstated on a top-level Work Order, it is placed for you, in this order: the cohort of the Work Order whose dispatch is filing it; otherwise the one cohort every `depends_on` target shares; otherwise a new cohort of one, whose id is this Work Order's own. To file into an existing undertaking from outside a dispatch, pass `{"of": "<work-order-id>"}` — the cohort that Work Order is in; it is refused exactly as reading that Work Order would be. A bare cohort id (a UUID read off any Work Order's `cohort_id`) is also accepted, and must be one a Work Order you can read already carries. To OPEN a unit — a wave, a feature — pass `{"new": true, "label": "<name>"}` on the one call that files its first Work Order, and let everything beneath inherit: each call mints one cohort, so labelling every item you file makes one cohort per item. The new cohort's id is this Work Order's own. It nests under the cohort of the Work Order whose dispatch is filing it, if any; add `"detach": true` for unrelated work filed from inside a dispatch, which then nests under nothing. `label` is stored as given (at most 256 bytes, no control characters) and is a name, never an address. With `parent_id` the Work Order takes its parent's cohort, and two forms are accepted beside it: `{"new": true, "label"?: …}`, which opens a sub-unit nested under the parent's cohort, and `{"of": "<work-order-id>"}`, which joins that Work Order's cohort when it is the parent's or nested beneath it — how several children share one sub-unit: open it with the first, then name the first with `of` on every other. A cohort outside the parent's tree, a bare cohort id and `detach` are refused. The response always carries `cohort_id`. A drafted Work Order is placed when it is released, over the `depends_on` it holds then; a drafted `{"new": true}` is minted, and its label written, at that release. */
+    cohort?: string | {
+        of: string;
+    } | {
+        /** Mint with no parent cohort even when filed from inside a dispatch: unrelated work, not a sub-unit of what the dispatch is doing. */
+        detach?: boolean;
+        /** The new cohort's name, stored as given and drawn verbatim. At most 256 bytes; no control characters. Not unique, and never an address. */
+        label?: string;
+        new: true;
+    };
+    /** Capacity key; Work Orders sharing a resolved key do not run concurrently. */
+    concurrency_key?: string;
+    /** RFC3339 timestamp before which the Work Order is not dispatched. */
+    deferred_until?: string;
+    /** Work Order ids that must each complete successfully before this one is dispatched; until then it sits in `blocked:waiting-on-deps`. Reaching a terminal state is not enough — a dependency that ends `failed:awaiting-ack` or `cancelled` never releases its dependent, which stays blocked. Which field of `block_reason.detail` carries an id says what to do about it: `pending` is a live set of ids still outstanding that narrows as they complete, while `failed_deps` names dependencies that terminated unsuccessfully and `unknown_deps` ones that no longer exist — neither of the latter two clears on its own, so the dependent stays parked until the upstream is repaired. */
+    depends_on?: string[];
+    /** File this Work Order in `draft` instead of `scheduled`: it exists, it is durable, it is visible on `list` / `tree` / `get`, and it DOES NOT RUN. No gate is evaluated, no capacity is consumed and no seat is drawn, so a draft costs nothing while it sits. It leaves by exactly two doors — released into the normal lifecycle, or cancelled — and nothing puts a Work Order back into `draft` once it has left. A draft BLOCKS anything that names it in `depends_on`, which is what makes drafting a whole breakdown safe: the dependent reports the draft's id under `block_reason.detail.pending` and waits, so an unreleased item cannot be stepped over. It also never expires, and nothing sweeps it — an abandoned draft is clutter you can see and cancel, deliberately preferred to work deleted on a timer. OMIT IT unless something has to review this before it runs. Filing directly is the normal case and is exactly what it was before this field existed; drafting is for the breakdown that wants approving, the Work Order being composed incrementally, and the bulk file that should be checked before any of it dispatches. */
+    draft?: boolean;
+    /** De-duplication token for retrying this create after an ambiguous failure. Two creates carrying the same key from the same principal within 10m0s produce ONE Work Order: the second returns the first's result with `idempotent_replay: true` instead of filing a second. Use it whenever a lost response would leave you unable to tell "the request never landed" from "it landed and the reply was lost" — only the second is dangerous, and retrying it without a key files the work twice. Scoped per-principal, so it neither collides with nor can be claimed by another caller. The reservation is durable — it is written in the Work Order's own transaction and survives a daemon restart, which is exactly when a client is most likely to be mid-retry. Omit it and this create behaves exactly as it did before the field existed. */
+    idempotency_key?: string;
+    /** Typed inputs, validated against the type's declared input schema. */
+    inputs?: {
+        [key: string]: unknown;
+    };
+    /** Typed references to the vault DOCUMENTS that spawned or inform this Work Order — the PRD, ADR or plan it was filed against (ADR-048). Each entry is a {type, ref} pair with an optional note: `type` is `source` (the document that spawned this Work Order) or `references` (a related document to read it against), and `ref` is a vault document URI, `vault://<vault-id>/<path>[#<block-id>]` — `<vault-id>` the UUIDv7 of the vault volume, `<path>` the document's vault-relative path including its extension, e.g. `vault://0190d4f2-6b3a-7c11-9f2e-8a4c1d5e6f70/features/inspector/PRD.md`. Nothing else parses. A ref addresses a document at a path, so it cannot carry an external anchor — an issue or pull request in a forge has no path in a vault, and another Work Order is a row in the Work Order store rather than a document. An external anchor belongs in this type's own typed `inputs`: `code-implementation` declares `repository` and `issue_number`, which are validated per-type and actually consumed. To relate two Work Orders, use `depends_on` (causal, gates dispatch) or `parent_id` (files this one into that train). */
+    links?: {
+        note?: string;
+        ref: string;
+        type: "references" | "source";
+    }[];
+    /** External systems to mirror this Work Order into (e.g. an issue in an external tracker), each naming the connector and ref that back it. */
+    mirrors?: {
+        connector?: string;
+        mode?: "read" | "write" | "bidirectional";
+        options?: unknown;
+        ref?: string;
+        type: string;
+    }[];
+    /** File this Work Order behind the human-approval gate: it reaches `blocked:waiting-on-approval` on its first evaluation and stays there until a person runs `tera workorder approve <id>` (or `reject`, which fails it). It holds no worker slot and no subject claim while it waits, and an approval is durable — approving it once does not re-block it on the next evaluation. Omit it for the normal case; set it when something has to agree before this runs. It cannot be set later: state it here, or discard and re-file. Distinct from `draft`, which also holds a Work Order back but is a filing that is not yet committed to and is released by whoever is composing it — this one is committed work waiting on a decision. */
+    needs_approval?: boolean;
+    /** Existing Work Order to file this one beneath, making it part of that train. It must be one you can read with work_order.get; one you cannot is refused exactly as that read would refuse it. The new Work Order takes that parent's cohort, verbatim; beside it `cohort` accepts `{"new": true, "label"?: …}`, a sub-unit nested under the parent's cohort, and `{"of": "<work-order-id>"}`, joining the cohort of a Work Order in the parent's tree. */
+    parent_id?: string;
+    /** Dispatch priority; higher runs sooner among ready Work Orders. */
+    priority?: number;
+    /** Typed, NON-CAUSAL relations from this Work Order to others (supersedes / duplicate_of / about / related). Each entry is a {relation, work_order_id} pair with an optional note, and `work_order_id` is a bare Work Order id — the same spelling `depends_on` and `parent_id` use, never a `vault://` ref. Set them here when the fact is known at filing time, which for the superseding case it usually is; discovered later, use work_order.relate. Three of the four gate nothing: no dispatch is blocked, delayed or cancelled by `duplicate_of`, `about` or `related`. A `supersedes` entry is the exception and it is the point of setting one here — it RETIRES the Work Order it names, in this call's own transaction: that Work Order moves to `superseded` with `superseded_by` set to this one, and can no longer be retried. The target must be in `failed:awaiting-ack`; one that is still running is refused, and the door is work_order.force_fail(id, reason) first. A terminal one is refused too — there is no retry to close — and so is a `supersedes` entry on a drafted create, since a draft may never be released. To record the claim WITHOUT moving the row, use work_order.relate. Same authorization as work_order.relate — a worker-class caller is refused, and an operator-class one needs `api/v1/workorders/relate` on top of its create grant, because the edge is the relate operation whichever call delivered it. Every target must exist, and no two entries may name the same target. Reach on the target is required for the two EVALUATIVE relations (`supersedes`, `duplicate_of`) and not for the two descriptive ones (`about`, `related`), per entry rather than per payload. */
+    relations?: {
+        /** Optional free text recorded on the edge and on the event announcing it. At most 256 bytes — stated here rather than as `maxLength`, which counts code points, because the handler measures bytes and a schema promising otherwise would advertise a leniency it does not honour. */
+        note?: string;
+        /** What this Work Order claims about the target. about (this Work Order's work is examining or acting on that one), duplicate_of (this should not exist; that one is the real work), related (see-also, carrying no lifecycle implication), supersedes (this replaces that one; that one should not be retried). Deliberately absent: `retry_of` (the retry machinery already records attempts against a single Work Order) and anything blocking-shaped (that is `depends_on`, which is causal and gates dispatch). */
+        relation: "about" | "duplicate_of" | "related" | "supersedes";
+        /** The Work Order this claim is about, as a bare id — the same spelling `depends_on` and `parent_id` use. Not a `vault://` ref: those address a document at a path inside a volume, and a Work Order is a row in the Work Order store. */
+        work_order_id: string;
+    }[];
+    /** Free-form labels carried on the row for reporting, and selectable server-side: `work_order.list` takes a `tag` and matches it WHOLE, so pick a spelling (`repo:kottera/kottera`) and keep it — there is no prefix or wildcard match. Labels only: no tag arms a gate, changes a state transition or means anything to the daemon. At most 32 tags, each at most 128 BYTES (not characters — a tag of 128 multi-byte characters is refused). */
+    tags?: string[];
+    /** One-line human summary, shown on list / tree rows. */
+    title?: string;
+    /** Registered Work Order Type to file against. A bare leaf name is accepted when no other registered type shares it. */
+    type: string;
+    /** Worker to assign. Omit to take the type's own default worker. */
+    worker?: string;
+};
+/**
+ * `work_order.create` result (v1).
+ *
+ * What `work_order.create` answers on success (ADR-143 D4), generated from `workorder.CreateResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/create.result.json
+ */
+export type WorkOrderCreateResult = {
+    id: string;
+    worker: string;
+    state: string;
+    type: string;
+    created_at: string;
+    cohort_id: string;
+    idempotent_replay?: boolean;
+    attachments?: {
+        handle: string;
+        filename: string;
+        mime_type: string;
+        size_bytes: number;
+        description?: string;
+        consumed: boolean;
+    }[];
+    delegation?: {
+        subject: string;
+        outstanding: string[] | null;
+        unavailable?: {
+            upstream: string;
+            gap: string;
+        }[];
+        withdrawn?: {
+            upstream: string;
+            gap: string;
+        }[];
+        door?: string;
+        walled?: string[];
+        fails_at?: string;
+        checked_at?: string;
+        dispatch_timeout_seconds?: number;
+        failures?: {
+            connection: string;
+            upstream?: string;
+            holder: {
+                kind: string;
+                name: string;
+            };
+            reason: string;
+            act_by: string;
+            repair: string;
+            evidence?: string;
+        }[];
+    };
+    warnings?: string[];
+    /** The Work Order's outputs, in the shape its type's output_schema declares. Present on a completed task-augmented create's result (ADR-089 D4); absent on a synchronous create. */
+    outputs?: unknown;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/create_child.params.json
+ */
+export type WorkOrderCreateChildParams = {
+    /** Files to hand this Work Order, each named by the HANDLE its upload minted — `tera artifacts upload <file> --description "…"` mints one in a single command, or over the API `POST /api/v1/artifacts/uploads/authorize` starts an upload and completing it mints the handle. A DISPATCHED RUN uses neither door — a worker-class caller is refused both — and attaches only a handle it has ALREADY PUBLISHED into this same train, which costs nothing and is not a re-upload. ATTACHMENTS CARRY A HANDLE AND NEVER FILE CONTENT, at any size: there is no inline, base64 or small-file form of this field on any surface, so upload first and pass the reference. You do not describe the file here — its filename, declared content type, size, digest and the uploader's description come from the upload itself, so what a later reader sees is what was actually uploaded rather than what the create said about it. An attach CONSUMES the artifact into this one Work Order's train: it leaves your staged account, the same handle keeps working, and it cannot be attached to a second Work Order — upload the file again for that. A handle you have not attached within 24 hours of uploading it is collected; attaching to a `draft` stops that clock for as long as the draft lives, and discarding the draft hands the file back to you with a fresh 24 hours rather than deleting it. Every unattachable handle answers the same way — never uploaded, already attached, expired, or somebody else's are one refusal, because telling them apart would say whether another principal's handle exists; `tera artifacts list --staged` lists what is actually yours (`GET /api/v1/artifacts/staged` over the API). A run has no staging account to list, and the handle it should be passing is one of its own outputs in this train. Inputs get their own byte allowance (64 MiB per Work Order) and never spend the separate allowance a run uses to publish artifacts about its own work. */
+    attachments?: {
+        /** The artifact handle the upload minted. Opaque: it carries no filename and no path, and nothing about it is constructible. */
+        handle: string;
+    }[];
+    /** The prose specification handed to the child. */
+    body?: string;
+    /** Usually OMIT it: the child takes this Work Order's cohort, and everything it files takes the child's. Pass `{"new": true, "label": "<name>"}` only when this child OPENS a sub-unit of what this Work Order is doing — a wave of a feature, or one group of a wave — and the child's own breakdown should be grouped under that name. It mints a cohort, nested under this Work Order's, whose id is the child's own; everything the child files inherits it. Each call mints one, so do not label every child you file: that makes one cohort per child. To put several children in ONE sub-unit, open it with the first and pass `{"of": "<that child's id>"}` on every other: `of` joins the cohort of a Work Order whose cohort is this Work Order's or nested beneath it, and is refused exactly as reading that Work Order would be. A child can name no cohort outside this Work Order's tree, cannot name one by bare id, and cannot detach. A drafted child's cohort is settled when it is released: a `new` is minted, and its label written, then; an `of` naming another draft needs that draft released first or in the same set. */
+    cohort?: {
+        /** The new cohort's name, stored as given and drawn verbatim. At most 256 bytes; no control characters. Not unique, and never an address. */
+        label?: string;
+        new?: true;
+        /** Join the cohort of the Work Order with this id, which must be this Work Order's cohort or nested beneath it. Alone: not beside `new` or `label`. */
+        of?: string;
+    };
+    /** Capacity key; Work Orders sharing a resolved key do not run concurrently. Omit to take the type's own template. */
+    concurrency_key?: string;
+    /** RFC3339 timestamp before which the child is not ready. */
+    deferred_until?: string;
+    /** Work Order ids that must each complete successfully before this child is ready. A dependency that ends failed or cancelled never releases its dependent. */
+    depends_on?: string[];
+    /** File this Work Order in `draft` instead of `scheduled`: it exists, it is durable, it is visible on `list` / `tree` / `get`, and it DOES NOT RUN. No gate is evaluated, no capacity is consumed and no seat is drawn, so a draft costs nothing while it sits. It leaves by exactly two doors — released into the normal lifecycle, or cancelled — and nothing puts a Work Order back into `draft` once it has left. A draft BLOCKS anything that names it in `depends_on`, which is what makes drafting a whole breakdown safe: the dependent reports the draft's id under `block_reason.detail.pending` and waits, so an unreleased item cannot be stepped over. It also never expires, and nothing sweeps it — an abandoned draft is clutter you can see and cancel, deliberately preferred to work deleted on a timer. OMIT IT unless something has to review this before it runs. Filing directly is the normal case and is exactly what it was before this field existed; drafting is for the breakdown that wants approving, the Work Order being composed incrementally, and the bulk file that should be checked before any of it dispatches. */
+    draft?: boolean;
+    /** Typed inputs, validated against the child type's declared input schema. */
+    inputs?: {
+        [key: string]: unknown;
+    };
+    /** File this child behind the human-approval gate: it reaches `blocked:waiting-on-approval` and waits there for a person. Stated per child and never inherited from the parent. */
+    needs_approval?: boolean;
+    /** Informational, like `policy`. */
+    on_child_failure?: "fail-fast" | "wait-others" | "ignore";
+    /** The off-tera Work Order you hold, to file this child beneath (ADR-139 D6). Honoured only for its current taker; omit it inside a dispatch, where the parent is the dispatch's own Work Order. */
+    parent?: string;
+    /** Informational: echoed back for your own bookkeeping. What governs whether the parent waits is the wait it declares, not this field. */
+    policy?: "wait-for-all" | "wait-for-any" | "fire-and-forget";
+    /** Dispatch priority; higher runs sooner among ready Work Orders. */
+    priority?: number;
+    /** At most 32 tags, each at most 128 BYTES (not characters — a tag of 128 multi-byte characters is refused). */
+    tags?: string[];
+    /** One-line human summary, shown on list and tree rows. */
+    title?: string;
+    /** Registered Work Order Type to file the child against. A bare leaf name is accepted when no other registered type shares it. */
+    type: string;
+    /** The child's owning worker. It must be the parent's; omit it to take the parent's. */
+    worker?: string;
+};
+/**
+ * `work_order.create_child` result (v1).
+ *
+ * What `work_order.create_child` answers on success (ADR-143 D4), generated from `workorder.CreateChildResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/create_child.result.json
+ */
+export type WorkOrderCreateChildResult = {
+    id: string;
+    parent_id: string;
+    cohort_id: string;
+    worker: string;
+    state: string;
+    policy: string;
+    on_child_failure?: string;
+    attachments?: {
+        handle: string;
+        filename: string;
+        mime_type: string;
+        size_bytes: number;
+        description?: string;
+        consumed: boolean;
+    }[];
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/edit.params.json
+ */
+export type WorkOrderEditParams = {
+    /** The prose specification handed to the dispatched agent. Stated empty clears it. To correct part of it without re-emitting the whole thing, use `edits`. */
+    body?: string;
+    /** Capacity key; Work Orders sharing a resolved key do not run concurrently. Stated empty removes the restriction. It is not re-derived from the type's template when `inputs` change — a stated key is yours to keep, so re-derivation would silently overwrite it from a field that has nothing to do with it; state the key to change it. */
+    concurrency_key?: string;
+    /** Work Order ids that must each complete successfully before this one is dispatched. REPLACES the current set; `[]` clears it. Every id must exist, none may repeat, and none may be this Work Order itself. Checked for cycles against the combined dependency / parent / wait graph BEFORE anything is written — a dependency that would close one refuses the whole call, naming the edges, and the draft is left exactly as it was including the other fields the call stated. */
+    depends_on?: string[];
+    /** Substring replacements against this draft's prose, stated instead of its new full value — the cheapest spelling there is, and the one the whole amendment exists for: a correction to a few sentences of a task document costs the correction rather than the document. Applied IN ORDER, each against the result of the previous, so a later edit may target text an earlier one produced. ANY failing edit refuses the WHOLE call and writes nothing — not the other edits, and not the other fields the same call stated. An `old_string` that is not found is a refusal (`string_edit_not_found`), and so is one matching more than once without `replace_all` (`string_edit_ambiguous`, which reports the count); the first match is never taken silently. A field cannot be both edited here and stated wholesale in the same call. */
+    edits?: {
+        /** What this edit addresses: `title`, `body`, or `inputs.<key>` for one key of the typed input document — e.g. `inputs.task`, which is where the code-* types keep their task prose. Everything after the first dot is the key verbatim, so an input key containing a dot is addressable. The addressed input must exist and must be a string. The other editable fields are refused by name: `worker` and `concurrency_key` are short identifiers cheaper to state whole, and `tags`, `depends_on`, `links`, `relations` and `priority` are not text. */
+        field: string;
+        /** What replaces it. May be empty, which deletes the text. May not equal `old_string`: replacing text with itself is an argument that was dropped, not a change. */
+        new_string: string;
+        /** The exact text to find. Never empty — the empty string occurs everywhere and so names no location. Include enough surrounding text to identify ONE occurrence, or set `replace_all`. */
+        old_string: string;
+        /** Replace EVERY occurrence. Unset, a second match refuses the call and reports the count rather than silently picking the first — a caller that meant a later occurrence would otherwise have no way to see that the wrong text moved. */
+        replace_all?: boolean;
+    }[];
+    /** The Work Order to edit: a draft for any field, any state for `title` and `links`. Required, and never defaulted from the caller's own dispatch: an edit is stated about a Work Order by somebody who is not running it, so a defaulted id would let a mistyped call rewrite the caller's own work. */
+    id: string;
+    /** Typed inputs, REPLACING the draft's current ones wholesale — this is not a merge, so state every key you want the Work Order to keep. To change SOME keys use `inputs_patch`, and to change some TEXT inside one key use `edits`; both cost the size of the correction rather than the size of the document. They are not validated against the type's input schema here: ADR-104 D10 makes an incomplete draft a legitimate artifact and checks validity at release, which is what lets a Work Order be composed across several edits. */
+    inputs?: {
+        [key: string]: unknown;
+    };
+    /** Typed inputs to change, MERGED per key — the cheap spelling of `inputs`, and the one to reach for when a correction is smaller than the document. A stated key replaces that key, an UNSTATED key is left exactly as it is, and a key stated as null is REMOVED. Only top-level keys: a stated object value replaces that input wholesale rather than merging into it, which is where this deliberately departs from RFC 7386 JSON Merge Patch — inputs are flat in practice, and recursion would make "replace a whole object-valued input" a question with a surprising answer. Cannot be stated together with `inputs`, which answers the same question wholesale. Because null is the removal spelling, an input cannot be SET to null through a patch; state `inputs` for that. Not validated against the type's input schema here — ADR-104 D10 checks validity at release. */
+    inputs_patch?: {
+        [key: string]: unknown;
+    };
+    /** Typed references to the vault DOCUMENTS that spawned or inform this Work Order (ADR-048). REPLACES the current list; `[]` clears it. Editable in any state, like `title`. Same grammar as on work_order.create: each entry is a {type, ref} pair with an optional note, and `ref` is `vault://<vault-id>/<path>[#<block-id>]`, e.g. `vault://0190d4f2-6b3a-7c11-9f2e-8a4c1d5e6f70/features/inspector/PRD.md`. */
+    links?: {
+        note?: string;
+        ref: string;
+        type: "references" | "source";
+    }[];
+    /** Dispatch priority; higher runs sooner among ready Work Orders. */
+    priority?: number;
+    /** Optional note recorded on the `edited` event, read by whoever asks why this draft says something different from what was filed. The event names the actor and the fields either way; this is the why. */
+    reason?: string;
+    /** Typed, NON-CAUSAL relations to ASSERT on this draft (supersedes / duplicate_of / about / related). ADDITIVE, unlike every other field here: entries are asserted and nothing is withdrawn by omission, because two of the four are evaluative — they change what the TARGET's own work_order.get says about how to treat it — and dropping one by leaving it out would retract a claim about another Work Order silently. To remove an edge, use work_order.unrelate, which names the triple it withdraws. Same authorization as work_order.relate: an operator-class caller needs `api/v1/workorders/relate` on top of its edit grant, because the edge is the relate operation whichever call delivered it. */
+    relations?: {
+        /** Optional free text recorded on the edge and on the event announcing it. At most 256 bytes — stated here rather than as `maxLength`, which counts code points, because the handler measures bytes and a schema promising otherwise would advertise a leniency it does not honour. */
+        note?: string;
+        /** What this Work Order claims about the target. about (this Work Order's work is examining or acting on that one), duplicate_of (this should not exist; that one is the real work), related (see-also, carrying no lifecycle implication), supersedes (this replaces that one; that one should not be retried). Deliberately absent: `retry_of` (the retry machinery already records attempts against a single Work Order) and anything blocking-shaped (that is `depends_on`, which is causal and gates dispatch). */
+        relation: "about" | "duplicate_of" | "related" | "supersedes";
+        /** The Work Order this claim is about, as a bare id — the same spelling `depends_on` and `parent_id` use. Not a `vault://` ref: those address a document at a path inside a volume, and a Work Order is a row in the Work Order store. */
+        work_order_id: string;
+    }[];
+    /** Free-form labels carried on the row for reporting, and selectable with `work_order.list`'s `tag` filter, which matches a tag whole. REPLACES the current set; `[]` clears it. At most 32 tags, each at most 128 BYTES (not characters — a tag of 128 multi-byte characters is refused). */
+    tags?: string[];
+    /** One-line human summary, shown on list / tree rows. Editable in any state, so a Work Order's title can follow what it turned out to be. Stated empty clears it. To change part of a DRAFT's title rather than all of it, use `edits`. */
+    title?: string;
+    /** The worker that will own the released Work Order. Releasing a draft requires one, so this is the field that repairs a draft filed against the wrong owner. */
+    worker?: string;
+};
+/**
+ * `work_order.edit` result (v1).
+ *
+ * What `work_order.edit` answers on success (ADR-143 D4), generated from `workorder.EditResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/edit.result.json
+ */
+export type WorkOrderEditResult = {
+    id: string;
+    state: string;
+    applied: string[] | null;
+    worker: string;
+    title: string;
+    body: string;
+    /** The draft's inputs after the edit, in the shape its type's input_schema declares. */
+    inputs: unknown;
+    priority: number;
+    tags: string[] | null;
+    depends_on: string[] | null;
+    concurrency_key: string;
+    links: {
+        type: string;
+        ref: string;
+        note?: string;
+    }[] | null;
+    relations: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    related_by: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    relation_scope?: {
+        withheld_relations?: number;
+        withheld_related_by?: number;
+        note: string;
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/events.params.json
+ */
+export type WorkOrderEventsParams = {
+    /** Work Order to read events for. Omit to read the global event stream across every Work Order (operator-gated). */
+    id?: string;
+    /** Maximum rows to return; 0 or absent means no cap. Exactly `limit` rows back means there is more to read. */
+    limit?: number;
+    /** A plugin principal, `plugin:<vault>/<name>`. Global stream only: returns just the events whose actor names that plugin (ADR-141 D7) — what it did as itself, the Work Orders its triggers filed, and what a person did through its on-behalf-of token. The cursor contract is unchanged. */
+    plugin?: string;
+    /** Exclusive cursor: return only events with id > since. Resume from the id of the last row processed. */
+    since?: number;
+};
+/**
+ * `work_order.events` result (v1).
+ *
+ * What `work_order.events` answers on success (ADR-143 D4), generated from `workorder.EventsResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/events.result.json
+ */
+export type WorkOrderEventsResult = {
+    events: {
+        id: number;
+        work_order_id: string;
+        work_order_type?: string;
+        timestamp: string;
+        kind: string;
+        from_state?: string;
+        to_state: string;
+        reason?: string;
+        /** The event's payload, whose shape its kind decides, as the event log recorded it. */
+        payload?: unknown;
+        /** Who caused the event, as the event log recorded it. The shape written is an EventActor; a row written before a field existed lacks that key. */
+        actor?: unknown;
+    }[] | null;
+    /** Set on the global stream when since lies below the history watermark: events at or below this id may be missing from the stream because a delete removed them. Omitted when the stream from since is complete. */
+    trimmed_through?: number;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/fail.params.json
+ */
+export type WorkOrderFailParams = {
+    error: string;
+    /** Machine-readable failure signature (ADR-079 D1). Optional; `error` remains the human-readable line. Consumed by the exception funnel's intake to decide whether a deterministic pre-filter can act on this failure. */
+    failure?: {
+        /** kind=permission_denied: the capability whose invocation was refused (`work_order.fail`). Names the grant an operator has to restore. */
+        capability?: string;
+        /** Opaque per-kind detail. Not a place for a field the kind should name. */
+        detail?: unknown;
+        /** The wire error code the failure arrived with, verbatim (`envelope_missing`, `exec_error`, `local_execution_refused`). Provenance rather than a second discriminator: `kind` is this daemon's own closed vocabulary and is what you branch on, and this is the capability-plane value it was derived from — whose producer is free to add codes this daemon has no kind for. The derivation is lossy on purpose (`exec_error` and `producer_exit` share one kind), so this is where the distinction survives. One arm states the daemon's own attribution instead of the step's code: a dispatch whose pool member's credential died reports `producer_exit` like any other dead producer, and the daemon — which held the member and typed the death — records `account_auth_failed`, with the step's own code preserved on `detail.code`. Optional; most failures carry no code. */
+        error_code?: string;
+        /** Which failure shape this is. Selects which of the fields below are required. */
+        kind: "ceiling_exceeded" | "delegation_not_granted" | "dispatch_dead" | "dispatch_failed" | "environment_provisioning_failed" | "execution_error" | "permission_denied" | "result_envelope_invalid" | "result_envelope_missing" | "session_lost" | "test_failure" | "work_reported_failure" | "worker_removed";
+        /** error_code=account_auth_failed: the resource-pool member whose credential the dispatch drew on when the producer holding it reported that credential dead. The actionable half of that failure — the operator's next move is `tera seats credential <member>`, which takes this as its argument. Keyed on the code rather than on `kind`, because the dead-credential failure is an `execution_error` whose other producers name no member. Recorded, not required. */
+        member?: string;
+        /** kind=test_failure: repo-relative package the failure was reported in (`pkg/workorder`, `tests/harness`). */
+        package?: string;
+        /** kind=permission_denied: the authorization subject the refusal was decided on — the principal this Work Order's dispatches authorize as. Recorded, not required. */
+        subject?: string;
+        /** kind=test_failure: the failing test exactly as `--- FAIL:` spells it, including the `TestExternalHarness/<scenario>` prefix for harness scenarios. Matched for equality by the flake registry, so an approximation is worse than an absence. */
+        test_name?: string;
+    };
+    /** Work Order id. Optional for the dispatched root recipe — omit it and the id is taken from the dispatch context. When supplied it must equal the Work Order this recipe was dispatched for. */
+    id?: string;
+    retriable?: boolean;
+};
+/**
+ * `work_order.fail` result (v1).
+ *
+ * What `work_order.fail` answers on success (ADR-143 D4), generated from `workorder.FailResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/fail.result.json
+ */
+export type WorkOrderFailResult = {
+    id: string;
+    state: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/force_fail.params.json
+ */
+export type WorkOrderForceFailParams = {
+    /** Machine-readable failure signature (ADR-079 D1). Optional; `error` remains the human-readable line. Consumed by the exception funnel's intake to decide whether a deterministic pre-filter can act on this failure. */
+    failure?: {
+        /** kind=permission_denied: the capability whose invocation was refused (`work_order.fail`). Names the grant an operator has to restore. */
+        capability?: string;
+        /** Opaque per-kind detail. Not a place for a field the kind should name. */
+        detail?: unknown;
+        /** The wire error code the failure arrived with, verbatim (`envelope_missing`, `exec_error`, `local_execution_refused`). Provenance rather than a second discriminator: `kind` is this daemon's own closed vocabulary and is what you branch on, and this is the capability-plane value it was derived from — whose producer is free to add codes this daemon has no kind for. The derivation is lossy on purpose (`exec_error` and `producer_exit` share one kind), so this is where the distinction survives. One arm states the daemon's own attribution instead of the step's code: a dispatch whose pool member's credential died reports `producer_exit` like any other dead producer, and the daemon — which held the member and typed the death — records `account_auth_failed`, with the step's own code preserved on `detail.code`. Optional; most failures carry no code. */
+        error_code?: string;
+        /** Which failure shape this is. Selects which of the fields below are required. */
+        kind: "ceiling_exceeded" | "delegation_not_granted" | "dispatch_dead" | "dispatch_failed" | "environment_provisioning_failed" | "execution_error" | "permission_denied" | "result_envelope_invalid" | "result_envelope_missing" | "session_lost" | "test_failure" | "work_reported_failure" | "worker_removed";
+        /** error_code=account_auth_failed: the resource-pool member whose credential the dispatch drew on when the producer holding it reported that credential dead. The actionable half of that failure — the operator's next move is `tera seats credential <member>`, which takes this as its argument. Keyed on the code rather than on `kind`, because the dead-credential failure is an `execution_error` whose other producers name no member. Recorded, not required. */
+        member?: string;
+        /** kind=test_failure: repo-relative package the failure was reported in (`pkg/workorder`, `tests/harness`). */
+        package?: string;
+        /** kind=permission_denied: the authorization subject the refusal was decided on — the principal this Work Order's dispatches authorize as. Recorded, not required. */
+        subject?: string;
+        /** kind=test_failure: the failing test exactly as `--- FAIL:` spells it, including the `TestExternalHarness/<scenario>` prefix for harness scenarios. Matched for equality by the flake registry, so an approximation is worse than an absence. */
+        test_name?: string;
+    };
+    /** The Work Order to force-fail. Required — this verb acts on a Work Order the caller is not running, so there is no dispatch context to take an id from. */
+    id: string;
+    /** Why this Work Order is being declared dead. Required, and recorded on the transition event — it is what someone reading the event log later has to distinguish an operator's judgement from the agent's own failure report. */
+    reason: string;
+};
+/**
+ * `work_order.force_fail` result (v1).
+ *
+ * What `work_order.force_fail` answers on success (ADR-143 D4), generated from `workorder.ForceFailResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/force_fail.result.json
+ */
+export type WorkOrderForceFailResult = {
+    id: string;
+    state: string;
+    from_state: string;
+    upstream?: {
+        upstream?: string;
+        tracking_severed: boolean;
+        upstream_cancelled: boolean;
+        outcome_provenance: string;
+        outcome_cause: string;
+        last_reported_state?: string;
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/get.params.json
+ */
+export type WorkOrderGetParams = {
+    /** Work Order to read. On a `paused:awaiting-input` Work Order the response's `question` field carries what is being asked — read it before calling work_order.answer. **Tell that state from `paused:awaiting-interactive-turn`, which carries no question and is not a run that needs you** (ADR-129 D3): `paused:awaiting-input` is a producer that asked a specific question and is stuck until a person decides it, while `paused:awaiting-interactive-turn` is an interactive session that has yielded the turn and is waiting at its inbox for whatever comes next — a message, any of its own children settling, or the pause's own deadline. "Input" is a generic word and the second is NOT a kind of the first. On any paused Work Order `waiting_on` carries what would reopen it: `resume` names the door (empty means no door consults this pause, so nothing will end it), and `inert_predicate` marks a recorded predicate nothing consults. A park whose `resume` is "children settle" is waiting on its children — answering it destroys the wait. **`waiting_on.refusal` outranks all of that**: present only while this run's resume is being turned away, it names the cause, the member or pool, whether waiting helps, and `clears` — what would end it. While it is set the door named in `resume` is NOT what is holding the run, so do not suggest waking it: a wake re-enters the same gate and is refused again. */
+    id: string;
+    /** How much of the Work Order to answer with. `full` (the default when absent) is the whole materialized snapshot. `summary` is the same document with the operator diagnostics left out — the lean read for a supervising caller: state, what a park is waiting on and asking, why it is blocked or failed, and `has_outputs` in place of the outputs; it carries no recovery, pin, selection, pause_reason, body, inputs or outputs. Any other value is refused. */
+    view?: "full" | "summary";
+};
+/**
+ * `work_order.get` result (v1).
+ *
+ * What `work_order.get` answers on success (ADR-143 D4), generated from `workorder.GetResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/get.result.json
+ */
+export type WorkOrderGetResult = {
+    context_compactions?: {
+        state: string;
+        count: number | null;
+        latest_at?: string;
+    };
+    recovery?: {
+        workspace: {
+            state: string;
+            source: string;
+            host?: {
+                kind: string;
+                runner: string;
+            };
+            recorded_at?: string;
+            retired_at?: string;
+        };
+        session: {
+            resumability: string;
+            reason: string;
+            continuity_state: string;
+            latest_by_capability: {
+                event_id: number;
+                context_compactions?: number;
+                invocation_id?: string;
+                capability: string;
+                session_scope?: string;
+                session_id?: string;
+                resumed?: boolean;
+                resume_count?: number;
+                started_at?: string;
+                resume_refused?: boolean;
+                resume_refused_cause?: string;
+                resume_refused_reason?: string;
+                held_on?: string;
+                dispatched_to?: string;
+                unreported_resumes?: number;
+                unreported_resume_outcome?: string;
+                phase?: string;
+                observed_at: string;
+            }[] | null;
+            resume_tokens?: {
+                session_scope: string;
+                event_id: number;
+                session_id?: string;
+                stamped: boolean;
+                not_stamped_reason?: string;
+            }[];
+        };
+        guidance: string;
+    };
+    id: string;
+    worker: string;
+    type: string;
+    type_leaf: string;
+    parent_id?: string;
+    cohort_id: string;
+    state: string;
+    title?: string;
+    body?: string;
+    /** The Work Order's inputs, in the shape its type's input_schema declares. */
+    inputs?: unknown;
+    /** The Work Order's outputs, in the shape its type's output_schema declares. */
+    outputs?: unknown;
+    tags: string[] | null;
+    priority: number;
+    depends_on?: string[];
+    links?: {
+        type: string;
+        ref: string;
+        note?: string;
+    }[];
+    deferred_until?: string;
+    needs_approval?: boolean;
+    pause_reason?: {
+        kind: string;
+        /** The wait predicate the pause was taken on, as its pauser stated it: a WaitPredicate, a kind and that kind's spec. */
+        predicate?: unknown;
+        /** The pause context, in whatever shape the pauser wrote. */
+        context?: unknown;
+        delivery_envelope?: string;
+        authorized_by?: {
+            class: string;
+            principal?: string;
+            groups?: string[];
+            origin: string;
+            session_id?: string;
+            worker?: string;
+            parent_id?: string;
+            authorized_for?: string;
+            plugin?: string;
+            evidence_class?: string;
+        };
+    };
+    question?: {
+        text?: string;
+        /** The asker's structured evidence, or the whole pause context when it is not in the asking shape: its shape is the asker's. */
+        context?: unknown;
+        description?: string;
+    };
+    waiting_on?: {
+        pause_kind: string;
+        predicate_kind?: string;
+        resume: string;
+        inert_predicate?: boolean;
+        unsatisfiable?: boolean;
+        held_answer?: boolean;
+        refusal?: {
+            cause: string;
+            member?: string;
+            pool?: string;
+            pool_cause?: string;
+            verb?: string;
+            repairable: boolean;
+            refused_at?: string;
+            clears?: string;
+        };
+        input_barrier?: {
+            input_id: string;
+            input_sequence: number;
+            attempt_id?: string;
+            state: string;
+            reconciliation: string;
+            behind: number;
+            recovery: string;
+        };
+    };
+    delegation?: {
+        subject: string;
+        outstanding: string[] | null;
+        unavailable?: {
+            upstream: string;
+            gap: string;
+        }[];
+        withdrawn?: {
+            upstream: string;
+            gap: string;
+        }[];
+        door?: string;
+        walled?: string[];
+        fails_at?: string;
+        checked_at?: string;
+        dispatch_timeout_seconds?: number;
+        failures?: {
+            connection: string;
+            upstream?: string;
+            holder: {
+                kind: string;
+                name: string;
+            };
+            reason: string;
+            act_by: string;
+            repair: string;
+            evidence?: string;
+        }[];
+    };
+    could_not_decide?: {
+        kind: string;
+        detail?: string;
+    };
+    block_reason?: {
+        kind: string;
+        detail?: unknown;
+    };
+    retry?: {
+        attempt: number;
+        max: number;
+        next_retry_at?: string;
+        hint?: string;
+        reason?: string;
+        resumed_unobserved?: boolean;
+        /** The daemon's own account of why the previous attempt's result declaration was refused, composed at the retry: the violations as the refusal recorded them and the pinned output_schema the next attempt is judged by. */
+        output_contract?: unknown;
+    };
+    failure?: {
+        kind: string;
+        test_name?: string;
+        package?: string;
+        capability?: string;
+        member?: string;
+        subject?: string;
+        error_code?: string;
+        /** Per-kind detail of the failure, opaque by contract: its shape is the producer's that reported it. */
+        detail?: unknown;
+    };
+    step_refusal?: {
+        state: string;
+        binding?: {
+            source: string;
+            event_id: number;
+            at: string;
+            reason?: string;
+            to_state?: string;
+            site?: string;
+            candidate?: string;
+            selection_mode?: string;
+            binding_state?: string;
+            settlement_kind?: string;
+        };
+        step?: {
+            source: string;
+            event_id: number;
+            at: string;
+            reason?: string;
+            to_state?: string;
+            site?: string;
+            candidate?: string;
+            selection_mode?: string;
+            binding_state?: string;
+            settlement_kind?: string;
+        };
+    };
+    salvage?: {
+        inspected_at: string;
+        duration_ms?: number;
+        status: string;
+        error?: string;
+        ending?: string;
+        volumes?: {
+            id?: string;
+            kind?: string;
+            path?: string;
+            present: boolean;
+            inspected: boolean;
+            skip_reason?: string;
+            remotes?: {
+                name?: string;
+                url?: string;
+            }[];
+            base_ref?: string;
+            base_sha?: string;
+            branches?: {
+                name: string;
+                tip_sha?: string;
+                push_state: string;
+                push_reason?: string;
+                remote_ref?: string;
+                remote_sha?: string;
+                upstream?: string;
+                commits?: {
+                    sha: string;
+                    subject?: string;
+                    subject_truncated?: boolean;
+                    committed_at?: string;
+                }[];
+                history_truncated?: string;
+            }[];
+            branches_truncated?: boolean;
+            worktree?: {
+                modified: number;
+                staged: number;
+                untracked: number;
+                untracked_excluding_dispatch_scratch?: number;
+            };
+            envelope?: {
+                declared: boolean;
+                path?: string;
+                present: boolean;
+                bytes?: number;
+                parsed: boolean;
+                parse_error?: string;
+                content?: string;
+                truncated?: boolean;
+            };
+            pull_request?: {
+                determined: boolean;
+                reason?: string;
+                url?: string;
+                number?: number;
+                source?: string;
+                hint_url?: string;
+            };
+        }[];
+        truncated?: boolean;
+        dropped?: string[];
+    };
+    workspace?: {
+        runner: string;
+        attempt: number;
+        recorded_at: string;
+        retired_at?: string;
+        hold_started_at?: string;
+    };
+    session_loss?: {
+        cause: string;
+        held_on: string;
+        dispatched_to: string;
+        attempt: number;
+        deadline?: string;
+        held_since?: string;
+        observed_at: string;
+        volumes?: string[];
+    };
+    execution?: {
+        waiter?: string;
+        runner?: string;
+        dispatch_id?: string;
+        step_dispatch_id?: string;
+        since?: string;
+        late_results?: {
+            disposition: string;
+            runner: string;
+            dispatch_id: string;
+            step_dispatch_id?: string;
+            attempt: number;
+            status?: string;
+            recorded_at?: string;
+            event_id: number;
+        }[];
+    };
+    upstream_task?: {
+        upstream: string;
+        task_id: string;
+        tool?: string;
+        last_reported_state?: string;
+        sync: {
+            last_synced_at?: string;
+            reachability?: string;
+            unreachable_since?: string;
+            detail?: string;
+        };
+        outcome_provenance?: string;
+        outcome_cause?: string;
+        cancel_requested_at?: string;
+    };
+    take?: {
+        principal: string;
+        taken_at: string;
+        last_progress_at?: string;
+        describe?: string;
+        caller_is_person?: boolean;
+        outcome_provenance?: string;
+    };
+    outcome?: {
+        outcome_provenance: string;
+        attested_by?: string;
+    };
+    relations: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    related_by: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    relation_scope?: {
+        withheld_relations?: number;
+        withheld_related_by?: number;
+        note: string;
+    };
+    validity?: {
+        valid: boolean;
+        reason?: string;
+        field?: string;
+    };
+    pin?: {
+        state: string;
+        generation?: number;
+        first_generation?: boolean;
+        config_digest?: string;
+        schema_version?: number;
+        pinned_at?: string;
+        provenance?: string;
+        pinned_by?: string;
+        reason?: string;
+        absence?: string;
+        refusal?: string;
+        cause?: string;
+        match?: {
+            verdict: string;
+            live_digest?: string;
+            cause?: string;
+        };
+    } | null;
+    selection?: {
+        state: string;
+        cause?: string;
+        refusal?: string;
+        refusal_cause?: string;
+        pin_schema_version?: number;
+        sites?: {
+            state: string;
+            logical_site_id: string;
+            path?: string;
+            step?: string;
+            selectable: boolean;
+            policy?: {
+                mode: string;
+                candidate?: string;
+                order?: string[];
+            };
+            interaction?: string;
+            interactive_request?: boolean;
+            yields_turn_offer?: boolean;
+            offer_contradiction?: boolean;
+            workflow_instance_id?: string;
+            chain_generation?: number;
+            binding_state?: string;
+            revision?: number;
+            admission_revision?: number;
+            pin_generation?: number;
+            pin_digest?: string;
+            site_definition_digest?: string;
+            selection_mode?: string;
+            selection_reason?: string;
+            requested?: {
+                candidate: string;
+            };
+            selected?: {
+                candidate?: string;
+                capability_type?: string;
+                capability?: string;
+                operation?: string;
+                effective_config_digest?: string;
+                native_input_digest?: string;
+                profile_digest?: string;
+            };
+            admitted?: {
+                revision: number;
+                dispatch_id?: string;
+                draws?: {
+                    provenance: string;
+                    pool: string;
+                    member?: string;
+                }[];
+                draws_unreadable?: boolean;
+            };
+            accepted?: {
+                dispatch_document_digest?: string;
+                receipt: boolean;
+            };
+            started?: {
+                at: string;
+            };
+            settled?: {
+                kind?: string;
+                digest?: string;
+                at?: string;
+            };
+            wait?: {
+                fingerprint?: string;
+                decisions?: {
+                    candidate?: string;
+                    class?: string;
+                    reason?: string;
+                    detail?: string;
+                    terminal?: boolean;
+                }[];
+                dependencies?: {
+                    candidate?: string;
+                    kind?: string;
+                    id?: string;
+                    deadline?: string;
+                }[];
+                earliest_deadline?: string;
+                unreadable?: boolean;
+            };
+            attempt_digest?: string;
+            model_policy?: {
+                profile_id?: string;
+                profile_version?: number;
+                requested_tier?: string;
+                requested_model?: string;
+                requested_effort?: string;
+                resolved_tier?: string;
+                resolved_model?: string;
+                resolved_effort?: string;
+                table_source?: string;
+                table_revision?: string;
+                reported_state: string;
+                reported_model?: string;
+                reported_effort?: string;
+            };
+            refusal?: string;
+            refusal_cause?: string;
+            created_at?: string;
+            updated_at?: string;
+        }[];
+    } | null;
+    interaction: {
+        mode?: string;
+        provenance: string;
+        cause?: string;
+    } | null;
+    activity: {
+        state: string;
+        partition?: string;
+        partitions?: string[];
+        cause?: string;
+    } | null;
+    created_by?: string;
+    created_via?: string;
+    created_at: string;
+    updated_at: string;
+    off_tera: boolean;
+    has_outputs?: boolean;
+    archived: boolean;
+    history?: {
+        disposition: string;
+        locator?: string;
+        trimmed_at: string;
+    };
+    terminal_at?: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/guide.params.json
+ */
+export type WorkOrderGuideParams = {
+    /** Files to hand the RUNNING invocations this message reaches, each named by the HANDLE its upload minted — `tera artifacts upload <file> --description "…"` mints one in a single command, or over the API `POST /api/v1/artifacts/uploads/authorize` starts an upload and completing it mints the handle. ATTACHMENTS CARRY A HANDLE AND NEVER FILE CONTENT, at any size: there is no inline, base64 or small-file form of this field on any surface, so upload first and pass the reference. You do not describe the file here — its filename, declared content type, size and the uploader's description come from the upload itself, and they are what the notice announcing this message shows the run. Say what you want DONE with the files in `message`. What the run receives is metadata and an invitation to fetch: the platform writes nothing into its workspace, so there is no path for it to open and it reads the bytes back through its own `artifacts` verb. An attach CONSUMES the artifact into this Work Order's train: it leaves your staged account, the same handle keeps working, and it cannot be attached again. A `dry_run` consumes nothing. Nothing is consumed by a message that is refused, or that reaches nothing in flight. Every unattachable handle answers the same way — never uploaded, already attached, expired, or somebody else's are one refusal, because telling them apart would say whether another principal's handle exists; `tera artifacts list --staged` lists what is actually yours (`GET /api/v1/artifacts/staged` over the API). These files are weighed against the SAME 64 MiB per-Work-Order input allowance the Work Order was filed under, which is separate from the allowance a run uses to publish artifacts about its own work — so a long-running Work Order that was filed with attachments has less of it left. One message carries at most 64 files, a bound on the COUNT rather than the bytes: send more across more than one message. */
+    attachments?: {
+        /** The artifact handle the upload minted. Opaque: it carries no filename and no path, and nothing about it is constructible. */
+        handle: string;
+    }[];
+    /** Resolve and report without enqueuing anything. The resolved set, each member's declared contract, and any refusals still come back — a refusal is decided from the capability's declaration, so it is evidence a dry run genuinely has. It CONSUMES NO ATTACHMENT: handles named alongside it are still staged and still yours afterwards. */
+    dry_run?: boolean;
+    /** The Work Order whose in-flight invocations to address. Required — this verb acts on a Work Order the caller is not running, so there is no dispatch context to take an id from. It resolves to the SET of in-flight invocations in that Work Order's dispatch tree; the whole set comes back on `resolved`, whether or not it was addressed. Only THIS Work Order's own invocations are addressed by default — a message addressed to a Work Order is never delivered to a descendant of it. If this Work Order is running nothing of its own the message is HELD and delivered when it next runs, whatever its descendants' hosts are doing. If it is running on a host this daemon holds no live link to, the message is HELD too, and delivered to that run when the host reconnects or to the next run, whichever comes first — never answered `accepted` against a run nobody can reach. The `held` block says so, and its `woke` member says the run was an interactive session at its inbox and a turn was started to read the message. OFF-TERA WORK (ADR-139 D9) is never held: deliver POSTS the message on that Work Order for its taker, present or future — ack `posted`, and the `posted` block names the event the taker's replies carry — and interrupt is refused, because there is no turn to interrupt. */
+    id: string;
+    /** Exclusive conversation sequence cursor for a dry-run history page; follow input_next_after. */
+    input_after?: number;
+    /** Interactive submission identity, scoped to this caller and conversation. Retry the same key with identical text and handles after a lost reply; omission creates a distinct message. */
+    input_key?: string;
+    /** Explicit resolution of an uncertain interactive attempt; requires correlated history or a stated operator replay decision. */
+    input_recovery?: {
+        attempt_id: string;
+        evidence: string;
+        input_id: string;
+        state: "pending" | "incorporated" | "cancelled";
+    };
+    /** Address exactly this invocation instead of the default. Ids come from the `resolved` set of any call, including a dry run — so this narrows within a set already resolved and cannot redirect to something the resolution did not report. A named invocation is never held: one on an unreachable host answers `undetermined` and nothing is written. */
+    invocation_id?: string;
+    /** What to say to the running invocation. Content only — the platform composes the envelope around it (who sent it, attested, and when), so framing written here is content and not framing. Required unless `dry_run` is set or nothing is in flight. */
+    message?: string;
+    /** Which members of the resolved set to address. `addressee` is the default: the invocations of the Work Order named in `id`, and NEVER an invocation belonging to a descendant of it. `leaves` addresses the invocations actually doing the work anywhere beneath it — the old default, on request. A leaf is also addressable on its own by passing ITS Work Order id as `id`, which is what the refusal for an idle addressee names. A `leaves` call is never held: members on an unreachable host answer `undetermined` and nothing is written for them. */
+    target?: "addressee" | "leaves";
+    /** deliver queues the message for the invocation to take when it next reaches a point it can — its latency is bounded by the unit of work in flight, which each resolved member reports as `unit_of_work`. interrupt cancels that unit and presents the message as a fresh directive. Required: the two differ on what they cost, and the choice is the caller's. AGAINST AN INTERACTIVE RUN (ADR-129 D6): deliver to one parked at `paused:awaiting-interactive-turn` is held AND wakes it, so a turn starts to read it and `held.woke` is true; interrupt on one that is RUNNING discards the turn in flight and the run lands back at that inbox rather than failing or completing. interrupt is never held: against a run with nothing in flight it is refused — there is no unit of work to discard, and a held interrupt would arrive at a future turn it was never aimed at — and against a run on an unreachable host it answers `undetermined` and writes nothing. */
+    verb: "deliver" | "interrupt";
+};
+/**
+ * `work_order.guide` result (v1).
+ *
+ * What `work_order.guide` answers on success (ADR-143 D4), generated from `workorder.GuideResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/guide.result.json
+ */
+export type WorkOrderGuideResult = {
+    input_next_after?: number;
+    inputs?: {
+        message: {
+            kind?: string;
+            question_at?: string;
+            input_id?: string;
+            input_sequence?: number;
+            caller?: string;
+            /** Platform-attested provenance as recorded by the dispatching host; its actor schema belongs to that host. */
+            actor?: unknown;
+            issued_at?: string;
+            text: string;
+            attachments?: {
+                handle: string;
+                filename: string;
+                mime_type: string;
+                size: number;
+                description?: string;
+            }[];
+        };
+        state: string;
+        attempt?: {
+            id: string;
+            invocation_id: string;
+            dispatch_id: string;
+            observations?: {
+                observed_at: string;
+                state: string;
+                evidence: string;
+            }[];
+        };
+        resolution?: string;
+    }[];
+    input_barrier?: {
+        input_id: string;
+        input_sequence: number;
+        attempt_id?: string;
+        state: string;
+        reconciliation: string;
+        behind: number;
+        recovery: string;
+    };
+    id: string;
+    verb: string;
+    dry_run: boolean;
+    selected: string;
+    resolved: {
+        invocation_id: string;
+        capability: string;
+        work_order_id?: string;
+        started_at: string;
+        leaf: boolean;
+        addressed: boolean;
+        accepts: string[] | null;
+        unit_of_work?: string;
+        deliver_latency?: string;
+        ack?: {
+            state: string;
+            evidence: string;
+            reason?: string;
+            sequence?: number;
+        };
+    }[] | null;
+    resolved_count: number;
+    addressed_count: number;
+    by_state?: {
+        [key: string]: number;
+    };
+    undetermined?: {
+        runner: string;
+        reason: string;
+    }[];
+    ack?: {
+        state: string;
+        evidence: string;
+        reason?: string;
+        sequence?: number;
+    };
+    held?: {
+        work_order_id: string;
+        sequence: number;
+        expires_at: string;
+        woke?: boolean;
+    };
+    posted?: {
+        work_order_id: string;
+        event_id: number;
+        taker?: string;
+        attachments?: string[];
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/history.params.json
+ */
+export type WorkOrderHistoryParams = {
+    /** Any member of the archived train. Required; never defaulted from a dispatch. */
+    id: string;
+};
+/**
+ * `work_order.history` result (v1).
+ *
+ * What `work_order.history` answers on success (ADR-143 D4), generated from `workorder.HistoryResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/history.result.json
+ */
+export type WorkOrderHistoryResult = {
+    id: string;
+    locator: string;
+    record: {
+        header: {
+            kind: string;
+            record_version: number;
+            root_id: string;
+            type: string;
+            partition?: string;
+            terminal_at: string;
+        };
+        members: {
+            id: string;
+            worker?: string;
+            type: string;
+            parent_id?: string;
+            cohort_id?: string;
+            state: string;
+            /** The parent step this member was filed for, as archived. */
+            parent_step?: unknown;
+            /** The pause reason the member last held, as archived. */
+            pause_reason?: unknown;
+            /** The block reason the member last held, as archived. */
+            block_reason?: unknown;
+            /** The member's retry policy and count, as archived. */
+            retry?: unknown;
+            /** The member's spec — title, body, inputs and the rest — as archived. */
+            spec?: unknown;
+            /** The member's outputs, as archived. */
+            outputs?: unknown;
+            /** The member's failure, as archived. */
+            failure?: unknown;
+            /** The member's salvage record, as archived. */
+            salvage?: unknown;
+            /** The member's workspace record, as archived. */
+            workspace?: unknown;
+            /** The member's session-loss record, as archived. */
+            session_loss?: unknown;
+            /** The member's activity-partition pin, as archived. */
+            activity_partition?: unknown;
+            /** The member's declared artefacts, as archived. */
+            artefacts?: unknown;
+            assignee?: string;
+            created_by?: string;
+            created_at: string;
+            updated_at?: string;
+            superseded_by?: string;
+            terminal_at?: string;
+            config_digest?: string;
+            events?: {
+                id: number;
+                timestamp: string;
+                kind: string;
+                from_state?: string;
+                to_state?: string;
+                /** Who caused the event, as archived. */
+                actor?: unknown;
+                /** The event's payload, as archived. */
+                payload?: unknown;
+                reason?: string;
+            }[];
+            rows?: {
+                kind: string;
+                /** The row's domain shape, which its kind names. */
+                shape: unknown;
+            }[];
+            artifacts?: {
+                handle: string;
+                filename: string;
+                media_type: string;
+                size: number;
+                content_digest: string;
+            }[];
+            observations?: {
+                id: string;
+                digest: string;
+            }[];
+            correspondence?: {
+                id: string;
+                digest: string;
+            }[];
+        }[] | null;
+        digest: string;
+    };
+    withheld?: {
+        partition: string;
+        members: number;
+    }[];
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/history_unblock.params.json
+ */
+export type WorkOrderHistoryUnblockParams = {
+    /** The root of the blocked train. Required; never defaulted from a dispatch. */
+    id: string;
+};
+/**
+ * `work_order.history_unblock` result (v1).
+ *
+ * What `work_order.history_unblock` answers on success (ADR-143 D4), generated from `workorder.HistoryUnblockResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/history_unblock.result.json
+ */
+export type WorkOrderHistoryUnblockResult = {
+    id: string;
+    table: string;
+    effect: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/human.ask.params.json
+ */
+export type WorkOrderHumanAskParams = {
+    /** Structured evidence the operator needs to decide, carried alongside the question everywhere it is surfaced. Opaque — attach whatever the answer turns on. */
+    context?: unknown;
+    /** Optional, and omitting it is the ordinary park. Record this ONLY when you stopped because you could not decide the thing you are asking about and are handing it up — not when you are asking something that was always going to a person. It is what makes "the human seat consulted only where no ancestor could decide" a measurement rather than a reconstruction, so a record you did not mean makes that number wrong. Accepted on reason "awaiting-input" only. */
+    could_not_decide?: {
+        /** Optional. What you tried and why the choice is not yours to make. The question beside this already says what is being asked, so do not repeat it here. */
+        detail?: string;
+        /** The typed classification. Today there is one: "undecidable-here" — this run could not take the decision at its own level of the tree. */
+        kind: string;
+    };
+    /** Work Order to park. Optional for the dispatched root recipe — omit it and the id is taken from the dispatch context. */
+    id?: string;
+    /** What to ask the operator, in prose. This is the text the operator answers against: it comes back on work_order.get as `question.text`, inline per node on work_order.tree, and on `tera workorder show` / `answer`. Ask something answerable without the agent's context — the reader has the Work Order and this sentence. */
+    question: string;
+};
+/**
+ * `human.ask` result (v1).
+ *
+ * What `human.ask` answers on success (ADR-143 D4), generated from `workorder.PauseResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/human.ask.result.json
+ */
+export type WorkOrderHumanAskResult = {
+    id: string;
+    state: string;
+    resumed: boolean;
+    /** The resume payload, in whatever shape its answerer sent. */
+    payload?: unknown;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/interrupt.params.json
+ */
+export type WorkOrderInterruptParams = {
+    /** The Work Order whose running dispatch to end. Required — this verb acts on a Work Order the caller is not running. */
+    id: string;
+    /** Why the run is being stopped. Required: it is handed to the running session as the stop's sentence and recorded on the park. */
+    reason: string;
+};
+/**
+ * `work_order.interrupt` result (v1).
+ *
+ * What `work_order.interrupt` answers on success (ADR-143 D4), generated from `workorder.InterruptResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/interrupt.result.json
+ */
+export type WorkOrderInterruptResult = {
+    id: string;
+    state: string;
+    parks_at: string;
+    dispatches_stopped: number;
+    resume: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/list.params.json
+ */
+export type WorkOrderListParams = {
+    /** Select the Work Orders in this cohort — the undertaking a Work Order belongs to, read off any row's `cohort_id` (a Work Order filed alone is a cohort of one, whose id is its own). A UUID; anything else is refused rather than matched. Unlike `tag` this reads an indexed column on both store backends, so it is the filter to pass alone for 'everything in this undertaking', in every state, terminal included. Composes with the other filters as an AND. */
+    cohort?: string;
+    /** Select Work Orders filed with exactly this resolved capacity key. Matched verbatim against the key on the row, which is already materialized against that Work Order's own inputs — pass `prefilter/<subject id>`, not the type's `${inputs...}` template. This is how a caller asks 'is another Work Order of this tier already working my subject?' without reading inputs back out of every row. */
+    concurrency_key?: string;
+    /** Include archived Work Orders: those whose train left the hot window and whose history was trimmed, leaving a stub that keeps its id, type, worker, final state, parent and cohort. Absent or false answers about hot work only. An archived row carries `archived: true`; `tag`, `concurrency_key` and `subject` cannot match one, because the trim took what they read. */
+    include_archived?: boolean;
+    /** Maximum rows to return; 0 or absent means no cap. */
+    limit?: number;
+    /** Select the direct children of this Work Order — one generation. For a whole train, call work_order.tree. */
+    parent_id?: string;
+    /** Select Work Orders in exactly this state, e.g. `paused:awaiting-input` to find work that is waiting on an operator. Use `states` to match more than one. */
+    state?: string;
+    /** Select Work Orders in any of these states. Supersedes `state` when both are given. */
+    states?: string[];
+    /** Select Work Orders about this world subject, written bare as `<kind>/<id>` (`flake/TestShimServerSpawnsWithCredential`, `device/porch-temp`). This is the 'is anything already about this?' question a harness asks before it files, and it is answered from the subject index, so the answer spans every state INCLUDING terminal ones — work that is filed and blocked on deps, and work that was tried and failed, are two of the three useful answers. Reading is authorized per subject kind: a kind this deployment has not declared, or has not granted you, is refused rather than filtered to an empty list. */
+    subject?: string;
+    /** Select Work Orders carrying exactly this tag — `repo:kottera/kottera` to see everything in flight for one repository. Matched WHOLE, as an opaque string: there is no wildcard, no prefix match and no namespace, so `repo:*` selects Work Orders whose tag is literally `repo:*`. One tag per call, not a set. Tags ride the spec rather than a column, so this filter is unindexed on both store backends — pair it with `type`, `worker` or `states` when the table is large. */
+    tag?: string;
+    /** Select Work Orders of this type. A bare leaf name (`code-implementation`) is resolved against the registry, so the namespaced form is not required. */
+    type?: string;
+    /** Select Work Orders assigned to this worker. */
+    worker?: string;
+    /** Select Work Orders holding a workspace on this runner: their recorded workspace affinity (`recovery.workspace` on work_order.get) names it and has not been retired. This is what to ask before moving or wiping a host's data directory, because a PARKED Work Order holds its workspace as surely as a running one and a resume after the move would get a fresh, empty one. Terminal Work Orders whose bytes were retained match too, since a retry resumes there; pass `states` for live work only. Name the daemon's own host by its reserved runner name. Matched whole; unindexed on both store backends. */
+    workspace_host?: string;
+};
+/**
+ * `work_order.list` result (v1).
+ *
+ * What `work_order.list` answers on success (ADR-143 D4), generated from `workorder.ListResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/list.result.json
+ */
+export type WorkOrderListResult = {
+    work_orders: {
+        context_compactions?: {
+            state: string;
+            count: number | null;
+            latest_at?: string;
+        };
+        id: string;
+        parent_id?: string;
+        worker: string;
+        type: string;
+        state: string;
+        title?: string;
+        concurrency_key: string;
+        cohort_id: string;
+        tags: string[] | null;
+        priority: number;
+        validity?: {
+            valid: boolean;
+            reason?: string;
+            field?: string;
+        };
+        block_reason?: {
+            kind: string;
+            detail?: unknown;
+        };
+        deferred_until?: string;
+        created_at: string;
+        updated_at: string;
+        off_tera: boolean;
+        archived: boolean;
+        take?: {
+            principal: string;
+            taken_at: string;
+            last_progress_at?: string;
+            describe?: string;
+            caller_is_person?: boolean;
+            outcome_provenance?: string;
+        };
+    }[] | null;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/list_off_tera.params.json
+ */
+export type WorkOrderListOffTeraParams = Record<string, never>;
+/**
+ * `work_order.list_off_tera` result (v1).
+ *
+ * What `work_order.list_off_tera` answers on success (ADR-143 D4), generated from `workorder.ListOffTeraResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/list_off_tera.result.json
+ */
+export type WorkOrderListOffTeraResult = {
+    posted: {
+        id: string;
+        type: string;
+        state: string;
+        title?: string;
+        requirements: string;
+        /** The Work Order's inputs, verbatim, in the shape its type's input_schema declares. */
+        inputs?: unknown;
+        created_at: string;
+        age_seconds: number;
+        take?: {
+            principal: string;
+            taken_at: string;
+            last_progress_at?: string;
+            describe?: string;
+            caller_is_person?: boolean;
+            outcome_provenance?: string;
+        };
+        take_age_seconds?: number;
+        /** On a held entry: the JSON Schema this Work Order was pinned to at its first take, which submit_result grades the record against. Absent on posted and taken entries, and when the type declares none. */
+        output_schema?: unknown;
+    }[] | null;
+    held: {
+        id: string;
+        type: string;
+        state: string;
+        title?: string;
+        requirements: string;
+        /** The Work Order's inputs, verbatim, in the shape its type's input_schema declares. */
+        inputs?: unknown;
+        created_at: string;
+        age_seconds: number;
+        take?: {
+            principal: string;
+            taken_at: string;
+            last_progress_at?: string;
+            describe?: string;
+            caller_is_person?: boolean;
+            outcome_provenance?: string;
+        };
+        take_age_seconds?: number;
+        /** On a held entry: the JSON Schema this Work Order was pinned to at its first take, which submit_result grades the record against. Absent on posted and taken entries, and when the type declares none. */
+        output_schema?: unknown;
+    }[] | null;
+    taken?: {
+        id: string;
+        type: string;
+        state: string;
+        title?: string;
+        requirements: string;
+        /** The Work Order's inputs, verbatim, in the shape its type's input_schema declares. */
+        inputs?: unknown;
+        created_at: string;
+        age_seconds: number;
+        take?: {
+            principal: string;
+            taken_at: string;
+            last_progress_at?: string;
+            describe?: string;
+            caller_is_person?: boolean;
+            outcome_provenance?: string;
+        };
+        take_age_seconds?: number;
+        /** On a held entry: the JSON Schema this Work Order was pinned to at its first take, which submit_result grades the record against. Absent on posted and taken entries, and when the type declares none. */
+        output_schema?: unknown;
+    }[];
+    taken_visible: boolean;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/pause.params.json
+ */
+export type WorkOrderPauseParams = {
+    /** Opaque human-facing JSON, surfaced beside the Work Order and passed to a `cel` predicate as `context`. REQUIRED under reason "awaiting-review": that park's doors are a person, you have no outputs yet, and this is the only thing the reviewer gets — pass what they should open, e.g. {"artifact_url": "..."} or {"summary": "..."}. */
+    context?: unknown;
+    /** Optional, and omitting it is the ordinary park. Record this ONLY when you stopped because you could not decide the thing you are asking about and are handing it up — not when you are asking something that was always going to a person. It is what makes "the human seat consulted only where no ancestor could decide" a measurement rather than a reconstruction, so a record you did not mean makes that number wrong. Accepted on reason "awaiting-input" only. */
+    could_not_decide?: {
+        /** Optional. What you tried and why the choice is not yours to make. The question beside this already says what is being asked, so do not repeat it here. */
+        detail?: string;
+        /** The typed classification. Today there is one: "undecidable-here" — this run could not take the decision at its own level of the tree. */
+        kind: string;
+    };
+    id?: string;
+    /** Optional. What would end this wait. Required under reason "awaiting-event", whose door evaluates it; refused under "awaiting-review", whose doors are a reviewer's approve / reject / rework and evaluate nothing. */
+    predicate?: {
+        kind: "literal-match" | "cel" | "any-child-completes" | "all-children-complete" | "any-child-transitions" | "these-work-orders" | "these-work-orders-transitions";
+        spec?: unknown;
+    };
+    reason: "awaiting-input" | "awaiting-event" | "awaiting-review" | "awaiting-children" | "awaiting-approval" | "awaiting-interactive-turn";
+    /** Optional. How long this wait is willing to wait, in Go duration syntax ("30m", "2h"). When it elapses the run is woken and told that is why — it is not failed, not completed, and the wait is not re-armed; declare a fresh one if you still want notifying. Omit for an unbounded wait, which is the default. Not accepted on reason "awaiting-review". */
+    timeout?: string;
+};
+/**
+ * `work_order.pause` result (v1).
+ *
+ * What `work_order.pause` answers on success (ADR-143 D4), generated from `workorder.PauseResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/pause.result.json
+ */
+export type WorkOrderPauseResult = {
+    id: string;
+    state: string;
+    resumed: boolean;
+    /** The resume payload, in whatever shape its answerer sent. */
+    payload?: unknown;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/prioritize.params.json
+ */
+export type WorkOrderPrioritizeParams = {
+    /** The Work Order whose priority changes. Required; never defaulted from a dispatch. */
+    id: string;
+    /** The new priority. Higher is admitted first; 0 is the default every Work Order is filed with. */
+    priority: number;
+    /** Why this Work Order's place in the queue changed. Required, and recorded beside the old and the new value. */
+    reason: string;
+};
+/**
+ * `work_order.prioritize` result (v1).
+ *
+ * What `work_order.prioritize` answers on success (ADR-143 D4), generated from `workorder.PrioritizeResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/prioritize.result.json
+ */
+export type WorkOrderPrioritizeResult = {
+    id: string;
+    state: string;
+    priority: number;
+    previous_priority: number;
+    effect: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/progress.params.json
+ */
+export type WorkOrderProgressParams = {
+    /** The off-tera Work Order you hold. Required. */
+    id: string;
+    /** How the work is going, in your own words. Recorded on the Work Order's event log as off_tera.progress. At most 4096 bytes. */
+    message: string;
+    /** The id of the last event you have processed on this Work Order. The response carries the events addressed to you after it (a repost, a cancel, a wake, an answer, posted guidance), at most 32 with `more` set when there were more, plus `newest_event_id`. The server keeps no cursor: omit it, or pass 0, for everything addressed so far. */
+    seen_through?: number;
+};
+/**
+ * `work_order.progress` result (v1).
+ *
+ * What `work_order.progress` answers on success (ADR-143 D4), generated from `workorder.ProgressResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/progress.result.json
+ */
+export type WorkOrderProgressResult = {
+    id: string;
+    state: string;
+    take: {
+        principal: string;
+        taken_at: string;
+        last_progress_at?: string;
+        describe?: string;
+        caller_is_person?: boolean;
+        outcome_provenance?: string;
+    } | null;
+    addressed_events: {
+        id: number;
+        kind: string;
+        timestamp: string;
+        to_state?: string;
+        reason?: string;
+        /** Who caused the event, as the event log recorded it. The shape written is an EventActor; a row written before a field existed lacks that key. */
+        actor?: unknown;
+        /** The event's payload, whose shape its kind decides, as the event log recorded it. */
+        payload?: unknown;
+        /** True when the event concerns the take this reply is about — your current take; on a refusal, your take that ended; on a repost, the take it ended. False is an earlier take's history, not an instruction to you. */
+        your_take: boolean;
+    }[] | null;
+    more: boolean;
+    newest_event_id: number;
+    warnings?: string[];
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/recall.params.json
+ */
+export type WorkOrderRecallParams = {
+    /** The Work Orders to recall, as bare ids. Recalled ATOMICALLY: all of them or none. Each must be released and never dispatched — `scheduled` or `blocked:*`, with no attempt behind it. Naming one twice is the same act said twice and is absorbed. */
+    ids: string[];
+    /** Why these are being recalled. Required, and recorded on every recall transition: a parent waiting on a child, or a reviewer who released it, reads this. */
+    reason: string;
+};
+/**
+ * `work_order.recall` result (v1).
+ *
+ * What `work_order.recall` answers on success (ADR-143 D4), generated from `workorder.RecallResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/recall.result.json
+ */
+export type WorkOrderRecallResult = {
+    recalled: {
+        id: string;
+        state: string;
+        from: string;
+        type: string;
+        title?: string;
+    }[] | null;
+    count: number;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/refile.params.json
+ */
+export type WorkOrderRefileParams = {
+    /** Which input key carries the prose brief, and therefore where the "what changed" block is seeded. Defaults to `task`, the key every direct type in the system-vault seed uses for the instruction a session reads. State it for a type that spells it differently. A key holding no string is refused rather than skipped — the block has to land where the dispatched session reads it. */
+    brief_input?: string;
+    /** Short note recorded on the `supersedes` edge. */
+    note?: string;
+    /** The Work Order this one replaces. Must be in `failed:awaiting-ack`: that is the one state with a retry door open, and closing that door is what a supersession is for. A still-running Work Order is refused with force-fail named as the door; a terminal one is refused because there is nothing to close. */
+    predecessor: string;
+    /** Override the copied title. Omit to keep the predecessor's, which is usually right: it is the same work, and a successor whose title no longer matches is harder to find beside it. */
+    title?: string;
+    /** Override the copied worker. State it when the predecessor died for a reason attached to its worker — a depleted tier, a host that went quiet. */
+    worker?: string;
+};
+/**
+ * `work_order.refile` result (v1).
+ *
+ * What `work_order.refile` answers on success (ADR-143 D4), generated from `workorder.RefileResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/refile.result.json
+ */
+export type WorkOrderRefileResult = {
+    id: string;
+    state: string;
+    type: string;
+    worker: string;
+    title?: string;
+    predecessor: string;
+    brief_input: string;
+    what_changed_filled: boolean;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/relate.params.json
+ */
+export type WorkOrderRelateParams = {
+    /** `add` asserts the edge, `remove` withdraws it. Required, with no default: the two are not the same act, and a default would make the choice by absence. */
+    action: "add" | "remove";
+    /** The Work Order that CARRIES the edge — the one that supersedes, that is a duplicate, that is about something. Required: this verb is stated about a relationship between two Work Orders by someone who is neither, so there is no dispatch context to take an id from. */
+    id: string;
+    /** Optional free text recorded on the edge, at most 256 bytes. Ignored on `remove`. Re-asserting an existing triple does NOT update the note — that is what makes re-assertion idempotent; change one by removing the edge and adding it again. */
+    note?: string;
+    /** What this Work Order claims about the target. about (this Work Order's work is examining or acting on that one), duplicate_of (this should not exist; that one is the real work), related (see-also, carrying no lifecycle implication), supersedes (this replaces that one; that one should not be retried). Deliberately absent: `retry_of` (the retry machinery already records attempts against a single Work Order) and anything blocking-shaped (that is `depends_on`, which is causal and gates dispatch). Required on `remove` too — the triple (id, relation, target_id) is the edge's identity, and there are no edge ids. */
+    relation: "about" | "duplicate_of" | "related" | "supersedes";
+    /** The Work Order the claim is about, as a bare id. Must exist. Whether the caller also needs REACH on it follows what the relation asserts. `supersedes` and `duplicate_of` are evaluative — because the inverse direction is the primary read, they change what the TARGET's own work_order.get says about how to treat it — so those require reach on the target, as every relation does on `id`. `about` and `related` assert nothing about the target's status and require none, which is what lets a Work Order record that it is examining another worker's work. */
+    target_id: string;
+};
+/**
+ * `work_order.relate` result (v1).
+ *
+ * What `work_order.relate` answers on success (ADR-143 D4), generated from `workorder.RelateResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/relate.result.json
+ */
+export type WorkOrderRelateResult = {
+    id: string;
+    action: string;
+    relation: string;
+    target_id: string;
+    note?: string;
+    applied: boolean;
+    outcome: string;
+    relations: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    related_by: {
+        relation: string;
+        work_order_id: string;
+        note?: string;
+        created_at: string;
+        created_by?: string;
+    }[] | null;
+    relation_scope?: {
+        withheld_relations?: number;
+        withheld_related_by?: number;
+        note: string;
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/release.params.json
+ */
+export type WorkOrderReleaseParams = {
+    /** The Work Orders to release, as bare ids. Released ATOMICALLY: all of them or none. Each must be in `draft` — a named id that is not is refused by name, rather than skipped, because you wrote it down. Naming one twice is the same act said twice and is absorbed, not doubled. */
+    ids: string[];
+    /** Short audit note recorded on every transition event in the set. One note for the whole set, because the set is one act — "the breakdown was approved in review" is the fact worth recording. */
+    reason?: string;
+    /** Release every DRAFT beneath each named Work Order as well, at any depth. This is the common spelling for a breakdown, and it is sugar over the same atomic set rather than a second path. It SELECTS drafts: a non-draft node is walked through and not released, which is what lets you name the run that derived a wave — that run is `active`, not a draft. A named root with no draft anywhere beneath it is refused rather than reported as a release of nothing. */
+    subtree?: boolean;
+};
+/**
+ * `work_order.release` result (v1).
+ *
+ * What `work_order.release` answers on success (ADR-143 D4), generated from `workorder.ReleaseResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/release.result.json
+ */
+export type WorkOrderReleaseResult = {
+    released: {
+        id: string;
+        state: string;
+        type: string;
+        title?: string;
+        delegation?: {
+            subject: string;
+            outstanding: string[] | null;
+            unavailable?: {
+                upstream: string;
+                gap: string;
+            }[];
+            withdrawn?: {
+                upstream: string;
+                gap: string;
+            }[];
+            door?: string;
+            walled?: string[];
+            fails_at?: string;
+            checked_at?: string;
+            dispatch_timeout_seconds?: number;
+            failures?: {
+                connection: string;
+                upstream?: string;
+                holder: {
+                    kind: string;
+                    name: string;
+                };
+                reason: string;
+                act_by: string;
+                repair: string;
+                evidence?: string;
+            }[];
+        };
+    }[] | null;
+    count: number;
+    subtree?: boolean;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/repin.params.json
+ */
+export type WorkOrderRepinParams = {
+    /** Report the ADR-105 D8 classification and WRITE NOTHING. The manifest says what a resume under the candidate would do — where it would land, which steps would be passed over with nothing recorded, which recorded results would be re-run, and which would be orphaned — with the verdict derived from it. Unlike the `repin` MODE on the re-entry verbs, this is meaningful on its own: this verb IS the re-pin, so there is nothing else to suppress. */
+    dry_run?: boolean;
+    /** The ONE Work Order to re-pin. There is no `--type`, `--state` or tag selector, by ruling: *never automatic* is this act's defining property, and a loop over ids with one reason keeps every generation individually attributed. */
+    id: string;
+    /** Cross EVERY refusal the re-pin gate raises, including a capability or operation switch, by ending the contract rather than preserving it: every held step binding is settled `superseded` and a FRESH CHAIN GENERATION is opened for the resume, which then selects against the new pin from nothing (ADR-130 D5's "a deliberate new chain gets an explicit new generation"). It is the refusal's own suggested repair — abandon this Work Order and create a new one — WITHOUT losing the Work Order, its train, its workspace, its artifacts or its history. What it does lose is what the run was doing: a `started` binding it supersedes is a dispatch that was running. It does NOT cross a generation/digest inconsistency, which ADR-105 D7 classifies as corruption rather than as a configuration change. A binding at `admitted` or `dispatch_pending` is refused rather than superseded — those states have no edge that settles; let reconciliation republish and cross again. Authorized against `api/v1/workorders/repin/new-chain` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_open_new_chain` names every binding that would be superseded and how far each had got. */
+    new_chain?: boolean;
+    /** Why. REQUIRED: it is stored on the new pin generation, and an empty reason is what a first-dispatch pin carries — it means "nobody chose this". */
+    reason: string;
+    /** Cross ONE refusal: a select site where this Work Order's live step binding is running a candidate the new pin no longer offers (ADR-130 D5, ratified crossable 2026-09-20). The binding row is RETAINED at the same chain generation and the resume RE-SELECTS from the new candidate set, running the candidate loop against live capacity exactly as a first admission would. It does NOT preserve the candidate the run is on — that candidate is gone, which is why the refusal exists. It lifts nothing else: a capability or operation switch at a fixed site has no candidate to re-select, and a withdrawn `yields_turn` offer is frozen for the life of a pinned conversation (ADR-129 D9). Over a site whose candidate IS still offered, or a fixed site, it is a no-op and says so in the manifest rather than refusing. Authorized against `api/v1/workorders/repin/reselect` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_reselect` names the site, the candidate being given up and the set the resume will choose from. */
+    reselect?: boolean;
+};
+/**
+ * `work_order.repin` result (v1).
+ *
+ * What `work_order.repin` answers on success (ADR-143 D4), generated from `workorder.RepinResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/repin.result.json
+ */
+export type WorkOrderRepinResult = {
+    id: string;
+    state: string;
+    applied: boolean;
+    repin: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/repost.params.json
+ */
+export type WorkOrderRepostParams = {
+    /** The taken off-tera Work Order to post again. Required. */
+    id: string;
+    /** Why it is posted again. Recorded on off_tera.reposted, and named to the previous taker whenever it is refused afterwards. At most 4096 bytes. */
+    reason: string;
+    /** The id of the last event you have processed on this Work Order. The response carries the events addressed to you after it (a repost, a cancel, a wake, an answer, posted guidance), at most 32 with `more` set when there were more, plus `newest_event_id`. The server keeps no cursor: omit it, or pass 0, for everything addressed so far. */
+    seen_through?: number;
+};
+/**
+ * `work_order.repost` result (v1).
+ *
+ * What `work_order.repost` answers on success (ADR-143 D4), generated from `workorder.RepostResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/repost.result.json
+ */
+export type WorkOrderRepostResult = {
+    id: string;
+    state: string;
+    mode: string;
+    previous_taker: string;
+    addressed_events: {
+        id: number;
+        kind: string;
+        timestamp: string;
+        to_state?: string;
+        reason?: string;
+        /** Who caused the event, as the event log recorded it. The shape written is an EventActor; a row written before a field existed lacks that key. */
+        actor?: unknown;
+        /** The event's payload, whose shape its kind decides, as the event log recorded it. */
+        payload?: unknown;
+        /** True when the event concerns the take this reply is about — your current take; on a refusal, your take that ended; on a repost, the take it ended. False is an earlier take's history, not an instruction to you. */
+        your_take: boolean;
+    }[] | null;
+    more: boolean;
+    newest_event_id: number;
+    warnings?: string[];
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/retry.params.json
+ */
+export type WorkOrderRetryParams = {
+    /** Go duration ('30s', '5m') overriding the type's retry_backoff step, recorded on next_retry_at for the orchestrator to honour. Accepted only when the Work Order is `active`; retrying a `failed:awaiting-ack` Work Order with a backoff is refused, because nothing enforces it on that path yet. */
+    backoff?: string;
+    /** Report the ADR-105 D8 classification and DO NOTHING ELSE: no generation is minted and the retry does not happen. The manifest says what a resume under the candidate would do — where it would land, which steps would be passed over with nothing recorded, which recorded results would be re-run, and which would be orphaned — with the verdict derived from it. Only meaningful with `repin`; on its own it is refused, since there is nothing else here to preview. */
+    dry_run?: boolean;
+    /** Natural-language guidance for the next attempt; surfaced on the dispatch envelope as retry_hint. */
+    hint?: string;
+    /** Work Order to retry. Optional for the dispatched root recipe — omit it and the id is taken from the dispatch context. */
+    id?: string;
+    /** Cross EVERY refusal the re-pin gate raises, including a capability or operation switch, by ending the contract rather than preserving it: every held step binding is settled `superseded` and a FRESH CHAIN GENERATION is opened for the resume, which then selects against the new pin from nothing (ADR-130 D5's "a deliberate new chain gets an explicit new generation"). It is the refusal's own suggested repair — abandon this Work Order and create a new one — WITHOUT losing the Work Order, its train, its workspace, its artifacts or its history. What it does lose is what the run was doing: a `started` binding it supersedes is a dispatch that was running. It does NOT cross a generation/digest inconsistency, which ADR-105 D7 classifies as corruption rather than as a configuration change. A binding at `admitted` or `dispatch_pending` is refused rather than superseded — those states have no edge that settles; let reconciliation republish and cross again. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/new-chain` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_open_new_chain` names every binding that would be superseded and how far each had got. */
+    new_chain?: boolean;
+    /** Start a fresh harness session instead of resuming the one this Work Order last announced — for a session whose own content is the failure, or one the harness cannot resume. On a retry that re-dispatches it applies to that dispatch; on one that rejoins a running dispatch or collects a finished result it applies to the next dispatch the walk makes. Refused where it could apply to nothing: on the `active` edge (the session making the call is still running; interrupt or force_fail it first), on off-tera work, and beside `dry_run`, which writes nothing. Held on the Work Order's log, so a daemon restart does not lose it. The reply's `session` says what it applied to. */
+    new_session?: boolean;
+    /** Short audit note recorded on the retry event, and — with `repin` — the reason stored on the new pin generation. Required either way, and audit-only — guidance for the next attempt goes in `hint`, which is the field the agent actually reads. */
+    reason: string;
+    /** Rebind this Work Order to the configuration its type resolves to NOW, as a new generation, and then retry (ADR-105 D7). DURABLE: every subsequent attempt uses the new generation, so it is not a one-shot override that the next attempt falls back off. ATTRIBUTED: your principal and your `reason` are stored on the generation, and the generation history is the audit trail of every forced upgrade. It is the ONLY door onto a Work Order whose pinned configuration is fatally flawed — including one whose pin this daemon cannot decode, which is the case it exists for. Authorized against `api/v1/workorders/repin` IN ADDITION to this capability's own resource; worker-class callers are refused by class and no grant restores it. Pass `dry_run` with it first to see what the resume would cross. */
+    repin?: boolean;
+    /** Cross ONE refusal: a select site where this Work Order's live step binding is running a candidate the new pin no longer offers (ADR-130 D5, ratified crossable 2026-09-20). The binding row is RETAINED at the same chain generation and the resume RE-SELECTS from the new candidate set, running the candidate loop against live capacity exactly as a first admission would. It does NOT preserve the candidate the run is on — that candidate is gone, which is why the refusal exists. It lifts nothing else: a capability or operation switch at a fixed site has no candidate to re-select, and a withdrawn `yields_turn` offer is frozen for the life of a pinned conversation (ADR-129 D9). Over a site whose candidate IS still offered, or a fixed site, it is a no-op and says so in the manifest rather than refusing. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/reselect` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_reselect` names the site, the candidate being given up and the set the resume will choose from. */
+    reselect?: boolean;
+};
+/**
+ * `work_order.retry` result (v1).
+ *
+ * What `work_order.retry` answers on success (ADR-143 D4), generated from the arms of its result union; a value is exactly one of them. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/retry.result.json
+ */
+export type WorkOrderRetryResult = {
+    id: string;
+    state: string;
+    attempt: number;
+    max: number;
+    hint?: string;
+    next_retry_at?: string;
+    repin?: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+    chain?: {
+        inherits_generation: number;
+        generation: number;
+    };
+    binding?: {
+        released: number;
+        dispatch_id?: string;
+        runner?: string;
+        note: string;
+    };
+    runner_hold?: {
+        absence?: {
+            reported_at: string;
+            session_id: string;
+            link_version: number;
+        };
+        runner: string;
+        pool?: string;
+        linked: boolean;
+        superseded_attempt: number;
+        workspace_retired: boolean;
+        workspace_pinned: boolean;
+        held_seats: {
+            pool?: string;
+            member?: string;
+            runner?: string;
+            attempt: number;
+        }[] | null;
+        seats_tracked: boolean;
+        note: string;
+    };
+    arm?: string;
+    session?: {
+        resumed: boolean;
+        fate: string;
+        sessions?: {
+            session_scope: string;
+            session_id?: string;
+            fresh?: boolean;
+        }[];
+        new_session?: {
+            applied: boolean;
+            to: string;
+            note: string;
+        };
+        note: string;
+    };
+} | {
+    id: string;
+    state: string;
+    verb: string;
+    applied: boolean;
+    repin: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/submit_result.params.json
+ */
+export type WorkOrderSubmitResultParams = {
+    /** The off-tera Work Order you hold. Required. */
+    id: string;
+    /** Your result declaration (ADR-099): `status` `complete` or `failed`, a `summary`, and whatever the type's output_schema requires. Graded against the schema this Work Order was pinned to; a violation is refused with its pointer and changes nothing. `paused` with a `reason` parks it, still yours: `awaiting-input` with a `question`, or a `predicate` to wait on your children (`awaiting-children`) or on named Work Orders (`awaiting-event`, kind `these-work-orders`); a wake makes it active again. A reason the type cannot park on is refused and changes nothing. */
+    record: {
+        [key: string]: unknown;
+    };
+    /** The id of the last event you have processed on this Work Order. The response carries the events addressed to you after it (a repost, a cancel, a wake, an answer, posted guidance), at most 32 with `more` set when there were more, plus `newest_event_id`. The server keeps no cursor: omit it, or pass 0, for everything addressed so far. */
+    seen_through?: number;
+};
+/**
+ * `work_order.submit_result` result (v1).
+ *
+ * What `work_order.submit_result` answers on success (ADR-143 D4), generated from `workorder.SubmitResultResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/submit_result.result.json
+ */
+export type WorkOrderSubmitResultResult = {
+    id: string;
+    state: string;
+    status: string;
+    outcome?: {
+        outcome_provenance: string;
+        attested_by?: string;
+    };
+    checks?: string;
+    addressed_events: {
+        id: number;
+        kind: string;
+        timestamp: string;
+        to_state?: string;
+        reason?: string;
+        /** Who caused the event, as the event log recorded it. The shape written is an EventActor; a row written before a field existed lacks that key. */
+        actor?: unknown;
+        /** The event's payload, whose shape its kind decides, as the event log recorded it. */
+        payload?: unknown;
+        /** True when the event concerns the take this reply is about — your current take; on a refusal, your take that ended; on a repost, the take it ended. False is an earlier take's history, not an instruction to you. */
+        your_take: boolean;
+    }[] | null;
+    more: boolean;
+    newest_event_id: number;
+    warnings?: string[];
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/take.params.json
+ */
+export type WorkOrderTakeParams = {
+    /** Your own statement of where the work will be done — host, tool or session. Recorded as given and shown as given; tera never verifies, parses or keys on it. At most 1024 bytes. */
+    describe?: string;
+    /** The off-tera Work Order to take. Required — a take is made from outside any dispatch, so there is no dispatch context to take an id from. */
+    id: string;
+};
+/**
+ * `work_order.take` result (v1).
+ *
+ * What `work_order.take` answers on success (ADR-143 D4), generated from `workorder.TakeResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/take.result.json
+ */
+export type WorkOrderTakeResult = {
+    id: string;
+    type: string;
+    state: string;
+    take: {
+        principal: string;
+        taken_at: string;
+        last_progress_at?: string;
+        describe?: string;
+        caller_is_person?: boolean;
+        outcome_provenance?: string;
+    } | null;
+    instructions: string;
+    requirements?: string;
+    /** The Work Order's inputs, verbatim, in the shape its type's input_schema declares. */
+    inputs?: unknown;
+    attachments: {
+        handle: string;
+        filename: string;
+        mime_type?: string;
+        size_bytes: number;
+        description?: string;
+    }[] | null;
+    addressed_events: {
+        id: number;
+        kind: string;
+        timestamp: string;
+        to_state?: string;
+        reason?: string;
+        /** Who caused the event, as the event log recorded it. The shape written is an EventActor; a row written before a field existed lacks that key. */
+        actor?: unknown;
+        /** The event's payload, whose shape its kind decides, as the event log recorded it. */
+        payload?: unknown;
+        /** True when the event concerns the take this reply is about — your current take; on a refusal, your take that ended; on a repost, the take it ended. False is an earlier take's history, not an instruction to you. */
+        your_take: boolean;
+    }[] | null;
+    more: boolean;
+    newest_event_id: number;
+    warnings?: string[];
+    /** The JSON Schema this Work Order was pinned to at its first take, which submit_result grades the record against. Absent when the type declares none. */
+    output_schema?: unknown;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/transition.params.json
+ */
+export type WorkOrderTransitionParams = {
+    /** The externally-driven input to fire. The review actions (approve / reject / rework) are accepted only from `paused:awaiting-review`; `answer` only from `paused:awaiting-input` or `paused:awaiting-interactive-turn`. `wake` is the NON-DESTRUCTIVE door into a parked run: it makes the run's wait condition true and lets the ordinary paused → active machinery run, without re-dispatching, resurrecting or re-pinning anything. It is accepted from every paused state EXCEPT `paused:awaiting-review`, whose doors are approve / reject / rework because that park exists so a verdict is RECORDED, and `paused:interrupted`, whose one way out is work_order.guide(id, verb = "deliver") because the run was interrupted to be given a new instruction. It does NOT make the thing the run was waiting for happen: from `paused:awaiting-input` the run is told plainly that no answer was given, and from `paused:awaiting-capacity` / `paused:awaiting-credential` it means "proceed without it", so work needing that resource may fail immediately — that is the operator's call. From `paused:awaiting-upstream` it is sharper still: the backoff has NOT elapsed by construction, so the upstream that refused is very likely still refusing and the run may take the identical refusal at once. From `paused:plugin-contract-moved` it resumes the run on its OLD pin, so its next call to the plugin whose contract moved parks it again: that park's door is `work_order.repin`, which re-pins the run onto the installed contract version and resumes it. Authorized against api/v1/workorders/wake, which the transition grant does NOT imply, and `reason` is REQUIRED on it. For a Work Order that is terminal or merely stuck rather than parked, the road is work_order.force_fail then work_order.retry. `conclude` (ADR-129 D10) is the OPERATOR'S ENDING for an interactive conversation, accepted from `paused:awaiting-interactive-turn` and from NOTHING ELSE: it settles the run at the success terminal (`complete`) whatever the conversation decided, carrying an OPTIONAL `note`. An interactive dispatch has no ending of its own — its one exit is the turn boundary — so this is how the run ends, and there is no resume after it. A run mid-turn is INTERRUPTED first (work_order.guide(id, verb = "interrupt")), which lands it back at its inbox; a conclude arriving at an `active` row is refused and says so. Its children keep running to their own ends. Its optional note goes on `note`, NOT on `reason` — a conclude carrying `reason` is REFUSED rather than silently dropping your words, because unlike `wake` nothing here reaches the run. Authorized against api/v1/workorders/conclude, which the transition grant does NOT imply. */
+    action: "answer" | "approve" | "reject" | "rework" | "cancel" | "retry" | "wake" | "conclude";
+    /** Files to hand this Work Order, each named by the HANDLE its upload minted — `tera artifacts upload <file> --description "…"` mints one in a single command, or over the API `POST /api/v1/artifacts/uploads/authorize` starts an upload and completing it mints the handle. A DISPATCHED RUN uses neither door — a worker-class caller is refused both — and attaches only a handle it has ALREADY PUBLISHED into this same train, which costs nothing and is not a re-upload. ATTACHMENTS CARRY A HANDLE AND NEVER FILE CONTENT, at any size: there is no inline, base64 or small-file form of this field on any surface, so upload first and pass the reference. You do not describe the file here — its filename, declared content type, size, digest and the uploader's description come from the upload itself, so what a later reader sees is what was actually uploaded rather than what the create said about it. An attach CONSUMES the artifact into this one Work Order's train: it leaves your staged account, the same handle keeps working, and it cannot be attached to a second Work Order — upload the file again for that. A handle you have not attached within 24 hours of uploading it is collected; attaching to a `draft` stops that clock for as long as the draft lives, and discarding the draft hands the file back to you with a fresh 24 hours rather than deleting it. Every unattachable handle answers the same way — never uploaded, already attached, expired, or somebody else's are one refusal, because telling them apart would say whether another principal's handle exists; `tera artifacts list --staged` lists what is actually yours (`GET /api/v1/artifacts/staged` over the API). A run has no staging account to list, and the handle it should be passing is one of its own outputs in this train. Inputs get their own byte allowance (64 MiB per Work Order) and never spend the separate allowance a run uses to publish artifacts about its own work. */
+    attachments?: {
+        /** The artifact handle the upload minted. Opaque: it carries no filename and no path, and nothing about it is constructible. */
+        handle: string;
+    }[];
+    /** Report the ADR-105 D8 classification and DO NOTHING ELSE: no generation is minted and the transition does not happen. The manifest says what a resume under the candidate would do — where it would land, which steps would be passed over with nothing recorded, which recorded results would be re-run, and which would be orphaned — with the verdict derived from it. Only meaningful with `repin`; on its own it is refused, since there is nothing else here to preview. */
+    dry_run?: boolean;
+    /** Work Order to drive. */
+    id: string;
+    /** action=answer only: interactive answer retry identity. */
+    input_key?: string;
+    /** Cross EVERY refusal the re-pin gate raises, including a capability or operation switch, by ending the contract rather than preserving it: every held step binding is settled `superseded` and a FRESH CHAIN GENERATION is opened for the resume, which then selects against the new pin from nothing (ADR-130 D5's "a deliberate new chain gets an explicit new generation"). It is the refusal's own suggested repair — abandon this Work Order and create a new one — WITHOUT losing the Work Order, its train, its workspace, its artifacts or its history. What it does lose is what the run was doing: a `started` binding it supersedes is a dispatch that was running. It does NOT cross a generation/digest inconsistency, which ADR-105 D7 classifies as corruption rather than as a configuration change. A binding at `admitted` or `dispatch_pending` is refused rather than superseded — those states have no edge that settles; let reconciliation republish and cross again. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/new-chain` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_open_new_chain` names every binding that would be superseded and how far each had got. */
+    new_chain?: boolean;
+    /** action=rework: commentary injected into the resumed agent's context as guard_failure_note. action=conclude: the operator's OPTIONAL note on why the conversation ended, recorded on the transition's event-log row — it reaches nobody, because a concluded run does not run again. Read on those two actions and on no other. */
+    note?: string;
+    /** action=answer only: structured answer; takes precedence over text. */
+    payload?: unknown;
+    /** Short audit note recorded on the resulting event. Read as the rejection reason on action=reject (default: "review rejected") and as the cancellation reason on action=cancel, and — with `repin` — as the reason stored on the new pin generation, where it is REQUIRED. It is an audit line, not guidance — nothing reaches the agent through it. NOT ACCEPTED on action=conclude, which carries its operator note on `note` and refuses this field by name rather than dropping it. THE ONE EXCEPTION IS action=wake, where it is REQUIRED and DOES reach the run: it rides the wake payload, because a run woken with no explanation cannot act sensibly on having been woken. Even there it is PROVENANCE and not an instruction — it says why the wait was ended, the way a timeout wake says which bound elapsed. To instruct a run, use work_order.retry's `hint`, a rework `note`, or an answer. */
+    reason?: string;
+    /** Rebind this Work Order to the configuration its type resolves to NOW, as a new generation, and then transition (ADR-105 D7). DURABLE: every subsequent attempt uses the new generation, so it is not a one-shot override that the next attempt falls back off. ATTRIBUTED: your principal and your `reason` are stored on the generation, and the generation history is the audit trail of every forced upgrade. It is the ONLY door onto a Work Order whose pinned configuration is fatally flawed — including one whose pin this daemon cannot decode, which is the case it exists for. Authorized against `api/v1/workorders/repin` IN ADDITION to this capability's own resource; worker-class callers are refused by class and no grant restores it. Pass `dry_run` with it first to see what the resume would cross. */
+    repin?: boolean;
+    /** action=answer only: replace a definitely unsent held answer. */
+    replace?: boolean;
+    /** Cross ONE refusal: a select site where this Work Order's live step binding is running a candidate the new pin no longer offers (ADR-130 D5, ratified crossable 2026-09-20). The binding row is RETAINED at the same chain generation and the resume RE-SELECTS from the new candidate set, running the candidate loop against live capacity exactly as a first admission would. It does NOT preserve the candidate the run is on — that candidate is gone, which is why the refusal exists. It lifts nothing else: a capability or operation switch at a fixed site has no candidate to re-select, and a withdrawn `yields_turn` offer is frozen for the life of a pinned conversation (ADR-129 D9). Over a site whose candidate IS still offered, or a fixed site, it is a no-op and says so in the manifest rather than refusing. Only meaningful with `repin`. Authorized against `api/v1/workorders/repin/reselect` IN ADDITION to `api/v1/workorders/repin`. Pass `dry_run` first: the manifest's `would_reselect` names the site, the candidate being given up and the set the resume will choose from. */
+    reselect?: boolean;
+    /** action=answer only: the operator's answer text. Read work_order.get(id).question first — that is what is being asked. */
+    text?: string;
+};
+/**
+ * `work_order.transition` result (v1).
+ *
+ * What `work_order.transition` answers on success (ADR-143 D4), generated from the arms of its result union; a value is exactly one of them. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/transition.result.json
+ */
+export type WorkOrderTransitionResult = {
+    id: string;
+    state: string;
+    action: string;
+    trigger: string;
+    repin?: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+    disposition?: string;
+    runner?: string;
+    detail?: string;
+} | {
+    id: string;
+    state: string;
+    verb: string;
+    applied: boolean;
+    repin: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+} | {
+    resume_error?: string;
+    input?: {
+        message: {
+            kind?: string;
+            question_at?: string;
+            input_id?: string;
+            input_sequence?: number;
+            caller?: string;
+            /** Platform-attested provenance as recorded by the dispatching host; its actor schema belongs to that host. */
+            actor?: unknown;
+            issued_at?: string;
+            text: string;
+            attachments?: {
+                handle: string;
+                filename: string;
+                mime_type: string;
+                size: number;
+                description?: string;
+            }[];
+        };
+        state: string;
+        attempt?: {
+            id: string;
+            invocation_id: string;
+            dispatch_id: string;
+            observations?: {
+                observed_at: string;
+                state: string;
+                evidence: string;
+            }[];
+        };
+        resolution?: string;
+    };
+    input_barrier?: {
+        input_id: string;
+        input_sequence: number;
+        attempt_id?: string;
+        state: string;
+        reconciliation: string;
+        behind: number;
+        recovery: string;
+    };
+    id: string;
+    state: string;
+    delivered: boolean;
+    delivery: string;
+    resumed_parked_run: boolean;
+    outcome: string;
+    repin?: {
+        minted: boolean;
+        dry_run: boolean;
+        generation?: number;
+        config_digest?: string;
+        previous_state?: string;
+        previous_generation?: number;
+        classification: {
+            verdict: string;
+            caveat: string;
+            cause?: string;
+            manifest?: {
+                parked_step: string;
+                lands: boolean;
+                landing?: number;
+                absent?: {
+                    name: string;
+                    index: number;
+                    cause: string;
+                }[];
+                rerun?: string[];
+                orphaned?: string[];
+                digests_agree: boolean;
+                sessions?: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    outcome: string;
+                    reason: string;
+                }[];
+            };
+            warnings?: {
+                kind: string;
+                steps?: string[];
+            }[];
+        };
+        crossings?: {
+            would_reselect?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            would_open_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+            reselected?: {
+                site: string;
+                logical_site_id?: string;
+                structural_path?: string;
+                from_candidate: string;
+                offered?: string[];
+            }[];
+            opened_new_chain?: {
+                superseded: {
+                    site: string;
+                    logical_site_id?: string;
+                    structural_path?: string;
+                    chain_generation: number;
+                    state: string;
+                    candidate?: string;
+                }[] | null;
+                generation?: number;
+            };
+        };
+    };
+} | {
+    id: string;
+    state: string;
+    cancel_requested: boolean;
+    cancelled: boolean;
+    requested_at: string;
+    upstream: string;
+};
+/**
+ *
+ * Schema: sdk/workorder/schema/v1/tree.params.json
+ */
+export type WorkOrderTreeParams = {
+    /** Root of the train — any Work Order, not necessarily a top-level one. Every `paused:awaiting-input` node in the result carries its outstanding question inline as `question.text`, and every paused node carries `waiting_on` — the door that would reopen it, plus `waiting_on.refusal` when this run's resume is being refused, which is what is holding it instead of that door. */
+    id: string;
+    /** Maximum descendants to return. 0 or absent means the default; values above the maximum are clamped. */
+    limit?: number;
+    /** Generations below the root to walk. 0 or absent means the default; values above the maximum are clamped and reported as a truncation. */
+    max_depth?: number;
+    /** Return only descendants in any of these states, matched exactly as `work_order.list`'s `states` is. Absent or empty returns every descendant. Filters what is returned, never what is walked: a matching node beneath a non-matching one is still found. The root is always returned whatever its state; `counts`, `total` and `limit` count the returned descendants. */
+    states?: string[];
+};
+/**
+ * `work_order.tree` result (v1).
+ *
+ * What `work_order.tree` answers on success (ADR-143 D4), generated from `workorder.TreeResult`. A refusal is not this document: it is the invocation's `error` envelope.
+ *
+ * Schema: sdk/workorder/schema/v1/tree.result.json
+ */
+export type WorkOrderTreeResult = {
+    root: {
+        context_compactions?: {
+            state: string;
+            count: number | null;
+            latest_at?: string;
+        };
+        id: string;
+        parent_id?: string;
+        depth: number;
+        worker: string;
+        type: string;
+        state: string;
+        title?: string;
+        cohort_id: string;
+        depends_on?: string[];
+        tags: string[] | null;
+        priority: number;
+        block_reason?: {
+            kind: string;
+            detail?: unknown;
+        };
+        deferred_until?: string;
+        question?: {
+            text?: string;
+            /** The asker's structured evidence, or the whole pause context when it is not in the asking shape: its shape is the asker's. */
+            context?: unknown;
+            description?: string;
+        };
+        waiting_on?: {
+            pause_kind: string;
+            predicate_kind?: string;
+            resume: string;
+            inert_predicate?: boolean;
+            unsatisfiable?: boolean;
+            held_answer?: boolean;
+            refusal?: {
+                cause: string;
+                member?: string;
+                pool?: string;
+                pool_cause?: string;
+                verb?: string;
+                repairable: boolean;
+                refused_at?: string;
+                clears?: string;
+            };
+            input_barrier?: {
+                input_id: string;
+                input_sequence: number;
+                attempt_id?: string;
+                state: string;
+                reconciliation: string;
+                behind: number;
+                recovery: string;
+            };
+        };
+        delegation?: {
+            subject: string;
+            outstanding: string[] | null;
+            unavailable?: {
+                upstream: string;
+                gap: string;
+            }[];
+            withdrawn?: {
+                upstream: string;
+                gap: string;
+            }[];
+            door?: string;
+            walled?: string[];
+            fails_at?: string;
+            checked_at?: string;
+            dispatch_timeout_seconds?: number;
+            failures?: {
+                connection: string;
+                upstream?: string;
+                holder: {
+                    kind: string;
+                    name: string;
+                };
+                reason: string;
+                act_by: string;
+                repair: string;
+                evidence?: string;
+            }[];
+        };
+        could_not_decide?: {
+            kind: string;
+            detail?: string;
+        };
+        upstream_sync?: {
+            last_synced_at?: string;
+            reachability?: string;
+            unreachable_since?: string;
+            detail?: string;
+        };
+        outcome?: {
+            outcome_provenance: string;
+            attested_by?: string;
+        };
+        replaced?: {
+            relation: string;
+            work_order_id: string;
+            note?: string;
+            created_at: string;
+            created_by?: string;
+        }[];
+        validity?: {
+            valid: boolean;
+            reason?: string;
+            field?: string;
+        };
+        selection?: {
+            state: string;
+            cause?: string;
+            refusal?: string;
+            refusal_cause?: string;
+            pin_schema_version?: number;
+            sites?: {
+                state: string;
+                logical_site_id: string;
+                path?: string;
+                step?: string;
+                selectable: boolean;
+                policy?: {
+                    mode: string;
+                    candidate?: string;
+                    order?: string[];
+                };
+                interaction?: string;
+                interactive_request?: boolean;
+                yields_turn_offer?: boolean;
+                offer_contradiction?: boolean;
+                workflow_instance_id?: string;
+                chain_generation?: number;
+                binding_state?: string;
+                revision?: number;
+                admission_revision?: number;
+                pin_generation?: number;
+                pin_digest?: string;
+                site_definition_digest?: string;
+                selection_mode?: string;
+                selection_reason?: string;
+                requested?: {
+                    candidate: string;
+                };
+                selected?: {
+                    candidate?: string;
+                    capability_type?: string;
+                    capability?: string;
+                    operation?: string;
+                    effective_config_digest?: string;
+                    native_input_digest?: string;
+                    profile_digest?: string;
+                };
+                admitted?: {
+                    revision: number;
+                    dispatch_id?: string;
+                    draws?: {
+                        provenance: string;
+                        pool: string;
+                        member?: string;
+                    }[];
+                    draws_unreadable?: boolean;
+                };
+                accepted?: {
+                    dispatch_document_digest?: string;
+                    receipt: boolean;
+                };
+                started?: {
+                    at: string;
+                };
+                settled?: {
+                    kind?: string;
+                    digest?: string;
+                    at?: string;
+                };
+                wait?: {
+                    fingerprint?: string;
+                    decisions?: {
+                        candidate?: string;
+                        class?: string;
+                        reason?: string;
+                        detail?: string;
+                        terminal?: boolean;
+                    }[];
+                    dependencies?: {
+                        candidate?: string;
+                        kind?: string;
+                        id?: string;
+                        deadline?: string;
+                    }[];
+                    earliest_deadline?: string;
+                    unreadable?: boolean;
+                };
+                attempt_digest?: string;
+                model_policy?: {
+                    profile_id?: string;
+                    profile_version?: number;
+                    requested_tier?: string;
+                    requested_model?: string;
+                    requested_effort?: string;
+                    resolved_tier?: string;
+                    resolved_model?: string;
+                    resolved_effort?: string;
+                    table_source?: string;
+                    table_revision?: string;
+                    reported_state: string;
+                    reported_model?: string;
+                    reported_effort?: string;
+                };
+                refusal?: string;
+                refusal_cause?: string;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+        };
+        relation_scope?: {
+            withheld_relations?: number;
+            withheld_related_by?: number;
+            note: string;
+        };
+        created_at: string;
+        updated_at: string;
+        archived: boolean;
+    };
+    descendants: {
+        context_compactions?: {
+            state: string;
+            count: number | null;
+            latest_at?: string;
+        };
+        id: string;
+        parent_id?: string;
+        depth: number;
+        worker: string;
+        type: string;
+        state: string;
+        title?: string;
+        cohort_id: string;
+        depends_on?: string[];
+        tags: string[] | null;
+        priority: number;
+        block_reason?: {
+            kind: string;
+            detail?: unknown;
+        };
+        deferred_until?: string;
+        question?: {
+            text?: string;
+            /** The asker's structured evidence, or the whole pause context when it is not in the asking shape: its shape is the asker's. */
+            context?: unknown;
+            description?: string;
+        };
+        waiting_on?: {
+            pause_kind: string;
+            predicate_kind?: string;
+            resume: string;
+            inert_predicate?: boolean;
+            unsatisfiable?: boolean;
+            held_answer?: boolean;
+            refusal?: {
+                cause: string;
+                member?: string;
+                pool?: string;
+                pool_cause?: string;
+                verb?: string;
+                repairable: boolean;
+                refused_at?: string;
+                clears?: string;
+            };
+            input_barrier?: {
+                input_id: string;
+                input_sequence: number;
+                attempt_id?: string;
+                state: string;
+                reconciliation: string;
+                behind: number;
+                recovery: string;
+            };
+        };
+        delegation?: {
+            subject: string;
+            outstanding: string[] | null;
+            unavailable?: {
+                upstream: string;
+                gap: string;
+            }[];
+            withdrawn?: {
+                upstream: string;
+                gap: string;
+            }[];
+            door?: string;
+            walled?: string[];
+            fails_at?: string;
+            checked_at?: string;
+            dispatch_timeout_seconds?: number;
+            failures?: {
+                connection: string;
+                upstream?: string;
+                holder: {
+                    kind: string;
+                    name: string;
+                };
+                reason: string;
+                act_by: string;
+                repair: string;
+                evidence?: string;
+            }[];
+        };
+        could_not_decide?: {
+            kind: string;
+            detail?: string;
+        };
+        upstream_sync?: {
+            last_synced_at?: string;
+            reachability?: string;
+            unreachable_since?: string;
+            detail?: string;
+        };
+        outcome?: {
+            outcome_provenance: string;
+            attested_by?: string;
+        };
+        replaced?: {
+            relation: string;
+            work_order_id: string;
+            note?: string;
+            created_at: string;
+            created_by?: string;
+        }[];
+        validity?: {
+            valid: boolean;
+            reason?: string;
+            field?: string;
+        };
+        selection?: {
+            state: string;
+            cause?: string;
+            refusal?: string;
+            refusal_cause?: string;
+            pin_schema_version?: number;
+            sites?: {
+                state: string;
+                logical_site_id: string;
+                path?: string;
+                step?: string;
+                selectable: boolean;
+                policy?: {
+                    mode: string;
+                    candidate?: string;
+                    order?: string[];
+                };
+                interaction?: string;
+                interactive_request?: boolean;
+                yields_turn_offer?: boolean;
+                offer_contradiction?: boolean;
+                workflow_instance_id?: string;
+                chain_generation?: number;
+                binding_state?: string;
+                revision?: number;
+                admission_revision?: number;
+                pin_generation?: number;
+                pin_digest?: string;
+                site_definition_digest?: string;
+                selection_mode?: string;
+                selection_reason?: string;
+                requested?: {
+                    candidate: string;
+                };
+                selected?: {
+                    candidate?: string;
+                    capability_type?: string;
+                    capability?: string;
+                    operation?: string;
+                    effective_config_digest?: string;
+                    native_input_digest?: string;
+                    profile_digest?: string;
+                };
+                admitted?: {
+                    revision: number;
+                    dispatch_id?: string;
+                    draws?: {
+                        provenance: string;
+                        pool: string;
+                        member?: string;
+                    }[];
+                    draws_unreadable?: boolean;
+                };
+                accepted?: {
+                    dispatch_document_digest?: string;
+                    receipt: boolean;
+                };
+                started?: {
+                    at: string;
+                };
+                settled?: {
+                    kind?: string;
+                    digest?: string;
+                    at?: string;
+                };
+                wait?: {
+                    fingerprint?: string;
+                    decisions?: {
+                        candidate?: string;
+                        class?: string;
+                        reason?: string;
+                        detail?: string;
+                        terminal?: boolean;
+                    }[];
+                    dependencies?: {
+                        candidate?: string;
+                        kind?: string;
+                        id?: string;
+                        deadline?: string;
+                    }[];
+                    earliest_deadline?: string;
+                    unreadable?: boolean;
+                };
+                attempt_digest?: string;
+                model_policy?: {
+                    profile_id?: string;
+                    profile_version?: number;
+                    requested_tier?: string;
+                    requested_model?: string;
+                    requested_effort?: string;
+                    resolved_tier?: string;
+                    resolved_model?: string;
+                    resolved_effort?: string;
+                    table_source?: string;
+                    table_revision?: string;
+                    reported_state: string;
+                    reported_model?: string;
+                    reported_effort?: string;
+                };
+                refusal?: string;
+                refusal_cause?: string;
+                created_at?: string;
+                updated_at?: string;
+            }[];
+        };
+        relation_scope?: {
+            withheld_relations?: number;
+            withheld_related_by?: number;
+            note: string;
+        };
+        created_at: string;
+        updated_at: string;
+        archived: boolean;
+    }[] | null;
+    counts: {
+        [key: string]: number;
+    } | null;
+    total: number;
+    truncated?: boolean;
+    truncated_by?: string;
+};
+/**
+ * Every type this module declares, mapped to the repository path of the schema
+ * it was generated from.
+ */
+export declare const WORK_ORDER_SCHEMAS: {
+    readonly WorkOrderAcknowledgeParams: "sdk/workorder/schema/v1/acknowledge.params.json";
+    readonly WorkOrderAcknowledgeResult: "sdk/workorder/schema/v1/acknowledge.result.json";
+    readonly WorkOrderAnswerParams: "sdk/workorder/schema/v1/answer.params.json";
+    readonly WorkOrderAnswerResult: "sdk/workorder/schema/v1/answer.result.json";
+    readonly WorkOrderCancelParams: "sdk/workorder/schema/v1/cancel.params.json";
+    readonly WorkOrderCancelResult: "sdk/workorder/schema/v1/cancel.result.json";
+    readonly WorkOrderCohortSetParams: "sdk/workorder/schema/v1/cohort_set.params.json";
+    readonly WorkOrderCohortSetResult: "sdk/workorder/schema/v1/cohort_set.result.json";
+    readonly WorkOrderCompleteParams: "sdk/workorder/schema/v1/complete.params.json";
+    readonly WorkOrderCompleteResult: "sdk/workorder/schema/v1/complete.result.json";
+    readonly WorkOrderCreateParams: "sdk/workorder/schema/v1/create.params.json";
+    readonly WorkOrderCreateResult: "sdk/workorder/schema/v1/create.result.json";
+    readonly WorkOrderCreateChildParams: "sdk/workorder/schema/v1/create_child.params.json";
+    readonly WorkOrderCreateChildResult: "sdk/workorder/schema/v1/create_child.result.json";
+    readonly WorkOrderEditParams: "sdk/workorder/schema/v1/edit.params.json";
+    readonly WorkOrderEditResult: "sdk/workorder/schema/v1/edit.result.json";
+    readonly WorkOrderEventsParams: "sdk/workorder/schema/v1/events.params.json";
+    readonly WorkOrderEventsResult: "sdk/workorder/schema/v1/events.result.json";
+    readonly WorkOrderFailParams: "sdk/workorder/schema/v1/fail.params.json";
+    readonly WorkOrderFailResult: "sdk/workorder/schema/v1/fail.result.json";
+    readonly WorkOrderForceFailParams: "sdk/workorder/schema/v1/force_fail.params.json";
+    readonly WorkOrderForceFailResult: "sdk/workorder/schema/v1/force_fail.result.json";
+    readonly WorkOrderGetParams: "sdk/workorder/schema/v1/get.params.json";
+    readonly WorkOrderGetResult: "sdk/workorder/schema/v1/get.result.json";
+    readonly WorkOrderGuideParams: "sdk/workorder/schema/v1/guide.params.json";
+    readonly WorkOrderGuideResult: "sdk/workorder/schema/v1/guide.result.json";
+    readonly WorkOrderHistoryParams: "sdk/workorder/schema/v1/history.params.json";
+    readonly WorkOrderHistoryResult: "sdk/workorder/schema/v1/history.result.json";
+    readonly WorkOrderHistoryUnblockParams: "sdk/workorder/schema/v1/history_unblock.params.json";
+    readonly WorkOrderHistoryUnblockResult: "sdk/workorder/schema/v1/history_unblock.result.json";
+    readonly WorkOrderHumanAskParams: "sdk/workorder/schema/v1/human.ask.params.json";
+    readonly WorkOrderHumanAskResult: "sdk/workorder/schema/v1/human.ask.result.json";
+    readonly WorkOrderInterruptParams: "sdk/workorder/schema/v1/interrupt.params.json";
+    readonly WorkOrderInterruptResult: "sdk/workorder/schema/v1/interrupt.result.json";
+    readonly WorkOrderListParams: "sdk/workorder/schema/v1/list.params.json";
+    readonly WorkOrderListResult: "sdk/workorder/schema/v1/list.result.json";
+    readonly WorkOrderListOffTeraParams: "sdk/workorder/schema/v1/list_off_tera.params.json";
+    readonly WorkOrderListOffTeraResult: "sdk/workorder/schema/v1/list_off_tera.result.json";
+    readonly WorkOrderPauseParams: "sdk/workorder/schema/v1/pause.params.json";
+    readonly WorkOrderPauseResult: "sdk/workorder/schema/v1/pause.result.json";
+    readonly WorkOrderPrioritizeParams: "sdk/workorder/schema/v1/prioritize.params.json";
+    readonly WorkOrderPrioritizeResult: "sdk/workorder/schema/v1/prioritize.result.json";
+    readonly WorkOrderProgressParams: "sdk/workorder/schema/v1/progress.params.json";
+    readonly WorkOrderProgressResult: "sdk/workorder/schema/v1/progress.result.json";
+    readonly WorkOrderRecallParams: "sdk/workorder/schema/v1/recall.params.json";
+    readonly WorkOrderRecallResult: "sdk/workorder/schema/v1/recall.result.json";
+    readonly WorkOrderRefileParams: "sdk/workorder/schema/v1/refile.params.json";
+    readonly WorkOrderRefileResult: "sdk/workorder/schema/v1/refile.result.json";
+    readonly WorkOrderRelateParams: "sdk/workorder/schema/v1/relate.params.json";
+    readonly WorkOrderRelateResult: "sdk/workorder/schema/v1/relate.result.json";
+    readonly WorkOrderReleaseParams: "sdk/workorder/schema/v1/release.params.json";
+    readonly WorkOrderReleaseResult: "sdk/workorder/schema/v1/release.result.json";
+    readonly WorkOrderRepinParams: "sdk/workorder/schema/v1/repin.params.json";
+    readonly WorkOrderRepinResult: "sdk/workorder/schema/v1/repin.result.json";
+    readonly WorkOrderRepostParams: "sdk/workorder/schema/v1/repost.params.json";
+    readonly WorkOrderRepostResult: "sdk/workorder/schema/v1/repost.result.json";
+    readonly WorkOrderRetryParams: "sdk/workorder/schema/v1/retry.params.json";
+    readonly WorkOrderRetryResult: "sdk/workorder/schema/v1/retry.result.json";
+    readonly WorkOrderSubmitResultParams: "sdk/workorder/schema/v1/submit_result.params.json";
+    readonly WorkOrderSubmitResultResult: "sdk/workorder/schema/v1/submit_result.result.json";
+    readonly WorkOrderTakeParams: "sdk/workorder/schema/v1/take.params.json";
+    readonly WorkOrderTakeResult: "sdk/workorder/schema/v1/take.result.json";
+    readonly WorkOrderTransitionParams: "sdk/workorder/schema/v1/transition.params.json";
+    readonly WorkOrderTransitionResult: "sdk/workorder/schema/v1/transition.result.json";
+    readonly WorkOrderTreeParams: "sdk/workorder/schema/v1/tree.params.json";
+    readonly WorkOrderTreeResult: "sdk/workorder/schema/v1/tree.result.json";
+};