@smthrs/gateway 0.35.0 → 1.0.0-rc.3

package/dist/esm/GatewayRpcs.d.ts

@@ -0,0 +1,1886 @@
+/**
+ * The gateway's own remote procedures: the served read path, and the one
+ * composite mutation a product client cannot assemble safely on its own.
+ *
+ * Control mutations are not re-declared here. `@smthrs/control` `ControlRpcs`
+ * is the mutation contract and the gateway mounts it unchanged at `/rpc`, so
+ * there is exactly one wire definition of `Plan`, `Run`, `Approve`, `Deny`,
+ * `Cancel`, `Signal`, `Steer`, `Resume`, `List`, and `Watch`.
+ *
+ * The group shares `ControlRpcs.ControlAuth`, so one bearer credential
+ * authenticates both mounts and one server-stamped principal is recorded for
+ * whatever it authorizes.
+ *
+ * @since 1.0.0
+ */
+import { ControlError, ControlRpcs } from "@smthrs/control";
+import { Schema } from "effect";
+import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { GatewayError } from "./GatewayError.ts";
+import * as RunHistory from "./RunHistory.ts";
+/**
+ * The decision a client submits for one approval.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const Decision: Schema.Literals<readonly ["approve", "deny"]>;
+/**
+ * The decision a client submits for one approval.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type Decision = typeof Decision.Type;
+/**
+ * One approval decision, submitted with the exact payload the run published.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const SubmitApprovalInput: Schema.Struct<{
+    readonly decision: Schema.Literals<readonly ["approve", "deny"]>;
+    /**
+     * The answer to a question, for a gate that asks one.
+     *
+     * Most gates are a grant: approve or deny, and the decision IS the payload.
+     * A `HumanTask` gate asks for a value — prose, a choice, a JSON object — and
+     * the decision alone answers nothing. Present exactly when the row being
+     * submitted is one of those, in which case `target.requestId` names the wait
+     * point and this is what is delivered to it. A denial carries no answer: the
+     * question is refused, not answered.
+     *
+     * Additive on purpose: a client that never asks a person anything submits
+     * exactly what it submitted before.
+     */
+    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    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>;
+            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>;
+            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;
+}>;
+/**
+ * One approval decision, submitted with the exact payload the run published.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type SubmitApprovalInput = typeof SubmitApprovalInput.Type;
+/**
+ * What submitting an approval did.
+ *
+ * `decision` is the receipt for the grant or refusal. Control owns the
+ * decision and its durable resume delegation as one domain command.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export declare const SubmitApprovalOutput: Schema.Struct<{
+    readonly decision: 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"]>;
+    }>]>;
+}>;
+/**
+ * What submitting an approval did.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export type SubmitApprovalOutput = typeof SubmitApprovalOutput.Type;
+/**
+ * The gateway read path, the composite approval mutation, and the run
+ * history procedures.
+ *
+ * `Approval.Submit` is the transport form of Control's single decision
+ * command. Control records the decision and durable resume delegation; the
+ * gateway never composes a second mutation.
+ *
+ * @since 1.0.0
+ * @category groups
+ */
+export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot", Schema.Struct<{
+    readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>, Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>]>;
+    readonly after: Schema.optional<Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>>;
+}>, Schema.Union<readonly [Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        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>;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly sequence: Schema.Number;
+        readonly turn: Schema.Number;
+        readonly at: Schema.Number;
+        readonly kind: Schema.String;
+        readonly callId: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly label: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly startedAt: Schema.Number;
+        readonly endedAt: Schema.optional<Schema.Number>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly waitRunId: Schema.optional<Schema.String>;
+        readonly questionProvenance: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+        readonly requestId: Schema.String;
+        readonly title: Schema.String;
+        readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly payload: 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>;
+                    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>;
+                    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 requestedAt: Schema.Number;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["success", "failure"]>;
+        readonly output: Schema.String;
+        readonly settledAt: Schema.Number;
+    }>>;
+}>, Schema.Struct<{
+    readonly selector: Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly flowId: Schema.String;
+        readonly actionTag: Schema.String;
+        readonly samples: Schema.Number;
+        readonly p50Ms: Schema.Number;
+        readonly p90Ms: Schema.Number;
+    }>>;
+}>]>, typeof GatewayError, typeof ControlRpcs.ControlAuth, never> | Rpc.Rpc<"Projection.Subscribe", Schema.Struct<{
+    readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>, Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>]>;
+    readonly after: Schema.optional<Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>>;
+}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Union<readonly [Schema.TaggedStruct<"snapshot-start", {
+    readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>, Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>]>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        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>;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly sequence: Schema.Number;
+        readonly turn: Schema.Number;
+        readonly at: Schema.Number;
+        readonly kind: Schema.String;
+        readonly callId: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly label: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly startedAt: Schema.Number;
+        readonly endedAt: Schema.optional<Schema.Number>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly waitRunId: Schema.optional<Schema.String>;
+        readonly questionProvenance: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+        readonly requestId: Schema.String;
+        readonly title: Schema.String;
+        readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly payload: 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>;
+                    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>;
+                    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 requestedAt: Schema.Number;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["success", "failure"]>;
+        readonly output: Schema.String;
+        readonly settledAt: Schema.Number;
+    }>;
+}>, Schema.TaggedStruct<"row", {
+    readonly selector: Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly row: Schema.Struct<{
+        readonly flowId: Schema.String;
+        readonly actionTag: Schema.String;
+        readonly samples: Schema.Number;
+        readonly p50Ms: Schema.Number;
+        readonly p90Ms: Schema.Number;
+    }>;
+}>, Schema.TaggedStruct<"snapshot-end", {
+    readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>, Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>, Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>, Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>, Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>]>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"workspace-runs", {
+        readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"run-summary", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly flowId: Schema.String;
+        readonly statusRollup: Schema.optional<Schema.Struct<{
+            readonly subjectId: Schema.String;
+            readonly state: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "completed", "failed", "cancelled", "spawning", "exited"]>;
+            readonly activity: Schema.Literals<readonly ["working", "idle", "needs-input", "unknown"]>;
+            readonly health: Schema.Literals<readonly ["healthy", "stalled", "wedged-node", "runaway-loop", "awaiting-human", "failing", "unknown"]>;
+            readonly attention: Schema.Literals<readonly ["none", "awaiting-approval", "needs-input", "needs-resume", "unhealthy"]>;
+            readonly freshness: Schema.Literals<readonly ["fresh", "stale", "unobserved"]>;
+            readonly reason: Schema.optional<Schema.Literals<readonly ["ok", "no-progress", "awaiting-reply", "prompt-detected", "quota-wait", "timer-wait", "event-wait", "released", "unreachable", "probe-timeout", "probe-error", "owner-changed"]>>;
+            readonly provenance: Schema.optional<Schema.Struct<{
+                readonly checkerId: Schema.String;
+                readonly monitorId: Schema.String;
+                readonly observedAt: Schema.Int;
+                readonly expiresAt: Schema.Int;
+                readonly evidenceSeq: Schema.Int;
+                readonly incarnation: Schema.String;
+                readonly version: Schema.Int;
+            }>>;
+            readonly updatedAt: Schema.Int;
+        }>>;
+        readonly status: Schema.Literals<readonly ["accepted", "running", "parked", "waiting-approval", "cancelled", "completed", "failed"]>;
+        readonly lifecycleProvenance: Schema.optional<Schema.Struct<{
+            readonly control: Schema.Literals<readonly ["events", "legacy-snapshot", "unverified-snapshot"]>;
+            readonly execution: Schema.Literals<readonly ["control", "engine-observed", "engine-missing"]>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly executionProvenance: Schema.optional<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>;
+            readonly rootExecutionId: Schema.String;
+            readonly humanWaits: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+            readonly humanWaitSources: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly executionId: Schema.String;
+                readonly generation: Schema.Number;
+                readonly baseline: Schema.Literals<readonly ["created", "legacy"]>;
+                readonly fromSequence: Schema.Number;
+                readonly throughSequence: Schema.Number;
+            }>>>;
+            readonly currentExecutionId: Schema.optional<Schema.String>;
+            readonly generation: Schema.optional<Schema.Number>;
+            readonly baseline: Schema.optional<Schema.Literals<readonly ["created", "legacy"]>>;
+            readonly fromSequence: Schema.optional<Schema.Number>;
+            readonly throughSequence: Schema.optional<Schema.Number>;
+        }>>;
+        readonly createdAt: Schema.Number;
+        readonly updatedAt: Schema.Number;
+        readonly planId: Schema.optional<Schema.String>;
+        readonly planDigest: Schema.optional<Schema.String>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+        readonly lineageId: Schema.optional<Schema.String>;
+        readonly roundOrdinal: Schema.optional<Schema.Number>;
+        readonly waitingReason: Schema.optional<Schema.String>;
+        readonly steeringPending: Schema.optional<Schema.Number>;
+        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>;
+            readonly cascadedFrom: Schema.optional<Schema.String>;
+        }>>;
+        readonly deadlineAt: Schema.optional<Schema.Number>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly turns: Schema.Number;
+        readonly calls: Schema.Number;
+        readonly callsFailed: Schema.Number;
+        readonly editsAttempted: Schema.Number;
+        readonly editsSucceeded: Schema.Number;
+        readonly inputTokens: Schema.Number;
+        readonly outputTokens: Schema.Number;
+        readonly verdict: Schema.String;
+        readonly diagnosis: Schema.String;
+        readonly finalOutput: Schema.optional<Schema.String>;
+        readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureTag: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"run-events", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        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>;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"transcript", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly sequence: Schema.Number;
+        readonly turn: Schema.Number;
+        readonly at: Schema.Number;
+        readonly kind: Schema.String;
+        readonly callId: Schema.optional<Schema.String>;
+        readonly text: Schema.String;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"run-tree", {
+        readonly runId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly label: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+        readonly seat: Schema.optional<Schema.String>;
+        readonly startedAt: Schema.Number;
+        readonly endedAt: Schema.optional<Schema.Number>;
+        readonly parentRunId: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"approvals", {
+        readonly runId: Schema.optional<Schema.String>;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly waitRunId: Schema.optional<Schema.String>;
+        readonly questionProvenance: Schema.optional<Schema.Literals<readonly ["events", "legacy-observation", "unverified-observation"]>>;
+        readonly requestId: Schema.String;
+        readonly title: Schema.String;
+        readonly request: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly payload: 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>;
+                    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>;
+                    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 requestedAt: Schema.Number;
+        readonly status: Schema.Literals<readonly ["pending", "approved", "denied"]>;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"node-output", {
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly runId: Schema.String;
+        readonly nodeId: Schema.String;
+        readonly outcome: Schema.Literals<readonly ["success", "failure"]>;
+        readonly output: Schema.String;
+        readonly settledAt: Schema.Number;
+    }>>;
+}>, Schema.TaggedStruct<"delta", {
+    readonly selector: Schema.TaggedStruct<"flow-durations", {
+        readonly flowId: Schema.String;
+    }>;
+    readonly cursor: Schema.Struct<{
+        readonly selector: Schema.Union<readonly [Schema.TaggedStruct<"workspace-runs", {
+            readonly flowId: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.TaggedStruct<"run-summary", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-events", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"transcript", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"run-tree", {
+            readonly runId: Schema.String;
+        }>, Schema.TaggedStruct<"approvals", {
+            readonly runId: Schema.optional<Schema.String>;
+        }>, Schema.TaggedStruct<"node-output", {
+            readonly runId: Schema.String;
+            readonly nodeId: Schema.String;
+        }>, Schema.TaggedStruct<"flow-durations", {
+            readonly flowId: Schema.String;
+        }>]>;
+        readonly projection: Schema.Literals<readonly ["workspace-runs", "run-summary", "run-events", "transcript", "run-tree", "approvals", "node-output", "flow-durations"]>;
+        readonly runId: Schema.NullOr<Schema.String>;
+        readonly value: Schema.Int;
+        readonly offset: Schema.Int;
+    }>;
+    readonly delta: Schema.$Array<Schema.Struct<{
+        readonly flowId: Schema.String;
+        readonly actionTag: Schema.String;
+        readonly samples: Schema.Number;
+        readonly p50Ms: Schema.Number;
+        readonly p90Ms: Schema.Number;
+    }>>;
+}>, Schema.TaggedStruct<"heartbeat", {
+    readonly atMs: Schema.Number;
+}>]>, typeof GatewayError>, Schema.Never, typeof ControlRpcs.ControlAuth, never> | Rpc.Rpc<"Approval.Submit", Schema.Struct<{
+    readonly decision: Schema.Literals<readonly ["approve", "deny"]>;
+    /**
+     * The answer to a question, for a gate that asks one.
+     *
+     * Most gates are a grant: approve or deny, and the decision IS the payload.
+     * A `HumanTask` gate asks for a value — prose, a choice, a JSON object — and
+     * the decision alone answers nothing. Present exactly when the row being
+     * submitted is one of those, in which case `target.requestId` names the wait
+     * point and this is what is delivered to it. A denial carries no answer: the
+     * question is refused, not answered.
+     *
+     * Additive on purpose: a client that never asks a person anything submits
+     * exactly what it submitted before.
+     */
+    readonly answer: Schema.optional<Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    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>;
+            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>;
+            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;
+}>, Schema.Struct<{
+    readonly decision: 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"]>;
+    }>]>;
+}>, Schema.Union<readonly [typeof ControlError.NoMatchingWait, typeof ControlError.CodeDrift, typeof ControlError.PlanDigestMismatch, typeof ControlError.EnvelopeMismatch, typeof ControlError.AlreadyResolved, typeof ControlError.PlanNotFound, typeof ControlError.RunNotFound, typeof ControlError.InvalidInput, typeof ControlError.Unauthorized, typeof ControlError.PersistenceError, typeof ControlError.Unavailable, typeof ControlError.TransportError]>, typeof ControlRpcs.ControlAuth, never> | Rpc.Rpc<"Run.Fork", Schema.Struct<{
+    readonly runId: Schema.NonEmptyString;
+    readonly at: Schema.Int;
+    readonly lineage: Schema.optional<Schema.NonEmptyString>;
+    readonly step: Schema.optional<Schema.Struct<{
+        readonly stepKeyDigest: Schema.NonEmptyString;
+        readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>;
+}>, Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly parentRunId: Schema.String;
+    readonly status: Schema.Literal<"parked">;
+}>, Schema.Union<readonly [typeof RunHistory.HistoryRefused, typeof ControlError.Unauthorized, typeof ControlError.Unavailable]>, typeof ControlRpcs.ControlAuth, never> | Rpc.Rpc<"Run.Verify", Schema.Struct<{
+    readonly runId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly runId: Schema.String;
+    readonly verdict: Schema.Literals<readonly ["consistent", "divergent"]>;
+    readonly replayed: Schema.$Array<Schema.Struct<{
+        readonly stepKeyDigest: Schema.String;
+        readonly action: Schema.optional<Schema.String>;
+        readonly node: Schema.optional<Schema.String>;
+    }>>;
+    readonly resumes: Schema.optional<Schema.Struct<{
+        readonly stepKeyDigest: Schema.String;
+        readonly action: Schema.optional<Schema.String>;
+        readonly node: Schema.optional<Schema.String>;
+    }>>;
+    readonly executes: Schema.optional<Schema.Struct<{
+        readonly stepKeyDigest: Schema.String;
+        readonly action: Schema.optional<Schema.String>;
+        readonly node: Schema.optional<Schema.String>;
+    }>>;
+    readonly notReplayed: Schema.$Array<Schema.Struct<{
+        readonly stepKeyDigest: Schema.String;
+        readonly action: Schema.optional<Schema.String>;
+        readonly node: Schema.optional<Schema.String>;
+    }>>;
+}>, Schema.Union<readonly [typeof RunHistory.HistoryRefused, typeof ControlError.Unauthorized, typeof ControlError.Unavailable]>, typeof ControlRpcs.ControlAuth, never>>;
+//# sourceMappingURL=GatewayRpcs.d.ts.map