@smthrs/control 0.0.0-stage → 1.0.0-rc.4

package/dist/esm/ControlSchema.d.ts

@@ -0,0 +1,2642 @@
+/**
+ * Serializable control-plane values shared by local and RPC projections.
+ *
+ * @since 0.1.0
+ */
+import * as SteerPayload from "@smthrs/notifications/SteerPayload";
+import { DiscoveryWarning } from "@smthrs/registry/Descriptor";
+import { Schema } from "effect";
+/**
+ * A durable control-plane run identifier.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunId: Schema.String;
+/**
+ * A durable control-plane run identifier.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RunId = typeof RunId.Type;
+/**
+ * A registry flow identifier.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const FlowId: Schema.String;
+/**
+ * A registry flow identifier.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type FlowId = typeof FlowId.Type;
+/**
+ * A caller-supplied key that makes a control mutation idempotent.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const IdempotencyKey: Schema.String;
+/**
+ * A caller-supplied key that makes a control mutation idempotent.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type IdempotencyKey = typeof IdempotencyKey.Type;
+/**
+ * A server-authenticated identity stamped at the control boundary.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const Principal: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.String;
+    readonly stampedAt: Schema.Number;
+}>;
+/**
+ * A server-authenticated identity stamped at the control boundary.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Principal = typeof Principal.Type;
+/**
+ * The capabilities, flows, budget, and placement approved for a plan.
+ *
+ * `budget` holds the run's approved ceilings: `tokens`, `milliseconds` of
+ * active time, and `usd` in dollars, and its `deadline`: milliseconds of
+ * wall-clock time counted from the run's first start, shared by every round
+ * of the run. An absent ceiling or deadline is none.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const Envelope: Schema.Struct<{
+    readonly capabilities: Schema.$Array<Schema.String>;
+    /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+    readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly flows: Schema.$Array<Schema.String>;
+    readonly budget: Schema.Struct<{
+        readonly tokens: Schema.optional<Schema.Number>;
+        readonly milliseconds: Schema.optional<Schema.Number>;
+        readonly usd: Schema.optional<Schema.Number>;
+        readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+        readonly deadline: Schema.optional<Schema.Int>;
+    }>;
+    readonly host: Schema.optional<Schema.String>;
+}>;
+/**
+ * The capabilities, flows, budget, and placement approved for a plan.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Envelope = typeof Envelope.Type;
+/**
+ * The durability selected for an approval grant.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const GrantScope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+/**
+ * The durability selected for an approval grant.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type GrantScope = typeof GrantScope.Type;
+/**
+ * A plan or in-run approval target. The digest and full envelope are submitted
+ * with the target so the server can verify exactly what the caller reviewed.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ApprovalTarget: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+    readonly planId: Schema.String;
+    readonly digest: Schema.String;
+    readonly envelope: Schema.Struct<{
+        readonly capabilities: Schema.$Array<Schema.String>;
+        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly flows: Schema.$Array<Schema.String>;
+        readonly budget: Schema.Struct<{
+            readonly tokens: Schema.optional<Schema.Number>;
+            readonly milliseconds: Schema.optional<Schema.Number>;
+            readonly usd: Schema.optional<Schema.Number>;
+            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+            readonly deadline: Schema.optional<Schema.Int>;
+        }>;
+        readonly host: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.TaggedStruct<"Node", {
+    readonly runId: Schema.String;
+    readonly requestId: Schema.String;
+    readonly digest: Schema.String;
+    readonly envelope: Schema.Struct<{
+        readonly capabilities: Schema.$Array<Schema.String>;
+        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly flows: Schema.$Array<Schema.String>;
+        readonly budget: Schema.Struct<{
+            readonly tokens: Schema.optional<Schema.Number>;
+            readonly milliseconds: Schema.optional<Schema.Number>;
+            readonly usd: Schema.optional<Schema.Number>;
+            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+            readonly deadline: Schema.optional<Schema.Int>;
+        }>;
+        readonly host: Schema.optional<Schema.String>;
+    }>;
+}>]>;
+/**
+ * A plan or in-run approval target.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ApprovalTarget = typeof ApprovalTarget.Type;
+/**
+ * The complete, reviewable payload emitted by planning and submitted unchanged
+ * when an approval decision is made.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ApprovalPayload: Schema.Struct<{
+    readonly target: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+        readonly planId: Schema.String;
+        readonly digest: Schema.String;
+        readonly envelope: Schema.Struct<{
+            readonly capabilities: Schema.$Array<Schema.String>;
+            /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+            readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly flows: Schema.$Array<Schema.String>;
+            readonly budget: Schema.Struct<{
+                readonly tokens: Schema.optional<Schema.Number>;
+                readonly milliseconds: Schema.optional<Schema.Number>;
+                readonly usd: Schema.optional<Schema.Number>;
+                readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                readonly deadline: Schema.optional<Schema.Int>;
+            }>;
+            readonly host: Schema.optional<Schema.String>;
+        }>;
+    }>, Schema.TaggedStruct<"Node", {
+        readonly runId: Schema.String;
+        readonly requestId: Schema.String;
+        readonly digest: Schema.String;
+        readonly envelope: Schema.Struct<{
+            readonly capabilities: Schema.$Array<Schema.String>;
+            /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+            readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly flows: Schema.$Array<Schema.String>;
+            readonly budget: Schema.Struct<{
+                readonly tokens: Schema.optional<Schema.Number>;
+                readonly milliseconds: Schema.optional<Schema.Number>;
+                readonly usd: Schema.optional<Schema.Number>;
+                readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                readonly deadline: Schema.optional<Schema.Int>;
+            }>;
+            readonly host: Schema.optional<Schema.String>;
+        }>;
+    }>]>;
+    readonly scope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The complete, reviewable payload emitted by planning.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ApprovalPayload = typeof ApprovalPayload.Type;
+/**
+ * What `smithers plan` reports for one node before anything runs.
+ *
+ * The two outcomes fall out of step keys for free — a key either hits the
+ * step cache or it does not — which is why they are reported here rather than
+ * discovered during execution. The third outcome, `release`, belongs to
+ * orphan reconciliation and is deliberately not part of a plan card.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanNodeStatus: Schema.Literals<readonly ["cached", "run"]>;
+/**
+ * What `smithers plan` reports for one node before anything runs.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanNodeStatus = typeof PlanNodeStatus.Type;
+/**
+ * One keyed node of the plan an approval is being taken on.
+ *
+ * `key` is an `@smthrs/keys` `Key` produced by `@smthrs/plan`'s step-key
+ * compiler, so a node named here and a node recorded in the persisted plan are
+ * the same node. Ids are lookup addresses and are never hashed.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanNode: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["cached", "run"]>;
+    readonly id: Schema.NonEmptyString;
+    readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+    readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+    readonly material: Schema.Struct<{
+        readonly version: Schema.Literal<"flows/key-material/v2">;
+        readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+        readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+        readonly body: Schema.Unknown;
+        readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+            readonly value: Schema.Unknown;
+        }>, Schema.TaggedStruct<"Ref", {
+            readonly from: Schema.NonEmptyString;
+            readonly path: Schema.$Array<Schema.String>;
+        }>, Schema.TaggedStruct<"Pending", {
+            readonly from: Schema.NonEmptyString;
+        }>]>>;
+        readonly layers: Schema.$Array<Schema.String>;
+        readonly capabilities: Schema.$Array<Schema.String>;
+        readonly effects: Schema.optional<Schema.Unknown>;
+        readonly placement: Schema.optional<Schema.Unknown>;
+    }>;
+    readonly effects: Schema.Struct<{
+        readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>]>, Schema.TaggedStruct<"Filegroup", {
+            readonly name: Schema.NonEmptyString;
+            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>]>>;
+        }>]>>;
+        readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        }>, Schema.TaggedStruct<"TreeArtifact", {
+            readonly path: Schema.NonEmptyString;
+        }>]>, Schema.TaggedStruct<"Filegroup", {
+            readonly name: Schema.NonEmptyString;
+            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>, Schema.TaggedStruct<"TreeArtifact", {
+                readonly path: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+        readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+        readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+    }>;
+    readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+    readonly conflicts: Schema.$Array<Schema.Struct<{
+        readonly with: Schema.NonEmptyString;
+        readonly paths: Schema.$Array<Schema.String>;
+        readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+        readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+    }>>;
+    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+    readonly priority: Schema.Int;
+    readonly generation: Schema.Int;
+}>;
+/**
+ * One keyed node of the plan an approval is being taken on.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanNode = typeof PlanNode.Type;
+/**
+ * Why one node of a plan waits for another.
+ *
+ * These are the reasons the two shipped graph builders already record.
+ * `value` consumes an upstream result and `continuation` is the sequencing
+ * edge of a builder or a branch arm, from both. `failure` is `@smthrs/flow`'s
+ * recovery arm; `conflict` is the ordering edge `@smthrs/core`'s
+ * write-conflict pass adds, and `lane-merge` orders laned writers with their
+ * merge. A host reports the vocabulary of the builder it graphs with.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanEdgeReason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+/**
+ * Why one node of a plan waits for another.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanEdgeReason = typeof PlanEdgeReason.Type;
+/**
+ * One labelled edge of the graph a plan was built from.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanEdge: Schema.Struct<{
+    readonly from: Schema.NonEmptyString;
+    readonly to: Schema.NonEmptyString;
+    readonly reason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+}>;
+/**
+ * One labelled edge of the graph a plan was built from.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanEdge = typeof PlanEdge.Type;
+/**
+ * One node of the built graph, as the reader of a plan drills into it.
+ *
+ * It carries the address and the declaration site, and nothing else: the
+ * keyed node beside it (`PlanNode`) already says what the node is and what it
+ * would do, and this is the one fact about it the key material deliberately
+ * does not hold. `declaredAt` is the journal's own schema, so a plan card and
+ * a run's records state a declaration site the same way and under the same
+ * refusal of an absolute path; a host that cannot make a path relative to its
+ * own root omits it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanGraphNode: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly declaredAt: Schema.optionalKey<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly line: Schema.Int;
+    }>>;
+}>;
+/**
+ * One node of the built graph, as the reader of a plan drills into it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanGraphNode = typeof PlanGraphNode.Type;
+/**
+ * The shape of the graph a plan was built from, for a reader that draws it.
+ *
+ * A `PlanNode` carries `dependsOn`, which is one unlabelled edge set: it
+ * cannot tell a value dependency from a `catch` arm or from an ordering edge
+ * a write conflict added. The graph builder knows which is which, so a host
+ * that graphs a flow reports the reasons here rather than making every reader
+ * guess them back.
+ *
+ * `nodes` is the same statement about provenance: the builder observed where
+ * each node was declared and the key material deliberately does not carry it,
+ * so it travels here, beside the edges and outside the digest. A host that
+ * reports none is a host whose reader cannot open the code, not a host whose
+ * plan is wrong.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanGraph: Schema.Struct<{
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly from: Schema.NonEmptyString;
+        readonly to: Schema.NonEmptyString;
+        readonly reason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+    }>>;
+    readonly nodes: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly declaredAt: Schema.optionalKey<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly line: Schema.Int;
+        }>>;
+    }>>>;
+    /**
+     * The revision of the workspace those declaration sites were read out of.
+     *
+     * A site is a path and a line, and neither says which bytes were there: a
+     * host's working tree moves, so the same path after an edit or a branch
+     * switch is a different file. This is the immutable name of the tree the
+     * host loaded the flow from — a jj working-copy commit id, or a git commit
+     * for a tree that still matches one — and a reader asks the content route
+     * for the file AT this revision rather than for whatever is on disk now.
+     *
+     * A host that cannot name one reports nothing, and a reader that has
+     * nothing shows no code at all rather than code it cannot bind (D-068).
+     *
+     * Exactly the forty lowercase hex digits the only producer emits
+     * (`SourceRevision.objectId`), because the app puts this value straight
+     * into a contents route's `?ref=` and a route that spawns jj or git from it
+     * should never see anything else.
+     */
+    readonly sourceRevision: Schema.optional<Schema.NonEmptyString>;
+}>;
+/**
+ * The shape of the graph a plan was built from, for a reader that draws it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanGraph = typeof PlanGraph.Type;
+/**
+ * The reviewable, signed payload returned by planning and resubmitted to
+ * approval without reconstructing authority client-side.
+ *
+ * `nodes` is the keyed node graph the plan phase produced. It is part of the
+ * card, and part of the digest an approval binds to, because "approve this
+ * flow with this input" and "approve this graph of keyed work" are different
+ * promises: a change that re-keys a node changes what will run, and an
+ * approval taken against the old graph must not authorize the new one. A host
+ * that has not built a graph reports an empty one and loses nothing.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanCard: Schema.Struct<{
+    readonly planId: Schema.String;
+    readonly flowId: Schema.String;
+    readonly digest: Schema.String;
+    readonly inputSummary: Schema.String;
+    /** Discovery diagnostics for the selected flow; outside the approval identity. */
+    readonly warnings: Schema.optional<Schema.$Array<typeof DiscoveryWarning>>;
+    readonly envelope: Schema.Struct<{
+        readonly capabilities: Schema.$Array<Schema.String>;
+        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly flows: Schema.$Array<Schema.String>;
+        readonly budget: Schema.Struct<{
+            readonly tokens: Schema.optional<Schema.Number>;
+            readonly milliseconds: Schema.optional<Schema.Number>;
+            readonly usd: Schema.optional<Schema.Number>;
+            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+            readonly deadline: Schema.optional<Schema.Int>;
+        }>;
+        readonly host: Schema.optional<Schema.String>;
+    }>;
+    readonly deployClass: Schema.Boolean;
+    /** Executable source/metadata identity supplied by a discovery-based host. */
+    readonly executionDigest: Schema.optional<Schema.String>;
+    readonly plan: Schema.optional<Schema.Struct<{
+        readonly planId: Schema.NonEmptyString;
+        readonly flow: Schema.NonEmptyString;
+        readonly generation: Schema.Int;
+        readonly baseDigest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+        readonly digest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+        readonly nodes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+            readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+            readonly material: Schema.Struct<{
+                readonly version: Schema.Literal<"flows/key-material/v2">;
+                readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+                readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+                readonly body: Schema.Unknown;
+                readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                    readonly value: Schema.Unknown;
+                }>, Schema.TaggedStruct<"Ref", {
+                    readonly from: Schema.NonEmptyString;
+                    readonly path: Schema.$Array<Schema.String>;
+                }>, Schema.TaggedStruct<"Pending", {
+                    readonly from: Schema.NonEmptyString;
+                }>]>>;
+                readonly layers: Schema.$Array<Schema.String>;
+                readonly capabilities: Schema.$Array<Schema.String>;
+                readonly effects: Schema.optional<Schema.Unknown>;
+                readonly placement: Schema.optional<Schema.Unknown>;
+            }>;
+            readonly effects: Schema.Struct<{
+                readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>]>, Schema.TaggedStruct<"Filegroup", {
+                    readonly name: Schema.NonEmptyString;
+                    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>]>>;
+                }>]>>;
+                readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>, Schema.TaggedStruct<"TreeArtifact", {
+                    readonly path: Schema.NonEmptyString;
+                }>]>, Schema.TaggedStruct<"Filegroup", {
+                    readonly name: Schema.NonEmptyString;
+                    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>, Schema.TaggedStruct<"TreeArtifact", {
+                        readonly path: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+                readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+            }>;
+            readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+            readonly conflicts: Schema.$Array<Schema.Struct<{
+                readonly with: Schema.NonEmptyString;
+                readonly paths: Schema.$Array<Schema.String>;
+                readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+            }>>;
+            readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+            readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+            readonly priority: Schema.Int;
+            readonly generation: Schema.Int;
+        }>>;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly status: Schema.Literals<readonly ["cached", "run"]>;
+        readonly id: Schema.NonEmptyString;
+        readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+        readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+        readonly material: Schema.Struct<{
+            readonly version: Schema.Literal<"flows/key-material/v2">;
+            readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+            readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+            readonly body: Schema.Unknown;
+            readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                readonly value: Schema.Unknown;
+            }>, Schema.TaggedStruct<"Ref", {
+                readonly from: Schema.NonEmptyString;
+                readonly path: Schema.$Array<Schema.String>;
+            }>, Schema.TaggedStruct<"Pending", {
+                readonly from: Schema.NonEmptyString;
+            }>]>>;
+            readonly layers: Schema.$Array<Schema.String>;
+            readonly capabilities: Schema.$Array<Schema.String>;
+            readonly effects: Schema.optional<Schema.Unknown>;
+            readonly placement: Schema.optional<Schema.Unknown>;
+        }>;
+        readonly effects: Schema.Struct<{
+            readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>]>, Schema.TaggedStruct<"Filegroup", {
+                readonly name: Schema.NonEmptyString;
+                readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>]>>;
+            }>]>>;
+            readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            }>, Schema.TaggedStruct<"TreeArtifact", {
+                readonly path: Schema.NonEmptyString;
+            }>]>, Schema.TaggedStruct<"Filegroup", {
+                readonly name: Schema.NonEmptyString;
+                readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>, Schema.TaggedStruct<"TreeArtifact", {
+                    readonly path: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+            readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+            readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+        }>;
+        readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+        readonly conflicts: Schema.$Array<Schema.Struct<{
+            readonly with: Schema.NonEmptyString;
+            readonly paths: Schema.$Array<Schema.String>;
+            readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+            readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+        }>>;
+        readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+        readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+        readonly priority: Schema.Int;
+        readonly generation: Schema.Int;
+    }>>;
+    /**
+     * The labelled edges of the graph this plan was built from, and where its
+     * nodes were declared.
+     *
+     * Deliberately OUTSIDE the digest an approval binds to: the edges and the
+     * declaration sites describe the plan a reader draws, and nothing here
+     * changes what will run. The
+     * persisted plan's own digest already covers keys, edges, effects,
+     * conflicts, priorities and generations, so a host that starts reporting
+     * this field re-plans to the digest it planned to before and every parked
+     * approval still validates.
+     */
+    readonly graph: Schema.optional<Schema.Struct<{
+        readonly edges: Schema.$Array<Schema.Struct<{
+            readonly from: Schema.NonEmptyString;
+            readonly to: Schema.NonEmptyString;
+            readonly reason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+        }>>;
+        readonly nodes: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly declaredAt: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.NonEmptyString;
+                readonly line: Schema.Int;
+            }>>;
+        }>>>;
+        /**
+         * The revision of the workspace those declaration sites were read out of.
+         *
+         * A site is a path and a line, and neither says which bytes were there: a
+         * host's working tree moves, so the same path after an edit or a branch
+         * switch is a different file. This is the immutable name of the tree the
+         * host loaded the flow from — a jj working-copy commit id, or a git commit
+         * for a tree that still matches one — and a reader asks the content route
+         * for the file AT this revision rather than for whatever is on disk now.
+         *
+         * A host that cannot name one reports nothing, and a reader that has
+         * nothing shows no code at all rather than code it cannot bind (D-068).
+         *
+         * Exactly the forty lowercase hex digits the only producer emits
+         * (`SourceRevision.objectId`), because the app puts this value straight
+         * into a contents route's `?ref=` and a route that spawns jj or git from it
+         * should never see anything else.
+         */
+        readonly sourceRevision: Schema.optional<Schema.NonEmptyString>;
+    }>>;
+    readonly approval: Schema.Struct<{
+        readonly target: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+            readonly planId: Schema.String;
+            readonly digest: Schema.String;
+            readonly envelope: Schema.Struct<{
+                readonly capabilities: Schema.$Array<Schema.String>;
+                /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                readonly flows: Schema.$Array<Schema.String>;
+                readonly budget: Schema.Struct<{
+                    readonly tokens: Schema.optional<Schema.Number>;
+                    readonly milliseconds: Schema.optional<Schema.Number>;
+                    readonly usd: Schema.optional<Schema.Number>;
+                    readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                    readonly deadline: Schema.optional<Schema.Int>;
+                }>;
+                readonly host: Schema.optional<Schema.String>;
+            }>;
+        }>, Schema.TaggedStruct<"Node", {
+            readonly runId: Schema.String;
+            readonly requestId: Schema.String;
+            readonly digest: Schema.String;
+            readonly envelope: Schema.Struct<{
+                readonly capabilities: Schema.$Array<Schema.String>;
+                /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                readonly flows: Schema.$Array<Schema.String>;
+                readonly budget: Schema.Struct<{
+                    readonly tokens: Schema.optional<Schema.Number>;
+                    readonly milliseconds: Schema.optional<Schema.Number>;
+                    readonly usd: Schema.optional<Schema.Number>;
+                    readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                    readonly deadline: Schema.optional<Schema.Int>;
+                }>;
+                readonly host: Schema.optional<Schema.String>;
+            }>;
+        }>]>;
+        readonly scope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+        readonly idempotencyKey: Schema.String;
+    }>;
+}>;
+/**
+ * The reviewable, signed payload returned by planning and resubmitted to
+ * approval without reconstructing authority client-side.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type PlanCard = typeof PlanCard.Type;
+/**
+ * Stable statuses projected for a durable run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunStatus: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+/**
+ * Stable statuses projected for a durable run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RunStatus = typeof RunStatus.Type;
+/**
+ * How a run came to exist, when it did not start on its own.
+ *
+ * Defined by `@smthrs/control/Lineage` and re-exported here so a serializable
+ * projection needs one import.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunOrigin: Schema.Literals<readonly ["child", "fork", "continuation"]>;
+/**
+ * How a run came to exist, when it did not start on its own.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RunOrigin = typeof RunOrigin.Type;
+/**
+ * Where a cancellation came from.
+ *
+ * `control` is an operator asking through this plane, and it is the only
+ * source that can name a principal. `cascade` is a run swept up in an
+ * ancestor's cancellation. `engine` is everything the runtime decided on its
+ * own account: a lease expiry, a budget, a supervisor.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const CancelSource: Schema.Literals<readonly ["control", "engine", "cascade"]>;
+/**
+ * Where a cancellation came from.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type CancelSource = typeof CancelSource.Type;
+/**
+ * Who cancelled a run, why, and on whose behalf.
+ *
+ * A durable cancellation is anonymous on its own: the run row records that
+ * somebody asked and when, and nothing else. This is the attribution the
+ * journal adds back. `principal` and `reason` are present exactly when a
+ * request named them, which a cascade inherits from the request that started
+ * it and an engine-decided cancellation never has.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const Cancellation: Schema.Struct<{
+    readonly requestedAt: Schema.Number;
+    readonly source: Schema.Literals<readonly ["control", "engine", "cascade"]>;
+    readonly principal: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>>;
+    readonly reason: Schema.optional<Schema.String>;
+    /** The cancelled ancestor this run was swept up with, on a cascade. */
+    readonly cascadedFrom: Schema.optional<Schema.String>;
+}>;
+/**
+ * Who cancelled a run, why, and on whose behalf.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Cancellation = typeof Cancellation.Type;
+/**
+ * One open wait in a run tree that a person or named signal can end.
+ *
+ * A run that calls another flow parks the CHILD execution, not the run an
+ * operator named. `run-3` of `coding/request` sat at `waiting-reason: event`
+ * while the question a person owed an answer to — `coding-clarification` —
+ * was parked three executions below it on `coding/PreparePlan`. Every reader
+ * that asked the named run what it was waiting on was therefore told "an
+ * event", which is true of that one row and false of the run tree: nothing
+ * was going to arrive, because the run was waiting on a human.
+ *
+ * This is the wait as the ROOT of the tree reports it. `runId` is the
+ * execution actually holding it, which is what a decision has to be routed
+ * to; `token` is the durable wait address, submitted back unchanged;
+ * `request` is what the wait declared about itself, which for a `HumanTask`
+ * is `{kind, name, prompt, attempt, maxAttempts}`.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const PendingWait: Schema.Struct<{
+    /** The execution parked on this wait, which may be the root run itself. */
+    readonly runId: Schema.String;
+    /** The flow that execution is running. */
+    readonly flowId: Schema.optional<Schema.String>;
+    /** The supervisor vocabulary: `approval` for people or `event` for a named signal. */
+    readonly reason: Schema.String;
+    /** The durable wait address a decision is routed to. */
+    readonly token: Schema.String;
+    /** Digest used to join replayed display facts to this current operational address. */
+    readonly tokenDigest: Schema.optional<Schema.String>;
+    /** The wait point's own name, when the token addresses a named one. */
+    readonly name: Schema.optional<Schema.String>;
+    /** Which attempt of a re-asked question this is, counting from 1. */
+    readonly attempt: Schema.optional<Schema.Number>;
+    /** What the wait declared about itself, absent when it declared nothing. */
+    readonly request: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    /** When the execution holding this wait was created. */
+    readonly createdAt: Schema.Number;
+}>;
+/**
+ * One open wait in a run tree that a person or named signal can end.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type PendingWait = typeof PendingWait.Type;
+/**
+ * A compact summary for run listings and status projections.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunSummary: Schema.Struct<{
+    /** Whether lifecycle fields were observed in the engine or no engine row was visible. */
+    readonly executionObservation: Schema.optional<Schema.Literals<readonly ["observed", "missing"]>>;
+    /** Exact native semantic observation; never a control-stream fact. */
+    readonly executionView: Schema.optional<Schema.Struct<{
+        readonly root: Schema.Struct<{
+            readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly flowName: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+            readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+            readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly roundOrdinal: Schema.Int;
+            readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+            readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+            readonly waiting: Schema.NullOr<Schema.Struct<{
+                readonly reason: Schema.NonEmptyString;
+                readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+        }>;
+        readonly current: Schema.Struct<{
+            readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly flowName: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+            readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+            readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly roundOrdinal: Schema.Int;
+            readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+            readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+            readonly waiting: Schema.NullOr<Schema.Struct<{
+                readonly reason: Schema.NonEmptyString;
+                readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+        }>;
+        readonly humanWaits: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly flowName: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+            readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+            readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly roundOrdinal: Schema.Int;
+            readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+            readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+            readonly waiting: Schema.NullOr<Schema.Struct<{
+                readonly reason: Schema.NonEmptyString;
+                readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+        }>>>;
+    }>>;
+    readonly runId: Schema.String;
+    readonly flowId: Schema.String;
+    readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+    readonly planId: Schema.optional<Schema.String>;
+    readonly planDigest: Schema.optional<Schema.String>;
+    /** The flow's executable identity when the run started; resume refuses a different one. */
+    readonly executionDigest: Schema.optional<Schema.String>;
+    /** The engine version that started the run. */
+    readonly engineVersion: Schema.optional<Schema.String>;
+    /**
+     * How the code that would resume this run differs from the code it
+     * recorded. Computed by an exact run lookup, never stored; absent when
+     * nothing changed or the run is terminal.
+     */
+    readonly codeDrift: Schema.optional<Schema.Struct<{
+        readonly recorded: Schema.optional<Schema.String>;
+        readonly current: Schema.optional<Schema.String>;
+        readonly recordedEngine: Schema.optional<Schema.String>;
+        readonly currentEngine: Schema.optional<Schema.String>;
+    }>>;
+    readonly ownerId: Schema.optional<Schema.String>;
+    /**
+     * The authenticated principal that launched this run through the control
+     * plane. A reader that does not see every run sees only the runs its own
+     * principal launched. Absent on a run the engine created (a child, a fork,
+     * a later trampoline round) and on a run launched before it was recorded;
+     * only a reader that sees every run sees those.
+     */
+    readonly launchedBy: Schema.optional<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+    }>>;
+    /**
+     * The run this one branched from: the spawning run, the forked-from run, or
+     * the previous trampoline round. Absent on a run with no ancestor.
+     */
+    readonly parentRunId: Schema.optional<Schema.String>;
+    /**
+     * The trampoline lineage this run is a round of, and which round it is.
+     * Both absent means a lineage of one, read as round 0 of itself.
+     */
+    readonly lineageId: Schema.optional<Schema.String>;
+    readonly roundOrdinal: Schema.optional<Schema.Number>;
+    readonly origin: Schema.optional<Schema.Literals<readonly ["child", "fork", "continuation"]>>;
+    /**
+     * What a parked run is holding on: `approval`, `event`, `timer`, `quota`, or
+     * a reason a plugin declared. Absent on a run that is not parked, and on a
+     * park whose owner released the run without declaring one.
+     *
+     * The CLI's `ps` and `status` listings also render `executor` here for a run
+     * that has sat at `accepted` with no owner process past the launch handoff
+     * window. That value is computed at render time and never stored, so a
+     * reader going through the control RPC, the gateway projection, or a plugin
+     * sees the field absent on the same run.
+     */
+    readonly waitingReason: Schema.optional<Schema.String>;
+    /** What has been steered to this run and not yet delivered. */
+    readonly steering: Schema.optional<Schema.Struct<{
+        readonly pending: Schema.Number;
+    }>>;
+    /**
+     * A resume this run has been told to take and no host has taken up yet.
+     *
+     * A decision on an in-run approval restarts the run server-side, and the
+     * process that decides is usually not the process that hosts the execution:
+     * an operator's `smithers approve`, a gateway, a second CLI. The intent is
+     * therefore recorded durably here, and the host that owns the execution
+     * takes it up on its next tick and clears it. The number is the durable
+     * sequence of the request, so an operator can tell a delegation that is
+     * still outstanding from one that has been taken up. Absent means nothing
+     * is waiting to be taken up.
+     */
+    readonly pendingResume: Schema.optional<Schema.Number>;
+    /**
+     * The executor claim this run was parked under.
+     *
+     * A parked execution releases its owner columns — that is what makes it
+     * resumable at all — so after a park nothing on the row says which process
+     * is hosting it. Every process that shares the databases can therefore see
+     * the parked execution and resume it, including a short-lived `smithers
+     * approve` that would drive the run and then exit. The fence the park was
+     * written under is recorded here instead, so the host that parked the run
+     * recognizes its own park and every other composition can tell that the
+     * execution is not its to take up (triage B-15). Absent on a run that is not
+     * parked, and on a park written by something that held no fence.
+     */
+    readonly parkedBy: Schema.optional<Schema.String>;
+    /** Who cancelled this run, why, and on whose behalf. Absent until one did. */
+    readonly cancellation: Schema.optional<Schema.Struct<{
+        readonly requestedAt: Schema.Number;
+        readonly source: Schema.Literals<readonly ["control", "engine", "cascade"]>;
+        readonly principal: Schema.optional<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly stampedAt: Schema.Number;
+        }>>;
+        readonly reason: Schema.optional<Schema.String>;
+        /** The cancelled ancestor this run was swept up with, on a cascade. */
+        readonly cascadedFrom: Schema.optional<Schema.String>;
+    }>>;
+    /**
+     * Open human waits anywhere in this run's tree, nearest execution first.
+     *
+     * Present only when there is at least one, so a run nobody owes an answer
+     * carries no field rather than an empty array. `status` rolls up with it:
+     * a run any of whose descendants is parked on `approval` reports
+     * `waiting-approval`, which is what the existing inbox filters select on.
+     */
+    readonly pendingWaits: Schema.optional<Schema.$Array<Schema.Struct<{
+        /** The execution parked on this wait, which may be the root run itself. */
+        readonly runId: Schema.String;
+        /** The flow that execution is running. */
+        readonly flowId: Schema.optional<Schema.String>;
+        /** The supervisor vocabulary: `approval` for people or `event` for a named signal. */
+        readonly reason: Schema.String;
+        /** The durable wait address a decision is routed to. */
+        readonly token: Schema.String;
+        /** Digest used to join replayed display facts to this current operational address. */
+        readonly tokenDigest: Schema.optional<Schema.String>;
+        /** The wait point's own name, when the token addresses a named one. */
+        readonly name: Schema.optional<Schema.String>;
+        /** Which attempt of a re-asked question this is, counting from 1. */
+        readonly attempt: Schema.optional<Schema.Number>;
+        /** What the wait declared about itself, absent when it declared nothing. */
+        readonly request: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        /** When the execution holding this wait was created. */
+        readonly createdAt: Schema.Number;
+    }>>>;
+    /**
+     * When the run's approved deadline passes: its `createdAt` plus the
+     * envelope's `budget.deadline`, which is the instant the run is failed with
+     * `deadline_exceeded` if it has not settled. Absent on a run approved with
+     * no deadline.
+     */
+    readonly deadlineAt: Schema.optional<Schema.Number>;
+    readonly createdAt: Schema.Number;
+    readonly updatedAt: Schema.Number;
+}>;
+/**
+ * A compact summary for run listings and status projections.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type RunSummary = typeof RunSummary.Type;
+/**
+ * An operator message inserted into the transcript at the next turn boundary.
+ *
+ * `kind` is optional here and required on every other variant, which is what
+ * keeps a steer written before the vocabulary widened readable: a body and no
+ * kind is a message, and always was.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const MessageSteer: Schema.Struct<{
+    readonly kind: Schema.optional<Schema.Literal<"Message">>;
+    readonly body: Schema.String;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>;
+/**
+ * A model-seat change that applies from the next turn on.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const SeatSteer: Schema.Struct<{
+    readonly kind: Schema.Literal<"Seat">;
+    readonly seat: Schema.NonEmptyString;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>;
+/**
+ * A thinking-level change that applies from the next turn on.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ThinkingSteer: Schema.Struct<{
+    readonly kind: Schema.Literal<"Thinking">;
+    readonly thinking: Schema.Literals<readonly ["none", "minimal", "low", "medium", "high", "xhigh"]>;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>;
+/**
+ * Tools added to the active set for future turns.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ToolsSteer: Schema.Struct<{
+    readonly kind: Schema.Literal<"Tools">;
+    readonly toolNames: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>;
+/**
+ * A durable operator steer delivered at an execution turn boundary.
+ *
+ * An operator steers a run for four different reasons, and only one of them is
+ * something to tell the model. Saying "your seat changed" would spend a turn on
+ * bookkeeping; changing the seat is what was asked for. So the four are one
+ * union rather than four free-text conventions the harness would have to
+ * parse.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const SteerMessage: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.optional<Schema.Literal<"Message">>;
+    readonly body: Schema.String;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"Seat">;
+    readonly seat: Schema.NonEmptyString;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"Thinking">;
+    readonly thinking: Schema.Literals<readonly ["none", "minimal", "low", "medium", "high", "xhigh"]>;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"Tools">;
+    readonly toolNames: Schema.NonEmptyArray<Schema.NonEmptyString>;
+    readonly messageId: Schema.String;
+    readonly runId: Schema.String;
+    readonly principal: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly stampedAt: Schema.Number;
+    }>;
+    readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly createdAt: Schema.Number;
+}>]>;
+/**
+ * A durable operator steer delivered at an execution turn boundary.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type SteerMessage = typeof SteerMessage.Type;
+/**
+ * The stored steering item one steer carries.
+ *
+ * The envelope — who asked, when, for which run — is control-plane
+ * bookkeeping. What crosses into the notification queue is the item alone, in
+ * the vocabulary `@smthrs/notifications` defines and the harness reads back.
+ *
+ * @param message the steer
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare const steerItem: (message: SteerMessage) => SteerPayload.SteerPayload;
+/**
+ * A durable, named signal delivered to a waiting run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const SignalPayload: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * A durable, named signal delivered to a waiting run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type SignalPayload = typeof SignalPayload.Type;
+/**
+ * The RPC request schema for planning.
+ *
+ * The wire accepts JSON because an RPC request must be serializable. The local
+ * `Control.PlanInput` keeps `input` as `unknown` so a runtime can decode its
+ * flow's own input schema before anything crosses a transport.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PlanInputSchema: Schema.Struct<{
+    readonly flowId: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly idempotencyKey: Schema.optional<Schema.String>;
+    readonly budget: Schema.optional<Schema.Struct<{
+        readonly tokens: Schema.optional<Schema.Number>;
+        readonly milliseconds: Schema.optional<Schema.Number>;
+        readonly usd: Schema.optional<Schema.Number>;
+        readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+        readonly deadline: Schema.optional<Schema.Int>;
+    }>>;
+}>;
+/**
+ * The RPC request schema for starting a plan or resuming a run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunInputSchema: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+    readonly planId: Schema.String;
+    readonly digest: Schema.String;
+    readonly envelope: Schema.Struct<{
+        readonly capabilities: Schema.$Array<Schema.String>;
+        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+        readonly flows: Schema.$Array<Schema.String>;
+        readonly budget: Schema.Struct<{
+            readonly tokens: Schema.optional<Schema.Number>;
+            readonly milliseconds: Schema.optional<Schema.Number>;
+            readonly usd: Schema.optional<Schema.Number>;
+            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+            readonly deadline: Schema.optional<Schema.Int>;
+        }>;
+        readonly host: Schema.optional<Schema.String>;
+    }>;
+    readonly idempotencyKey: Schema.String;
+}>, Schema.TaggedStruct<"Resume", {
+    readonly runId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+    readonly allowCodeDrift: Schema.optional<Schema.Boolean>;
+}>]>;
+/**
+ * The RPC request schema for an approval decision.
+ *
+ * The authenticated server supplies the principal, so a client cannot name a
+ * different identity on the wire.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ApprovalInputSchema: Schema.Struct<{
+    readonly target: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+        readonly planId: Schema.String;
+        readonly digest: Schema.String;
+        readonly envelope: Schema.Struct<{
+            readonly capabilities: Schema.$Array<Schema.String>;
+            /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+            readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly flows: Schema.$Array<Schema.String>;
+            readonly budget: Schema.Struct<{
+                readonly tokens: Schema.optional<Schema.Number>;
+                readonly milliseconds: Schema.optional<Schema.Number>;
+                readonly usd: Schema.optional<Schema.Number>;
+                readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                readonly deadline: Schema.optional<Schema.Int>;
+            }>;
+            readonly host: Schema.optional<Schema.String>;
+        }>;
+    }>, Schema.TaggedStruct<"Node", {
+        readonly runId: Schema.String;
+        readonly requestId: Schema.String;
+        readonly digest: Schema.String;
+        readonly envelope: Schema.Struct<{
+            readonly capabilities: Schema.$Array<Schema.String>;
+            /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+            readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly flows: Schema.$Array<Schema.String>;
+            readonly budget: Schema.Struct<{
+                readonly tokens: Schema.optional<Schema.Number>;
+                readonly milliseconds: Schema.optional<Schema.Number>;
+                readonly usd: Schema.optional<Schema.Number>;
+                readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                readonly deadline: Schema.optional<Schema.Int>;
+            }>;
+            readonly host: Schema.optional<Schema.String>;
+        }>;
+    }>]>;
+    readonly scope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The RPC request schema for steering a run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const SteerInputSchema: Schema.Struct<{
+    readonly version: Schema.optional<Schema.Number>;
+    readonly runId: Schema.String;
+    readonly message: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.optional<Schema.Literal<"Message">>;
+        readonly body: Schema.String;
+        readonly messageId: Schema.String;
+        readonly runId: Schema.String;
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly stampedAt: Schema.Number;
+        }>;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly createdAt: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"Seat">;
+        readonly seat: Schema.NonEmptyString;
+        readonly messageId: Schema.String;
+        readonly runId: Schema.String;
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly stampedAt: Schema.Number;
+        }>;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly createdAt: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"Thinking">;
+        readonly thinking: Schema.Literals<readonly ["none", "minimal", "low", "medium", "high", "xhigh"]>;
+        readonly messageId: Schema.String;
+        readonly runId: Schema.String;
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly stampedAt: Schema.Number;
+        }>;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly createdAt: Schema.Number;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"Tools">;
+        readonly toolNames: Schema.NonEmptyArray<Schema.NonEmptyString>;
+        readonly messageId: Schema.String;
+        readonly runId: Schema.String;
+        readonly principal: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly stampedAt: Schema.Number;
+        }>;
+        readonly attribution: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+        readonly createdAt: Schema.Number;
+    }>]>;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The RPC request schema for signaling a run.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const SignalInputSchema: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly signal: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The shared fields of an RPC run mutation request.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const RunMutationInputSchema: Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The RPC request schema for a lifecycle mutation that records a reason.
+ *
+ * The reason is on the wire because the server records it with the decision.
+ * The principal is absent because the authenticated server stamps it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ReasonedMutationInputSchema: Schema.Struct<{
+    readonly reason: Schema.optional<Schema.String>;
+    readonly runId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The RPC request schema for cancellation.
+ *
+ * Cancellation currently has the same wire shape as every reasoned lifecycle
+ * mutation. This named alias keeps the operation's public contract explicit.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const CancelInputSchema: Schema.Struct<{
+    readonly reason: Schema.optional<Schema.String>;
+    readonly runId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * The RPC request schema for resume: a reasoned mutation that may accept a
+ * changed flow.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const ResumeInputSchema: Schema.Struct<{
+    readonly allowCodeDrift: Schema.optional<Schema.Boolean>;
+    readonly reason: Schema.optional<Schema.String>;
+    readonly runId: Schema.String;
+    readonly idempotencyKey: Schema.String;
+}>;
+/**
+ * A checkpoint in one journal entry's expansion. Without `offset`, the whole
+ * entry is consumed. With it, only members through that zero-based index are
+ * consumed. Pass the cursor back unchanged with the same run id.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const WatchCursor: Schema.Struct<{
+    readonly sequence: Schema.Int;
+    readonly offset: Schema.optional<Schema.Int>;
+}>;
+/**
+ * A checkpoint in one journal entry's expansion.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type WatchCursor = typeof WatchCursor.Type;
+/**
+ * A journal-projection cursor, optional run restriction, and delivery mode.
+ * Omitting `follow` preserves the live-stream behavior; `false` requests a
+ * finite snapshot of entries durable when the request is handled.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const WatchFilter: Schema.Struct<{
+    readonly runId: Schema.optional<Schema.String>;
+    /** Resume after a fully consumed source entry, including all its deltas. Requires `runId`. */
+    readonly afterSequence: Schema.optional<Schema.Number>;
+    /** Resume after one emitted event, even inside an expansion. Requires `runId`. Cannot be combined with `afterSequence`. */
+    readonly afterCursor: Schema.optional<Schema.Struct<{
+        readonly sequence: Schema.Int;
+        readonly offset: Schema.optional<Schema.Int>;
+    }>>;
+    readonly follow: Schema.optional<Schema.Boolean>;
+}>;
+/**
+ * A resumable journal-projection watch cursor and optional run restriction.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type WatchFilter = typeof WatchFilter.Type;
+/**
+ * One ordered journal-projection delta streamed by `watch`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ControlEvent: Schema.Struct<{
+    /** Present on `ControlLive.watch` events; absent on raw projections and older providers. */
+    readonly cursor: Schema.optional<Schema.Struct<{
+        readonly sequence: Schema.Int;
+        readonly offset: Schema.optional<Schema.Int>;
+    }>>;
+    readonly sequence: Schema.Number;
+    readonly kind: Schema.String;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly occurredAt: Schema.Number;
+    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+/**
+ * One ordered journal-projection delta streamed by `watch`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ControlEvent = typeof ControlEvent.Type;
+/**
+ * How many items a listing returns when the caller names no `limit`.
+ *
+ * A listing with no bound returned the whole collection and paid one pending
+ * steer query per run, so `smithers ps` on a busy project grew without bound.
+ * A default is the smallest fix that keeps every caller working: a client that
+ * wants more walks `nextCursor`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const defaultPageSize = 100;
+/**
+ * The largest `limit` a listing accepts.
+ *
+ * The cap is the resource bound: a remote bearer holder cannot ask one request
+ * to project an unbounded number of rows.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const maxPageSize = 500;
+/**
+ * A page size a listing can actually make progress on.
+ *
+ * `0`, a negative size, a fraction, `NaN`, and `Infinity` are all refused. A
+ * zero-sized page used to answer `{ items: [], nextCursor: "0" }`, which is a
+ * cursor a client loops on forever.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const PageLimit: Schema.Int;
+/**
+ * How a claimed trigger occurrence ended.
+ *
+ * The same six words `@smthrs/triggers` records in its fire ledger. They are
+ * declared here rather than imported because the triggers package depends on
+ * this one (its scheduler launches runs through `Control`), so the vocabulary
+ * has to live on the control side of that edge.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const FireOutcome: Schema.Literals<readonly ["launched", "completed", "skipped", "buffered", "superseded", "failed"]>;
+/**
+ * How a claimed trigger occurrence ended.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type FireOutcome = typeof FireOutcome.Type;
+/**
+ * One registered trigger as a listing reports it.
+ *
+ * `nextOccurrencesMs` is the store clock's view of the next fires, computed at
+ * read time, so an operator sees when a schedule will next run without
+ * evaluating the cron expression client-side. `schedulerLastTickMs` is the
+ * last poll the scheduler recorded; absent means no scheduler has ticked on
+ * this host, so an enabled trigger is not going to fire. `activeRunId` names
+ * the run the trigger is currently holding, and is absent while the trigger
+ * holds a reservation rather than a launched run.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const TriggerSummary: Schema.Struct<{
+    readonly triggerId: Schema.String;
+    readonly flowId: Schema.String;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly cron: Schema.String;
+    readonly timezone: Schema.optional<Schema.String>;
+    readonly overlap: Schema.Literals<readonly ["skip", "buffer-one", "supersede"]>;
+    readonly catchUp: Schema.Literals<readonly ["none", "one", "all"]>;
+    readonly maxCatchUp: Schema.optional<Schema.Number>;
+    readonly enabled: Schema.Boolean;
+    readonly revision: Schema.Number;
+    readonly lastFiredAtMs: Schema.optional<Schema.Number>;
+    readonly pendingAtMs: Schema.optional<Schema.Number>;
+    readonly activeRunId: Schema.optional<Schema.String>;
+    readonly nextOccurrencesMs: Schema.$Array<Schema.Number>;
+    readonly schedulerLastTickMs: Schema.optional<Schema.Number>;
+}>;
+/**
+ * One registered trigger as a listing reports it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type TriggerSummary = typeof TriggerSummary.Type;
+/**
+ * One claimed trigger occurrence and what became of it.
+ *
+ * `outcome` is `null` while the occurrence is claimed and not yet reported,
+ * which is the window between a claim and its `recordResult`. `waiting` names
+ * what a launched run is parked on when the ledger can see it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const FireSummary: Schema.Struct<{
+    readonly triggerId: Schema.String;
+    readonly occurrenceAtMs: Schema.Number;
+    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["launched", "completed", "skipped", "buffered", "superseded", "failed"]>>;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly error: Schema.optional<Schema.String>;
+    readonly waiting: Schema.optional<Schema.Literal<"approval">>;
+}>;
+/**
+ * One claimed trigger occurrence and what became of it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type FireSummary = typeof FireSummary.Type;
+/**
+ * An operator's decision on a stored plan.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const PlanDecision: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+/**
+ * An operator's decision on a stored plan.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type PlanDecision = typeof PlanDecision.Type;
+/**
+ * One stored plan as a listing reports it: the card an approval submits
+ * (`card.approval`), the decoded input it was planned with, and its decision.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const PlanSummary: Schema.Struct<{
+    readonly card: Schema.Struct<{
+        readonly planId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly digest: Schema.String;
+        readonly inputSummary: Schema.String;
+        /** Discovery diagnostics for the selected flow; outside the approval identity. */
+        readonly warnings: Schema.optional<Schema.$Array<typeof DiscoveryWarning>>;
+        readonly envelope: Schema.Struct<{
+            readonly capabilities: Schema.$Array<Schema.String>;
+            /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+            readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+            readonly flows: Schema.$Array<Schema.String>;
+            readonly budget: Schema.Struct<{
+                readonly tokens: Schema.optional<Schema.Number>;
+                readonly milliseconds: Schema.optional<Schema.Number>;
+                readonly usd: Schema.optional<Schema.Number>;
+                readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                readonly deadline: Schema.optional<Schema.Int>;
+            }>;
+            readonly host: Schema.optional<Schema.String>;
+        }>;
+        readonly deployClass: Schema.Boolean;
+        /** Executable source/metadata identity supplied by a discovery-based host. */
+        readonly executionDigest: Schema.optional<Schema.String>;
+        readonly plan: Schema.optional<Schema.Struct<{
+            readonly planId: Schema.NonEmptyString;
+            readonly flow: Schema.NonEmptyString;
+            readonly generation: Schema.Int;
+            readonly baseDigest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+            readonly digest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.NonEmptyString;
+                readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+                readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+                readonly material: Schema.Struct<{
+                    readonly version: Schema.Literal<"flows/key-material/v2">;
+                    readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+                    readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+                    readonly body: Schema.Unknown;
+                    readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                        readonly value: Schema.Unknown;
+                    }>, Schema.TaggedStruct<"Ref", {
+                        readonly from: Schema.NonEmptyString;
+                        readonly path: Schema.$Array<Schema.String>;
+                    }>, Schema.TaggedStruct<"Pending", {
+                        readonly from: Schema.NonEmptyString;
+                    }>]>>;
+                    readonly layers: Schema.$Array<Schema.String>;
+                    readonly capabilities: Schema.$Array<Schema.String>;
+                    readonly effects: Schema.optional<Schema.Unknown>;
+                    readonly placement: Schema.optional<Schema.Unknown>;
+                }>;
+                readonly effects: Schema.Struct<{
+                    readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>]>, Schema.TaggedStruct<"Filegroup", {
+                        readonly name: Schema.NonEmptyString;
+                        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>]>>;
+                    }>]>>;
+                    readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>, Schema.TaggedStruct<"TreeArtifact", {
+                        readonly path: Schema.NonEmptyString;
+                    }>]>, Schema.TaggedStruct<"Filegroup", {
+                        readonly name: Schema.NonEmptyString;
+                        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>, Schema.TaggedStruct<"TreeArtifact", {
+                            readonly path: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                    readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+                }>;
+                readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+                readonly conflicts: Schema.$Array<Schema.Struct<{
+                    readonly with: Schema.NonEmptyString;
+                    readonly paths: Schema.$Array<Schema.String>;
+                    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                }>>;
+                readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                readonly priority: Schema.Int;
+                readonly generation: Schema.Int;
+            }>>;
+        }>>;
+        readonly nodes: Schema.$Array<Schema.Struct<{
+            readonly status: Schema.Literals<readonly ["cached", "run"]>;
+            readonly id: Schema.NonEmptyString;
+            readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+            readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+            readonly material: Schema.Struct<{
+                readonly version: Schema.Literal<"flows/key-material/v2">;
+                readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+                readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+                readonly body: Schema.Unknown;
+                readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                    readonly value: Schema.Unknown;
+                }>, Schema.TaggedStruct<"Ref", {
+                    readonly from: Schema.NonEmptyString;
+                    readonly path: Schema.$Array<Schema.String>;
+                }>, Schema.TaggedStruct<"Pending", {
+                    readonly from: Schema.NonEmptyString;
+                }>]>>;
+                readonly layers: Schema.$Array<Schema.String>;
+                readonly capabilities: Schema.$Array<Schema.String>;
+                readonly effects: Schema.optional<Schema.Unknown>;
+                readonly placement: Schema.optional<Schema.Unknown>;
+            }>;
+            readonly effects: Schema.Struct<{
+                readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>]>, Schema.TaggedStruct<"Filegroup", {
+                    readonly name: Schema.NonEmptyString;
+                    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>]>>;
+                }>]>>;
+                readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                    readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                    readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                }>, Schema.TaggedStruct<"TreeArtifact", {
+                    readonly path: Schema.NonEmptyString;
+                }>]>, Schema.TaggedStruct<"Filegroup", {
+                    readonly name: Schema.NonEmptyString;
+                    readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>, Schema.TaggedStruct<"TreeArtifact", {
+                        readonly path: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+                readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+            }>;
+            readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+            readonly conflicts: Schema.$Array<Schema.Struct<{
+                readonly with: Schema.NonEmptyString;
+                readonly paths: Schema.$Array<Schema.String>;
+                readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+            }>>;
+            readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+            readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+            readonly priority: Schema.Int;
+            readonly generation: Schema.Int;
+        }>>;
+        /**
+         * The labelled edges of the graph this plan was built from, and where its
+         * nodes were declared.
+         *
+         * Deliberately OUTSIDE the digest an approval binds to: the edges and the
+         * declaration sites describe the plan a reader draws, and nothing here
+         * changes what will run. The
+         * persisted plan's own digest already covers keys, edges, effects,
+         * conflicts, priorities and generations, so a host that starts reporting
+         * this field re-plans to the digest it planned to before and every parked
+         * approval still validates.
+         */
+        readonly graph: Schema.optional<Schema.Struct<{
+            readonly edges: Schema.$Array<Schema.Struct<{
+                readonly from: Schema.NonEmptyString;
+                readonly to: Schema.NonEmptyString;
+                readonly reason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+            }>>;
+            readonly nodes: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.NonEmptyString;
+                readonly declaredAt: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.NonEmptyString;
+                    readonly line: Schema.Int;
+                }>>;
+            }>>>;
+            /**
+             * The revision of the workspace those declaration sites were read out of.
+             *
+             * A site is a path and a line, and neither says which bytes were there: a
+             * host's working tree moves, so the same path after an edit or a branch
+             * switch is a different file. This is the immutable name of the tree the
+             * host loaded the flow from — a jj working-copy commit id, or a git commit
+             * for a tree that still matches one — and a reader asks the content route
+             * for the file AT this revision rather than for whatever is on disk now.
+             *
+             * A host that cannot name one reports nothing, and a reader that has
+             * nothing shows no code at all rather than code it cannot bind (D-068).
+             *
+             * Exactly the forty lowercase hex digits the only producer emits
+             * (`SourceRevision.objectId`), because the app puts this value straight
+             * into a contents route's `?ref=` and a route that spawns jj or git from it
+             * should never see anything else.
+             */
+            readonly sourceRevision: Schema.optional<Schema.NonEmptyString>;
+        }>>;
+        readonly approval: Schema.Struct<{
+            readonly target: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+                readonly planId: Schema.String;
+                readonly digest: Schema.String;
+                readonly envelope: Schema.Struct<{
+                    readonly capabilities: Schema.$Array<Schema.String>;
+                    /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                    readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                    readonly flows: Schema.$Array<Schema.String>;
+                    readonly budget: Schema.Struct<{
+                        readonly tokens: Schema.optional<Schema.Number>;
+                        readonly milliseconds: Schema.optional<Schema.Number>;
+                        readonly usd: Schema.optional<Schema.Number>;
+                        readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                        readonly deadline: Schema.optional<Schema.Int>;
+                    }>;
+                    readonly host: Schema.optional<Schema.String>;
+                }>;
+            }>, Schema.TaggedStruct<"Node", {
+                readonly runId: Schema.String;
+                readonly requestId: Schema.String;
+                readonly digest: Schema.String;
+                readonly envelope: Schema.Struct<{
+                    readonly capabilities: Schema.$Array<Schema.String>;
+                    /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                    readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                    readonly flows: Schema.$Array<Schema.String>;
+                    readonly budget: Schema.Struct<{
+                        readonly tokens: Schema.optional<Schema.Number>;
+                        readonly milliseconds: Schema.optional<Schema.Number>;
+                        readonly usd: Schema.optional<Schema.Number>;
+                        readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                        readonly deadline: Schema.optional<Schema.Int>;
+                    }>;
+                    readonly host: Schema.optional<Schema.String>;
+                }>;
+            }>]>;
+            readonly scope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+            readonly idempotencyKey: Schema.String;
+        }>;
+    }>;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly decision: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+}>;
+/**
+ * One stored plan as a listing reports it.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type PlanSummary = typeof PlanSummary.Type;
+/** Exact native observations, including unavailable evidence rather than a guessed lifecycle.
+ * @category schemas
+ * @since 1.0.0
+ */
+export declare const ExecutionBatch: Schema.Struct<{
+    readonly source: Schema.NullOr<Schema.String>;
+    readonly revision: Schema.NullOr<Schema.Int>;
+    readonly snapshots: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Observed", {
+        readonly executionId: Schema.String;
+        readonly source: Schema.String;
+        readonly revision: Schema.Int;
+        readonly observation: Schema.Struct<{
+            readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly flowName: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+            readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+            readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly roundOrdinal: Schema.Int;
+            readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+            readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+            readonly waiting: Schema.NullOr<Schema.Struct<{
+                readonly reason: Schema.NonEmptyString;
+                readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+        }>;
+    }>, Schema.TaggedStruct<"Missing", {
+        readonly executionId: Schema.String;
+        readonly source: Schema.String;
+        readonly revision: Schema.Int;
+        readonly deleted: Schema.Boolean;
+    }>, Schema.TaggedStruct<"Unavailable", {
+        readonly executionId: Schema.String;
+        readonly reason: Schema.Literals<readonly ["unsupported", "outside-run", "ancestry-unavailable"]>;
+    }>]>>;
+}>;
+/** Native execution observations with their source watermark.
+ * @category models
+ * @since 1.0.0
+ */
+export type ExecutionBatch = typeof ExecutionBatch.Type;
+/**
+ * A typed listing request for discovered flows, durable runs, registered
+ * triggers, the trigger fire ledger, or stored plans.
+ *
+ * `plans` lists stored plans oldest first, narrowed by flow and decision, so an
+ * operator can find what is waiting for approval: a build target declaring
+ * `approval: "required"` leaves a pending `system/target` plan. Plans are an
+ * operator's to read; a restricted reader lists none.
+ *
+ * `principalId` selects the runs whose `launchedBy.id` it names. It narrows a
+ * listing; it is not an authorization boundary. The server restricts a reader
+ * that does not see every run to the runs its own principal launched, whatever
+ * filter it sends.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ListRequest: Schema.Union<readonly [Schema.TaggedStruct<"executions", {
+    readonly runId: Schema.String;
+    readonly executionIds: Schema.$Array<Schema.NonEmptyString>;
+}>, Schema.TaggedStruct<"flows", {
+    readonly filters: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly cursor: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.TaggedStruct<"runs", {
+    readonly filters: Schema.optional<Schema.Struct<{
+        readonly runId: Schema.optional<Schema.String>;
+        readonly flowId: Schema.optional<Schema.String>;
+        readonly status: Schema.optional<Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>>;
+        readonly terminal: Schema.optional<Schema.Boolean>;
+        readonly principalId: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        /** Runs created at or after this epoch millisecond. */
+        readonly since: Schema.optional<Schema.Number>;
+        /** Runs created before this epoch millisecond. */
+        readonly until: Schema.optional<Schema.Number>;
+        /** Runs a fire of this trigger started. */
+        readonly triggerId: Schema.optional<Schema.String>;
+    }>>;
+    /** Creation time, newest or oldest first; omitted preserves the historical listing order. */
+    readonly order: Schema.optional<Schema.Literals<readonly ["newest", "oldest"]>>;
+    readonly cursor: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.TaggedStruct<"triggers", {
+    readonly filters: Schema.optional<Schema.Struct<{
+        readonly triggerId: Schema.optional<Schema.String>;
+        readonly flowId: Schema.optional<Schema.String>;
+        readonly enabled: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly cursor: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.TaggedStruct<"fires", {
+    readonly filters: Schema.optional<Schema.Struct<{
+        readonly triggerId: Schema.optional<Schema.String>;
+        readonly runId: Schema.optional<Schema.String>;
+        readonly outcome: Schema.optional<Schema.Literals<readonly ["launched", "completed", "skipped", "buffered", "superseded", "failed"]>>;
+    }>>;
+    readonly cursor: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>, Schema.TaggedStruct<"plans", {
+    readonly filters: Schema.optional<Schema.Struct<{
+        readonly flowId: Schema.optional<Schema.String>;
+        readonly decision: Schema.optional<Schema.Literals<readonly ["pending", "approved", "denied"]>>;
+    }>>;
+    readonly cursor: Schema.optional<Schema.String>;
+    readonly limit: Schema.optional<Schema.Int>;
+}>]>;
+/**
+ * A typed listing request for discovered flows, durable runs, registered
+ * triggers, the trigger fire ledger, or stored plans.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ListRequest = typeof ListRequest.Type;
+/**
+ * A typed page returned for a flow, run, trigger, fire, or plan listing.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const ListResponse: Schema.Union<readonly [Schema.TaggedStruct<"executions", {
+    readonly source: Schema.NullOr<Schema.String>;
+    readonly revision: Schema.NullOr<Schema.Int>;
+    readonly items: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Observed", {
+        readonly executionId: Schema.String;
+        readonly source: Schema.String;
+        readonly revision: Schema.Int;
+        readonly observation: Schema.Struct<{
+            readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly flowName: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+            readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+            readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+            readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+            readonly roundOrdinal: Schema.Int;
+            readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+            readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+            readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+            readonly waiting: Schema.NullOr<Schema.Struct<{
+                readonly reason: Schema.NonEmptyString;
+                readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+        }>;
+    }>, Schema.TaggedStruct<"Missing", {
+        readonly executionId: Schema.String;
+        readonly source: Schema.String;
+        readonly revision: Schema.Int;
+        readonly deleted: Schema.Boolean;
+    }>, Schema.TaggedStruct<"Unavailable", {
+        readonly executionId: Schema.String;
+        readonly reason: Schema.Literals<readonly ["unsupported", "outside-run", "ancestry-unavailable"]>;
+    }>]>>;
+    readonly nextCursor: Schema.optional<Schema.Never>;
+}>, Schema.TaggedStruct<"flows", {
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly flowId: Schema.String;
+        readonly description: Schema.String;
+        readonly inputSchema: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>;
+    readonly warnings: Schema.optional<Schema.$Array<typeof DiscoveryWarning>>;
+    readonly nextCursor: Schema.optional<Schema.String>;
+}>, Schema.TaggedStruct<"runs", {
+    readonly items: Schema.$Array<Schema.Struct<{
+        /** Whether lifecycle fields were observed in the engine or no engine row was visible. */
+        readonly executionObservation: Schema.optional<Schema.Literals<readonly ["observed", "missing"]>>;
+        /** Exact native semantic observation; never a control-stream fact. */
+        readonly executionView: Schema.optional<Schema.Struct<{
+            readonly root: Schema.Struct<{
+                readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly flowName: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+                readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+                readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+                readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly roundOrdinal: Schema.Int;
+                readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+                readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+                readonly waiting: Schema.NullOr<Schema.Struct<{
+                    readonly reason: Schema.NonEmptyString;
+                    readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                    readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>>;
+            }>;
+            readonly current: Schema.Struct<{
+                readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly flowName: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+                readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+                readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+                readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly roundOrdinal: Schema.Int;
+                readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+                readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+                readonly waiting: Schema.NullOr<Schema.Struct<{
+                    readonly reason: Schema.NonEmptyString;
+                    readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                    readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>>;
+            }>;
+            readonly humanWaits: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly flowName: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["pending", "running", "suspended", "completed", "failed", "cancelled"]>;
+                readonly createdAtMs: Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">;
+                readonly startedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly finishedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly parentRunId: Schema.NullOr<Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">>;
+                readonly lineageId: Schema.brand<Schema.String, "@smthrs/journal/JournalEvent/RunId">;
+                readonly roundOrdinal: Schema.Int;
+                readonly cancelRequestedAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                readonly treeVersion: Schema.optional<Schema.Literal<1>>;
+                readonly parentPolicy: Schema.optional<Schema.Literals<readonly ["cancel", "detach"]>>;
+                readonly waiting: Schema.NullOr<Schema.Struct<{
+                    readonly reason: Schema.NonEmptyString;
+                    readonly wakeAtMs: Schema.NullOr<Schema.brand<Schema.Int, "@smthrs/journal/TimestampMs">>;
+                    readonly tokenDigest: Schema.NullOr<Schema.NonEmptyString>;
+                    readonly point: Schema.optional<Schema.NullOr<Schema.String>>;
+                    readonly request: Schema.optional<Schema.NullOr<Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                }>>;
+            }>>>;
+        }>>;
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        /** The flow's executable identity when the run started; resume refuses a different one. */
+        readonly executionDigest: Schema.optional<Schema.String>;
+        /** The engine version that started the run. */
+        readonly engineVersion: Schema.optional<Schema.String>;
+        /**
+         * How the code that would resume this run differs from the code it
+         * recorded. Computed by an exact run lookup, never stored; absent when
+         * nothing changed or the run is terminal.
+         */
+        readonly codeDrift: Schema.optional<Schema.Struct<{
+            readonly recorded: Schema.optional<Schema.String>;
+            readonly current: Schema.optional<Schema.String>;
+            readonly recordedEngine: Schema.optional<Schema.String>;
+            readonly currentEngine: Schema.optional<Schema.String>;
+        }>>;
+        readonly ownerId: Schema.optional<Schema.String>;
+        /**
+         * The authenticated principal that launched this run through the control
+         * plane. A reader that does not see every run sees only the runs its own
+         * principal launched. Absent on a run the engine created (a child, a fork,
+         * a later trampoline round) and on a run launched before it was recorded;
+         * only a reader that sees every run sees those.
+         */
+        readonly launchedBy: Schema.optional<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+        }>>;
+        /**
+         * The run this one branched from: the spawning run, the forked-from run, or
+         * the previous trampoline round. Absent on a run with no ancestor.
+         */
+        readonly parentRunId: Schema.optional<Schema.String>;
+        /**
+         * The trampoline lineage this run is a round of, and which round it is.
+         * Both absent means a lineage of one, read as round 0 of itself.
+         */
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly origin: Schema.optional<Schema.Literals<readonly ["child", "fork", "continuation"]>>;
+        /**
+         * What a parked run is holding on: `approval`, `event`, `timer`, `quota`, or
+         * a reason a plugin declared. Absent on a run that is not parked, and on a
+         * park whose owner released the run without declaring one.
+         *
+         * The CLI's `ps` and `status` listings also render `executor` here for a run
+         * that has sat at `accepted` with no owner process past the launch handoff
+         * window. That value is computed at render time and never stored, so a
+         * reader going through the control RPC, the gateway projection, or a plugin
+         * sees the field absent on the same run.
+         */
+        readonly waitingReason: Schema.optional<Schema.String>;
+        /** What has been steered to this run and not yet delivered. */
+        readonly steering: Schema.optional<Schema.Struct<{
+            readonly pending: Schema.Number;
+        }>>;
+        /**
+         * A resume this run has been told to take and no host has taken up yet.
+         *
+         * A decision on an in-run approval restarts the run server-side, and the
+         * process that decides is usually not the process that hosts the execution:
+         * an operator's `smithers approve`, a gateway, a second CLI. The intent is
+         * therefore recorded durably here, and the host that owns the execution
+         * takes it up on its next tick and clears it. The number is the durable
+         * sequence of the request, so an operator can tell a delegation that is
+         * still outstanding from one that has been taken up. Absent means nothing
+         * is waiting to be taken up.
+         */
+        readonly pendingResume: Schema.optional<Schema.Number>;
+        /**
+         * The executor claim this run was parked under.
+         *
+         * A parked execution releases its owner columns — that is what makes it
+         * resumable at all — so after a park nothing on the row says which process
+         * is hosting it. Every process that shares the databases can therefore see
+         * the parked execution and resume it, including a short-lived `smithers
+         * approve` that would drive the run and then exit. The fence the park was
+         * written under is recorded here instead, so the host that parked the run
+         * recognizes its own park and every other composition can tell that the
+         * execution is not its to take up (triage B-15). Absent on a run that is not
+         * parked, and on a park written by something that held no fence.
+         */
+        readonly parkedBy: Schema.optional<Schema.String>;
+        /** Who cancelled this run, why, and on whose behalf. Absent until one did. */
+        readonly cancellation: Schema.optional<Schema.Struct<{
+            readonly requestedAt: Schema.Number;
+            readonly source: Schema.Literals<readonly ["control", "engine", "cascade"]>;
+            readonly principal: Schema.optional<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.String;
+                readonly stampedAt: Schema.Number;
+            }>>;
+            readonly reason: Schema.optional<Schema.String>;
+            /** The cancelled ancestor this run was swept up with, on a cascade. */
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        /**
+         * Open human waits anywhere in this run's tree, nearest execution first.
+         *
+         * Present only when there is at least one, so a run nobody owes an answer
+         * carries no field rather than an empty array. `status` rolls up with it:
+         * a run any of whose descendants is parked on `approval` reports
+         * `waiting-approval`, which is what the existing inbox filters select on.
+         */
+        readonly pendingWaits: Schema.optional<Schema.$Array<Schema.Struct<{
+            /** The execution parked on this wait, which may be the root run itself. */
+            readonly runId: Schema.String;
+            /** The flow that execution is running. */
+            readonly flowId: Schema.optional<Schema.String>;
+            /** The supervisor vocabulary: `approval` for people or `event` for a named signal. */
+            readonly reason: Schema.String;
+            /** The durable wait address a decision is routed to. */
+            readonly token: Schema.String;
+            /** Digest used to join replayed display facts to this current operational address. */
+            readonly tokenDigest: Schema.optional<Schema.String>;
+            /** The wait point's own name, when the token addresses a named one. */
+            readonly name: Schema.optional<Schema.String>;
+            /** Which attempt of a re-asked question this is, counting from 1. */
+            readonly attempt: Schema.optional<Schema.Number>;
+            /** What the wait declared about itself, absent when it declared nothing. */
+            readonly request: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            /** When the execution holding this wait was created. */
+            readonly createdAt: Schema.Number;
+        }>>>;
+        /**
+         * When the run's approved deadline passes: its `createdAt` plus the
+         * envelope's `budget.deadline`, which is the instant the run is failed with
+         * `deadline_exceeded` if it has not settled. Absent on a run approved with
+         * no deadline.
+         */
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+    }>>;
+    readonly nextCursor: Schema.optional<Schema.String>;
+}>, Schema.TaggedStruct<"triggers", {
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly triggerId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly cron: Schema.String;
+        readonly timezone: Schema.optional<Schema.String>;
+        readonly overlap: Schema.Literals<readonly ["skip", "buffer-one", "supersede"]>;
+        readonly catchUp: Schema.Literals<readonly ["none", "one", "all"]>;
+        readonly maxCatchUp: Schema.optional<Schema.Number>;
+        readonly enabled: Schema.Boolean;
+        readonly revision: Schema.Number;
+        readonly lastFiredAtMs: Schema.optional<Schema.Number>;
+        readonly pendingAtMs: Schema.optional<Schema.Number>;
+        readonly activeRunId: Schema.optional<Schema.String>;
+        readonly nextOccurrencesMs: Schema.$Array<Schema.Number>;
+        readonly schedulerLastTickMs: Schema.optional<Schema.Number>;
+    }>>;
+    readonly nextCursor: Schema.optional<Schema.String>;
+}>, Schema.TaggedStruct<"fires", {
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly triggerId: Schema.String;
+        readonly occurrenceAtMs: Schema.Number;
+        readonly outcome: Schema.NullOr<Schema.Literals<readonly ["launched", "completed", "skipped", "buffered", "superseded", "failed"]>>;
+        readonly runId: Schema.optional<Schema.String>;
+        readonly error: Schema.optional<Schema.String>;
+        readonly waiting: Schema.optional<Schema.Literal<"approval">>;
+    }>>;
+    readonly nextCursor: Schema.optional<Schema.String>;
+}>, Schema.TaggedStruct<"plans", {
+    readonly items: Schema.$Array<Schema.Struct<{
+        readonly card: Schema.Struct<{
+            readonly planId: Schema.String;
+            readonly flowId: Schema.String;
+            readonly digest: Schema.String;
+            readonly inputSummary: Schema.String;
+            /** Discovery diagnostics for the selected flow; outside the approval identity. */
+            readonly warnings: Schema.optional<Schema.$Array<typeof DiscoveryWarning>>;
+            readonly envelope: Schema.Struct<{
+                readonly capabilities: Schema.$Array<Schema.String>;
+                /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                readonly flows: Schema.$Array<Schema.String>;
+                readonly budget: Schema.Struct<{
+                    readonly tokens: Schema.optional<Schema.Number>;
+                    readonly milliseconds: Schema.optional<Schema.Number>;
+                    readonly usd: Schema.optional<Schema.Number>;
+                    readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                    readonly deadline: Schema.optional<Schema.Int>;
+                }>;
+                readonly host: Schema.optional<Schema.String>;
+            }>;
+            readonly deployClass: Schema.Boolean;
+            /** Executable source/metadata identity supplied by a discovery-based host. */
+            readonly executionDigest: Schema.optional<Schema.String>;
+            readonly plan: Schema.optional<Schema.Struct<{
+                readonly planId: Schema.NonEmptyString;
+                readonly flow: Schema.NonEmptyString;
+                readonly generation: Schema.Int;
+                readonly baseDigest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+                readonly digest: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+                readonly nodes: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.NonEmptyString;
+                    readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+                    readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+                    readonly material: Schema.Struct<{
+                        readonly version: Schema.Literal<"flows/key-material/v2">;
+                        readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+                        readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+                        readonly body: Schema.Unknown;
+                        readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                            readonly value: Schema.Unknown;
+                        }>, Schema.TaggedStruct<"Ref", {
+                            readonly from: Schema.NonEmptyString;
+                            readonly path: Schema.$Array<Schema.String>;
+                        }>, Schema.TaggedStruct<"Pending", {
+                            readonly from: Schema.NonEmptyString;
+                        }>]>>;
+                        readonly layers: Schema.$Array<Schema.String>;
+                        readonly capabilities: Schema.$Array<Schema.String>;
+                        readonly effects: Schema.optional<Schema.Unknown>;
+                        readonly placement: Schema.optional<Schema.Unknown>;
+                    }>;
+                    readonly effects: Schema.Struct<{
+                        readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>]>, Schema.TaggedStruct<"Filegroup", {
+                            readonly name: Schema.NonEmptyString;
+                            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                            }>]>>;
+                        }>]>>;
+                        readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>, Schema.TaggedStruct<"TreeArtifact", {
+                            readonly path: Schema.NonEmptyString;
+                        }>]>, Schema.TaggedStruct<"Filegroup", {
+                            readonly name: Schema.NonEmptyString;
+                            readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                                readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                                readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                            }>, Schema.TaggedStruct<"TreeArtifact", {
+                                readonly path: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                        readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+                    }>;
+                    readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+                    readonly conflicts: Schema.$Array<Schema.Struct<{
+                        readonly with: Schema.NonEmptyString;
+                        readonly paths: Schema.$Array<Schema.String>;
+                        readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                        readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                    }>>;
+                    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                    readonly priority: Schema.Int;
+                    readonly generation: Schema.Int;
+                }>>;
+            }>>;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly status: Schema.Literals<readonly ["cached", "run"]>;
+                readonly id: Schema.NonEmptyString;
+                readonly kind: Schema.Literals<readonly ["step", "agent", "merge"]>;
+                readonly key: Schema.brand<Schema.String, "@smthrs/keys/Key">;
+                readonly material: Schema.Struct<{
+                    readonly version: Schema.Literal<"flows/key-material/v2">;
+                    readonly kind: Schema.Literals<readonly ["sealed", "compensable", "irreversible"]>;
+                    readonly nondeterministic: Schema.optional<Schema.Literal<true>>;
+                    readonly body: Schema.Unknown;
+                    readonly inputs: Schema.$Array<Schema.Union<readonly [Schema.TaggedStruct<"Literal", {
+                        readonly value: Schema.Unknown;
+                    }>, Schema.TaggedStruct<"Ref", {
+                        readonly from: Schema.NonEmptyString;
+                        readonly path: Schema.$Array<Schema.String>;
+                    }>, Schema.TaggedStruct<"Pending", {
+                        readonly from: Schema.NonEmptyString;
+                    }>]>>;
+                    readonly layers: Schema.$Array<Schema.String>;
+                    readonly capabilities: Schema.$Array<Schema.String>;
+                    readonly effects: Schema.optional<Schema.Unknown>;
+                    readonly placement: Schema.optional<Schema.Unknown>;
+                }>;
+                readonly effects: Schema.Struct<{
+                    readonly reads: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>]>, Schema.TaggedStruct<"Filegroup", {
+                        readonly name: Schema.NonEmptyString;
+                        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>]>>;
+                    }>]>>;
+                    readonly writes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                        readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                        readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    }>, Schema.TaggedStruct<"TreeArtifact", {
+                        readonly path: Schema.NonEmptyString;
+                    }>]>, Schema.TaggedStruct<"Filegroup", {
+                        readonly name: Schema.NonEmptyString;
+                        readonly entries: Schema.$Array<Schema.Union<readonly [Schema.NonEmptyString, Schema.TaggedStruct<"Glob", {
+                            readonly include: Schema.NonEmptyArray<Schema.NonEmptyString>;
+                            readonly exclude: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                        }>, Schema.TaggedStruct<"TreeArtifact", {
+                            readonly path: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                    readonly removes: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly boundaryMode: Schema.Literals<readonly ["hard", "expected"]>;
+                }>;
+                readonly dependsOn: Schema.$Array<Schema.NonEmptyString>;
+                readonly conflicts: Schema.$Array<Schema.Struct<{
+                    readonly with: Schema.NonEmptyString;
+                    readonly paths: Schema.$Array<Schema.String>;
+                    readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                    readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                }>>;
+                readonly strategy: Schema.Literals<readonly ["serialize", "lane", "fail"]>;
+                readonly runtime: Schema.Literals<readonly ["delay-rebase", "stop-merge"]>;
+                readonly priority: Schema.Int;
+                readonly generation: Schema.Int;
+            }>>;
+            /**
+             * The labelled edges of the graph this plan was built from, and where its
+             * nodes were declared.
+             *
+             * Deliberately OUTSIDE the digest an approval binds to: the edges and the
+             * declaration sites describe the plan a reader draws, and nothing here
+             * changes what will run. The
+             * persisted plan's own digest already covers keys, edges, effects,
+             * conflicts, priorities and generations, so a host that starts reporting
+             * this field re-plans to the digest it planned to before and every parked
+             * approval still validates.
+             */
+            readonly graph: Schema.optional<Schema.Struct<{
+                readonly edges: Schema.$Array<Schema.Struct<{
+                    readonly from: Schema.NonEmptyString;
+                    readonly to: Schema.NonEmptyString;
+                    readonly reason: Schema.Literals<readonly ["value", "continuation", "failure", "conflict", "lane-merge"]>;
+                }>>;
+                readonly nodes: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.NonEmptyString;
+                    readonly declaredAt: Schema.optionalKey<Schema.Struct<{
+                        readonly path: Schema.NonEmptyString;
+                        readonly line: Schema.Int;
+                    }>>;
+                }>>>;
+                /**
+                 * The revision of the workspace those declaration sites were read out of.
+                 *
+                 * A site is a path and a line, and neither says which bytes were there: a
+                 * host's working tree moves, so the same path after an edit or a branch
+                 * switch is a different file. This is the immutable name of the tree the
+                 * host loaded the flow from — a jj working-copy commit id, or a git commit
+                 * for a tree that still matches one — and a reader asks the content route
+                 * for the file AT this revision rather than for whatever is on disk now.
+                 *
+                 * A host that cannot name one reports nothing, and a reader that has
+                 * nothing shows no code at all rather than code it cannot bind (D-068).
+                 *
+                 * Exactly the forty lowercase hex digits the only producer emits
+                 * (`SourceRevision.objectId`), because the app puts this value straight
+                 * into a contents route's `?ref=` and a route that spawns jj or git from it
+                 * should never see anything else.
+                 */
+                readonly sourceRevision: Schema.optional<Schema.NonEmptyString>;
+            }>>;
+            readonly approval: Schema.Struct<{
+                readonly target: Schema.Union<readonly [Schema.TaggedStruct<"Plan", {
+                    readonly planId: Schema.String;
+                    readonly digest: Schema.String;
+                    readonly envelope: Schema.Struct<{
+                        readonly capabilities: Schema.$Array<Schema.String>;
+                        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly flows: Schema.$Array<Schema.String>;
+                        readonly budget: Schema.Struct<{
+                            readonly tokens: Schema.optional<Schema.Number>;
+                            readonly milliseconds: Schema.optional<Schema.Number>;
+                            readonly usd: Schema.optional<Schema.Number>;
+                            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                            readonly deadline: Schema.optional<Schema.Int>;
+                        }>;
+                        readonly host: Schema.optional<Schema.String>;
+                    }>;
+                }>, Schema.TaggedStruct<"Node", {
+                    readonly runId: Schema.String;
+                    readonly requestId: Schema.String;
+                    readonly digest: Schema.String;
+                    readonly envelope: Schema.Struct<{
+                        readonly capabilities: Schema.$Array<Schema.String>;
+                        /** Unrestricted builtin/addon/package imports, outside the guarded capability ceiling. */
+                        readonly hostImports: Schema.optional<Schema.$Array<Schema.String>>;
+                        readonly flows: Schema.$Array<Schema.String>;
+                        readonly budget: Schema.Struct<{
+                            readonly tokens: Schema.optional<Schema.Number>;
+                            readonly milliseconds: Schema.optional<Schema.Number>;
+                            readonly usd: Schema.optional<Schema.Number>;
+                            readonly onExceeded: Schema.optional<Schema.Literals<readonly ["fail", "warn", "skip-remaining", "park"]>>;
+                            readonly deadline: Schema.optional<Schema.Int>;
+                        }>;
+                        readonly host: Schema.optional<Schema.String>;
+                    }>;
+                }>]>;
+                readonly scope: Schema.Literals<readonly ["once", "run", "remembered"]>;
+                readonly idempotencyKey: Schema.String;
+            }>;
+        }>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly decision: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+    }>>;
+    readonly nextCursor: Schema.optional<Schema.String>;
+}>]>;
+/**
+ * A typed page returned for a flow, run, trigger, fire, or plan listing.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type ListResponse = typeof ListResponse.Type;
+/**
+ * A live process that hosts a run: its machine and process id.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const RunHost: Schema.Struct<{
+    readonly hostId: Schema.String;
+    readonly pid: Schema.Number;
+}>;
+/**
+ * A live process that hosts a run: its machine and process id.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type RunHost = typeof RunHost.Type;
+/**
+ * The idempotent outcome returned by every control mutation.
+ *
+ * An `Accepted` resume with `handedTo` was not claimed by the caller: the live
+ * process that parked the run takes it up and drives it.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare const Receipt: Schema.Union<readonly [Schema.TaggedStruct<"Accepted", {
+    readonly inputConsumed: Schema.optional<Schema.Boolean>;
+    readonly inputBody: Schema.optional<Schema.String>;
+    readonly receiptId: Schema.String;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly handedTo: Schema.optional<Schema.Struct<{
+        readonly hostId: Schema.String;
+        readonly pid: Schema.Number;
+    }>>;
+}>, Schema.TaggedStruct<"AlreadyApplied", {
+    readonly receiptId: Schema.String;
+    readonly runId: Schema.optional<Schema.String>;
+    readonly inputConsumed: Schema.optional<Schema.Boolean>;
+    readonly inputBody: Schema.optional<Schema.String>;
+}>, Schema.TaggedStruct<"Parked", {
+    readonly receiptId: Schema.String;
+    readonly planId: Schema.String;
+    readonly status: Schema.Literal<"waiting-approval">;
+}>, Schema.TaggedStruct<"Conflict", {
+    readonly message: Schema.String;
+}>, Schema.TaggedStruct<"Terminal", {
+    readonly runId: Schema.String;
+    readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+}>]>;
+/**
+ * The idempotent outcome returned by every control mutation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type Receipt = typeof Receipt.Type;
+//# sourceMappingURL=ControlSchema.d.ts.map